    001/*
    002 * Copyright (c) 2009 The openGion Project.
    003 *
    004 * Licensed under the Apache License, Version 2.0 (the "License");
    005 * you may not use this file except in compliance with the License.
    006 * You may obtain a copy of the License at
    007 *
    008 *     http://www.apache.org/licenses/LICENSE-2.0
    009 *
    010 * Unless required by applicable law or agreed to in writing, software
    011 * distributed under the License is distributed on an "AS IS" BASIS,
    012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
    013 * either express or implied. See the License for the specific language
    014 * governing permissions and limitations under the License.
    015 */
    016package org.opengion.fukurou.util;
    017
    018import org.opengion.fukurou.system.OgRuntimeException;          // 6.4.2.0 (2016/01/29)
    019import java.lang.reflect.InvocationTargetException;                     // 7.0.0.0
    020import java.io.UnsupportedEncodingException;
    021import java.net.URLEncoder;
    022import java.net.URLDecoder;
    023import java.util.ArrayList;
    024import java.util.Arrays;
    025import java.util.Enumeration;
    026import java.util.StringJoiner;                                                          // 6.4.4.2 (2016/04/01)
    027import java.util.concurrent.ConcurrentMap;                                      // 6.4.3.3 (2016/03/04)
    028import java.util.concurrent.ConcurrentHashMap;                          // 6.4.3.1 (2016/02/12) refactoring
    029import java.util.Iterator;
    030import java.util.StringTokenizer;
    031import java.util.Locale;                                                                        // 5.7.2.3 (2014/01/31)
    032import java.text.DecimalFormat;                                                         // 6.2.0.0 (2015/02/27)
    033import java.util.function.UnaryOperator;                                        // 6.9.2.1 (2018/03/12)
    034import java.util.function.Consumer;                                                     // 8.0.0.2 (2021/10/15)
    035
    036import org.opengion.fukurou.system.ThrowUtil;                                           // 6.4.2.0 (2016/01/29) package変更 fukurou.util → fukurou.system
    037// import org.opengion.fukurou.system.OgRuntimeException ;                      // 8.0.0.0 (2021/09/30)
    038
    039import static org.opengion.fukurou.system.HybsConst.CR;                         // 6.1.0.0 (2014/12/26) refactoring
    040import static org.opengion.fukurou.system.HybsConst.BUFFER_MIDDLE;      // 6.4.2.0 (2016/01/29) ローカル定義をやめて、HybsConst を使用する様に変更。
    041
    042/**
    043 * StringUtil.java は、共通的に使用される String関連メソッドを集約した、クラスです。
    044 *
    045 * @og.group ユーティリティ
    046 *
    047 * @version  4.0
    048 * @author       Kazuhiko Hasegawa
    049 * @since    JDK5.0,
    050 */
    051public final class StringUtil {
    052
    053        /**
    054         * code39 のチェックデジット計算に使用する モジュラス４３ の変換表です。
    055         *
    056         */
    057        private static final String MODULUS_43 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%" ;
    058
    059        /**
    060         * getUnicodeEscape で使用する桁合わせ用文字列配列です。
    061         * Unicodeの HexString 変換後の桁に応じて、埋め合わせします。
    062         *
    063         */
    064        private static final String[] UTF_STR = { "&#x0000", "&#x000", "&#x00", "&#x0", "&#x" };
    065
    066        // 4.0.3.0 (2007/12/26) 色コードにPURPLE を追加
    067        // 5.7.8.0 (2014/07/04) 透明追加
    068        // 6.0.2.1 (2014/09/26) ColorMap クラスに移動
    069
    070        // 6.2.0.0 (2015/02/27) #numberFormat( String , int ) で使用するフォーマット変換オブジェクト
    071        private static final DecimalFormat[] FMT1 = new DecimalFormat[] {
    072                                                                        new DecimalFormat( "#,##0" ) ,
    073                                                                        new DecimalFormat( "#,##0.0" ) ,
    074                                                                        new DecimalFormat( "#,##0.00" ) ,
    075                                                                        new DecimalFormat( "#,##0.000" ) ,
    076                                                                        new DecimalFormat( "#,##0.0000" ) } ;
    077
    078        private static final String ZERO = "00000000000000000000" ;             // ゼロ埋めの種
    079
    080        private static final String[][] ESC_ARY = new String[][] {              // 6.9.8.1 (2018/06/11)
    081                                                                         { "&lt;", "<" }
    082                                                                        ,{ "&LT;", "<" }
    083                                                                        ,{ "&gt;", ">" }
    084                                                                        ,{ "&GT;", ">" }        };
    085
    086        /**
    087         *      デフォルトコンストラクターをprivateにして、
    088         *      オブジェクトの生成をさせないようにする。
    089         *
    090         */
    091        private StringUtil() {}
    092
    093        /**
    094         * UTF-8 で、URLエンコードを行います。
    095         * このメソッドは、JDK1.4 以上でないと使用できません。
    096         *
    097         * @param       value エンコードする文字列
    098         *
    099         * @return       指定の文字コードでＵＲＬエンコードされた文字列
    100         * @see         #urlEncode2( String )
    101         * @og.rtnNotNull
    102         */
    103        public static String urlEncode( final String value ) {
    104                if( value == null ) { return ""; }
    105
    106                try {
    107                        return URLEncoder.encode( value,"UTF-8" );
    108                }
    109                catch( final UnsupportedEncodingException ex ) {
    110                        final String errMsg = "UnsupportedEncodingException [UTF-8]" + CR
    111                                                + ex.getMessage() ;
    112                        throw new OgRuntimeException( errMsg,ex );
    113                }
    114                catch( final RuntimeException ex2 ) {           // 3.6.0.0 (2004/09/17)
    115                        final String errMsg = "予期せぬエラー value=[" + value + "] , encode=[UTF-8]" + CR
    116                                                + ex2.getMessage();
    117                        throw new OgRuntimeException( errMsg,ex2 );
    118                }
    119        }
    120
    121        private static final String UN_CHANGE = ":/?=&._~" ;
    122
    123        /**
    124         * UTF-8 で、ASCII以外の文字の、URLエンコードします。
    125         *
    126         * 00 ～ 7F までのコードは、変換しません。
    127         *
    128         * これは、日本語ファイル名の直リンクなど、URLエンコードが必要ですが、
    129         * http:// などのURL の場合は、':' , '/' は、エンコードしたくありません。
    130         * また、openGion では、[カラム] などの特殊な変数を渡して、処理させているので
    131         * それらのキーワードも変換してほしくありません。
    132         * ただし、"%" と、";" は、変換します。
    133         *
    134         * @og.rev 6.2.0.1 (2015/03/06) ASCII以外の文字の、URLエンコードを行う。
    135         * @og.rev 6.9.0.0 (2018/01/31) 半角の中でも ':' , '/' , '?' , '=' , '&amp;' , '.' , '_' , '~' 以外の文字は置き換えます。
    136         *
    137         * @param       value エンコードする文字列
    138         *
    139         * @return       指定の文字コードでＵＲＬエンコードされた文字列(ASCII は省く)
    140         * @see         #urlEncode( String )
    141         * @og.rtnNotNull
    142         */
    143        public static String urlEncode2( final String value ) {
    144                if( value == null ) { return ""; }
    145
    146                final StringBuilder rtn = new StringBuilder( BUFFER_MIDDLE );
    147                final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );
    148
    149                for( int i=0; i<value.length(); i++ ) {
    150                        final char ch = value.charAt(i);
    151//                      if( ch > 0x7f ) { buf.append( ch ); }                           // ASCII以外は、とりあえず貯めておく
    152                        if( ch > 0x7f || UN_CHANGE.indexOf( ch ) < 0 ) { buf.append( ch ); }    // ASCII以外は、とりあえず貯めておく
    153                        else {
    154                                if( buf.length() > 0 ) {                                                // 前回のデータが残っている
    155                                        rtn.append( urlEncode( buf.toString() ) );      // ASCII以外のurlEncode処理と追加
    156                                        buf.setLength(0);                                                       // 初期化
    157                                }
    158                                rtn.append( ch );
    159        //                      // ファイル名に、";" や "%" が存在すると、認識できないため、半角文字でも変換しておきます。
    160        //                      if(      ch == ';' ) {  rtn.append( "%3B" ); }  // 特殊処理
    161        //                      else if( ch == '%' ) {  rtn.append( "%25" ); }
    162        //                      else {                                  rtn.append( ch );    }  // ASCII文字の追加
    163                        }
    164                }
    165
    166                if( buf.length() > 0 ) {                                                                // 残っている分
    167                        rtn.append( urlEncode( buf.toString() ) );                      // ASCII以外のurlEncode処理と追加
    168                }
    169
    170                return rtn.toString();
    171        }
    172
    173        /**
    174         * UTF-8 でURLエンコードされた文字列をデコードします。
    175         * このメソッドは、JDK1.4 以上でないと使用できません。
    176         *
    177         * @og.rev 5.4.5.0 追加
    178         * @param       value デコードする文字列
    179         *
    180         * @return       デコードされた文字列
    181         */
    182        public static String urlDecode( final String value ) {
    183                try {
    184                        return URLDecoder.decode( value,"UTF-8" );
    185                }
    186                catch( final UnsupportedEncodingException ex ) {
    187                        final String errMsg = "UnsupportedEncodingException [UTF-8]" + CR
    188                                                + ex.getMessage() ;
    189                        throw new OgRuntimeException( errMsg,ex );
    190                }
    191                catch( final RuntimeException ex2 ) {           // 3.6.0.0 (2004/09/17)
    192                        final String errMsg = "予期せぬエラー value=[" + value + "] , encode=[UTF-8]" + CR
    193                                                + ex2.getMessage();
    194                        throw new OgRuntimeException( errMsg,ex2 );
    195                }
    196        }
    197
    198        /**
    199         * 文字列の後ろのスペースを削除します。
    200         * String クラスの trim()メソッドは、文字列の両方のスペースを削除しますが、
    201         * この rTrim( String ) は、後ろの半角スペースのみ、詰めます。
    202         * 注意：'\u0020' (スペース文字) より小さい文字を切り取ります。
    203         *
    204         * @param       str 元の文字列
    205         *
    206         * @return      後ろの半角スペースを詰めた、新しい文字列
    207         */
    208        public static String rTrim( final String str ) {
    209                if( str == null )  { return null; }
    210                final int count = str.length();
    211
    212                int len = count;
    213
    214                while( 0 < len && str.charAt(len-1) <= ' ' ) {
    215                        len--;
    216                }
    217                return len < count ? str.substring(0, len) : str;
    218        }
    219
    220        /**
    221         * 文字列の後ろから、" .0" の文字を削除した数字型文字列を返します。
    222         * 数字型文字列は、入力文字列の後ろの スペース、小数点、ゼロを削除します。
    223         * また、先頭が、"." で始まる場合は、"0" を追加します。
    224         * 例: "123.00" ⇒ "123" , ".123" ⇒ "0.123"
    225         *
    226         * @og.rev 3.8.8.1 (2007/01/10) 新規作成
    227         *
    228         * @param       str 元の文字列
    229         *
    230         * @return      数字文字列化された、新しい文字列
    231         */
    232        public static String toNumber( final String str ) {
    233                if( str == null )  { return null; }
    234
    235                String rtn = str.trim() ;
    236
    237                final int adrs = rtn.indexOf( '.' );
    238                final int count = rtn.length();
    239                int len = count;
    240
    241                if( adrs >= 0 ) {
    242                        while( adrs < len && ".0".indexOf( rtn.charAt(len-1) ) >= 0 ) {
    243                                len--;
    244                        }
    245                }
    246
    247                if( len < count ) { rtn = rtn.substring(0, len); }
    248                if( adrs == 0 ) { rtn = "0" + rtn; }
    249
    250                return rtn ;
    251        }
    252
    253        /**
    254         * 文字列の前方のゼロ(０)を削除します。
    255         * 先頭の０を削除するまえに、trim して、スペースを削除しておきます。
    256         * すべてがゼロ(０)の場合は、"0" を返します。
    257         * 小数点( 0.01 など )の場合は、先頭の 0 がすべて消えるとまずいので、
    258         * "0." 部分は、残します。
    259         *
    260         * @og.rev 3.5.4.5 (2004/01/23) 新規追加
    261         *
    262         * @param       inStr 元の文字列
    263         *
    264         * @return      前方のゼロ(０)を削除した、新しい文字列
    265         */
    266        public static String lTrim0( final String inStr ) {
    267                if( inStr == null )  { return null; }
    268                final String str = inStr.trim();
    269                final int count = str.length();
    270
    271                int len = 0;
    272                while( count > len && str.charAt(len) == '0' ) {
    273                        len++;
    274                }
    275
    276                if( len == 0 ) { return str; }                          // 先頭がゼロでない。
    277                else if( len == count ) { return "0"; }         // すべてがゼロ
    278                else if( str.charAt(len) == '.' ) { return "0" + str.substring(len); }
    279                else { return str.substring(len); }
    280        }
    281
    282        /**
    283         * 文字列配列の各要素の後ろのスペースを削除します。
    284         * 個々の配列要素に対して、rTrim( String str ) を適用します。
    285         * 元の文字列配列に直接作用するのではなく、新しい文字列配列に
    286         * 結果をコピーして返します。
    287         * ただし、元の文字列配列が、null か、length == 0 の場合は、
    288         * 元の文字列配列(アドレス)を返します。
    289         * 注意：'\u0020' (スペース文字) より小さい文字を切り取ります。
    290         *
    291         * @param       str 元の文字列配列(可変長引数)
    292         *
    293         * @return      後ろの半角スペースを詰めた、新しい文字列配列
    294         */
    295        public static String[] rTrims( final String... str ) {
    296                // 6.1.1.0 (2015/01/17) 可変長引数でもnullは来る。
    297                if( str == null || str.length == 0 ) { return str; }
    298
    299                String[] rtn = new String[str.length];  // str.length == 0 の場合、長さゼロの新しい配列を返す。
    300                for( int i=0; i<str.length; i++ ) {
    301                        rtn[i] = rTrim( str[i] );
    302                }
    303                return rtn ;
    304        }
    305
    306        /**
    307         * 文字列の前後のダブルクオートを取り外します。
    308         * 前後にダブルクオートが入っていなければ、そのままの文字列を返します。
    309         * 前後に入っていない(片方のみなど)場合も、そのままの文字列を返します。
    310         * ※ 先頭に、'0 が含まれる場合は、カンマを削除します。
    311         *    従来は、ダブルクオートしてから、rTrim してましたが、trim してから、
    312         *    ダブルクオート外しを行います。
    313         *
    314         * @og.rev 6.2.1.0 (2015/03/13) 先頭に、'0 が含まれる場合は、カンマを削除
    315         *
    316         * @param       str 元の文字列
    317         *
    318         * @return      ダブルクオートを取り外した新しい文字列
    319         */
    320        public static String csvOutQuote( final String str ) {
    321                if( str == null )  { return null; }
    322
    323                // 6.2.1.0 (2015/03/13) 先頭に、'0 が含まれる場合は、カンマを削除
    324                String rtn = str.trim();                                                                        // ①前後のスペース削除
    325                if( rtn.startsWith( "'0" ) ) { rtn = rtn.substring(1); }        // ②先頭の'0 のカンマ外し
    326                else {
    327                        final int end = rtn.length();                                                   // ③前後のダブルクオート外し
    328                        if( end >= 2 && str.charAt(0) == '"' && str.charAt( end-1 ) == '"' ) {
    329                                rtn = rtn.substring( 1,end-1 );
    330                        }
    331                }
    332                return rtn;
    333        }
    334
    335        /**
    336         * 内部で使われる byte[] から String 生成 メソッド。
    337         *
    338         * @param       byteValue        変換するバイト列
    339         * @param       start            変換開始アドレス
    340         * @param       length           変換バイト数
    341         * @param       encode           変換する文字エンコード
    342         *
    343         * @return      変換後文字列
    344         */
    345        public static String makeString( final byte[] byteValue, final int start, final int length,final String encode ) {
    346
    347                if( encode.startsWith( "Unicode" ) ) {
    348                        final String errMsg = "Unicode文字列は、変換できません。[" + encode + "]"  + CR;
    349                        throw new OgRuntimeException( errMsg );
    350                }
    351
    352                String rtn = null;
    353                if( byteValue != null ) {
    354                        try {
    355                                // encode コードで変換されている byte[] を、String に変換。
    356                                rtn = new String( byteValue,start,length,encode );
    357                        } catch( final UnsupportedEncodingException ex ) {        // 変換コードが存在しないエラー
    358                                final String errMsg = "文字変換コードが存在しません。[" + encode + "]" + CR
    359                                                        + ex.getMessage() ;
    360                                throw new OgRuntimeException( errMsg,ex );
    361                        }
    362                }
    363                return rtn;
    364        }
    365
    366        /**
    367         * 指定の文字列をバイトコードに変換します。
    368         * 引数の文字列が null の場合は、return は、byte[0] を返します。
    369         *
    370         * @param       value    変換するストリング値
    371         * @param       encode   変換する文字エンコード
    372         *
    373         * @return      変換後文字列
    374         */
    375        public static byte[] makeByte( final String value,final String encode ) {
    376                byte[] rtnByte = new byte[0];
    377                if( value != null ) {
    378                        try {
    379                                rtnByte = value.getBytes( encode );             // byte[] に encode コードで変換。
    380                        } catch( final UnsupportedEncodingException ex ) {        // 変換コードが存在しないエラー
    381                                final String errMsg = "文字変換コードが存在しません。[" + encode + "]" + CR
    382                                                        + ex.getMessage();
    383                                throw new OgRuntimeException( errMsg,ex );
    384                        }
    385                }
    386                return rtnByte;
    387        }
    388
    389        /**
    390         * 半角スペースで固定長(半角換算の数)に変換した文字列を返します。
    391         * 半角スペース埋めは、文字が半角、全角混在でもかまいません。
    392         * 内部にセットした文字列は、変化しません。
    393         *
    394         * @param       str      Fill埋めする文字列
    395         * @param       su_fill  Fill埋めする文字列の長さ。(半角換算の数)
    396         *
    397         * @return      Fill埋めした新しいStringを返す。
    398         * @og.rtnNotNull
    399         */
    400        public static String stringXFill( final String str,final int su_fill ) {
    401                char[] charValue ;
    402
    403                if( str == null ) { charValue = new char[0]; }
    404                else              { charValue = str.toCharArray(); }
    405                final int len = charValue.length;
    406
    407                if( su_fill < len ) {
    408                        final String errMsg = "元の文字数がフォームより長いです。(数字が壊れます。)"
    409                                        + "su_fill[" + su_fill + "], len[" + len + "]" + CR
    410                                        + "input=[" + str + "]" + CR;
    411                        throw new OgRuntimeException( errMsg );
    412                }
    413
    414                final char[] charbuf = new char[ su_fill ];                     // 移す char 配列を新規作成
    415                Arrays.fill( charbuf,' ' );
    416                System.arraycopy( charValue,0,charbuf,0,len );
    417
    418                return new String( charbuf );            // コピーした配列全てを文字列に変換
    419        }
    420
    421        /**
    422         * 半角スペースで固定長(半角換算の数)に変換した文字列を返します。
    423         * 半角スペース埋めは、文字が半角、全角混在でもかまいません。
    424         * 内部にセットした文字列は、変化しません。
    425         *
    426         * @og.rev 6.3.6.0 (2015/08/16) System.arraycopy が使える箇所は、置き換えます。
    427         *
    428         * @param       str      Fill埋めする文字列
    429         * @param       su_fill  Fill埋めする文字列の長さ。(半角換算の数)
    430         * @param       encode   Fill埋めする文字列の文字エンコード
    431         *
    432         * @return      Fill埋めした新しいStringを返す。
    433         */
    434        public static String stringFill( final String str,final int su_fill,final String encode ) {
    435                if( su_fill < 0 ) {
    436                        final String errMsg = "指定文字数が負です。[" + su_fill + "]";
    437                        throw new OgRuntimeException( errMsg );
    438                }
    439
    440                final byte[] byteValue = makeByte( str,encode );
    441                final int len = byteValue.length;
    442
    443                // 内部文字列が指定長より長い場合
    444                if( len >= su_fill ) {
    445                        return makeString( byteValue,0,su_fill,encode );
    446                }
    447                else {
    448                        byte[] space = makeByte( " ",encode );
    449                        int spaceLen = space.length ;
    450                        if( spaceLen == 4 ) {                                   // encode が、UnicodeLittle の場合の特殊処理
    451                                space[0] = space[2];
    452                                space[1] = space[3];
    453                                spaceLen = 2;
    454                        }
    455                        byte[] bytebuf = new byte[su_fill];
    456                        // 6.3.6.0 (2015/08/16) System.arraycopy が使える箇所は、置き換えます。
    457                        System.arraycopy( byteValue,0,bytebuf,0,len );          // 6.3.6.0 (2015/08/16)
    458
    459                        int k = 0;
    460                        for( int j=len; j<su_fill; j++ ) {              // 余った部分は、スペース埋め
    461                                if( k >= spaceLen ) { k = 0; }
    462                                bytebuf[j] = space[k++];
    463                        }
    464                        return makeString( bytebuf,0,su_fill,encode );  // 新たに、すべての長さの部分文字列を作成する。
    465                }
    466        }
    467
    468        /**
    469         * 整数のフォーム( 12 で、整数部 １２桁を表す)に合った新しい文字列を作り、それを返します。
    470         * 実行できるのは、整数の String に対してのみです。
    471         * 内部にセットした文字列は、変化しません。
    472         * 桁数がオーバーする場合は、RuntimeException を throw します。
    473         *
    474         *   String str = StringUtil.intFill( "123",10 );
    475         *
    476         *   実行結果："0000000123"
    477         *
    478         * @param       str     整数の String
    479         * @param       su_fill フォームを表す正の数字 ( 12 で、整数部 １２桁を表す)
    480         *
    481         * @return      整数のフォームに合った文字列
    482         * @og.rtnNotNull
    483         * @see         #intFill( int ,int )
    484         * @throws      RuntimeException su_fill が、負の数か、元の文字数がフォームより長い場合、エラー
    485         */
    486        public static String intFill( final String str,final int su_fill ) {
    487                if( su_fill < 0 ) {
    488                        final String errMsg = "指定文字数が負です。[" + su_fill + "]";
    489                        throw new OgRuntimeException( errMsg );
    490                }
    491
    492                final char[] charbuf = new char[ su_fill ];                     // 移す char 配列を新規作成
    493                Arrays.fill( charbuf,'0' );
    494
    495                if( str == null ) { return new String( charbuf ); }
    496
    497                final char[] charValue = str.toCharArray();
    498                final int len = charValue.length;
    499
    500                if( su_fill < len ) {
    501                        final String errMsg = "元の文字数がフォームより長いです。(数字が壊れます。) su_fill[" + su_fill + "], len[" + len + "]";
    502                        throw new OgRuntimeException( errMsg );
    503                }
    504
    505                System.arraycopy( charValue,0,charbuf,su_fill-len,len );
    506
    507                return new String( charbuf );            // コピーした配列全てを文字列に変換
    508        }
    509
    510        /**
    511         * 整数のフォーム( 12 で、整数部 １２桁を表す)に合った新しい文字列を作り、それを返します。
    512         * 実行できるのは、正の整数に対してのみです。
    513         * 桁数がオーバーする場合は、オーバーしたまま返します。
    514         *
    515         *   String str = StringUtil.intFill( 123,10 );
    516         *
    517         *   実行結果："0000000123"
    518         *
    519         * @og.rev 6.0.2.4 (2014/10/17) 新規追加
    520         *
    521         * @param       num     正の整数
    522         * @param       su_fill フォームを表す数字 ( 12 で、整数部 １２桁を表す)
    523         *
    524         * @return      整数のフォームに合った文字列
    525         * @see         #intFill( String ,int )
    526         * @throws      RuntimeException su_fill または、num が、負の数の場合、エラー
    527         */
    528        public static String intFill( final int num,final int su_fill ) {
    529                if( num < 0 || su_fill < 0 ) {
    530                        final String errMsg = "指定文字数が負です。num=[" + num + "] , su_fill=[" + su_fill + "]";
    531                        throw new OgRuntimeException( errMsg );
    532                }
    533
    534                String rtn = String.valueOf( num );
    535
    536                final int len = su_fill - rtn.length();                                         // 桁の不足分を算出
    537                if( len > 0 ) {
    538                        rtn = "00000000000000000000".substring( 0,len ) + rtn ;
    539                }
    540
    541                return rtn;
    542        }
    543
    544        /**
    545         * 全角スペースで固定長(半角換算の数)に変換した文字列を返します。
    546         *
    547         * @param       str      Fill埋めする文字列
    548         * @param       su_fill  Fill埋めする文字列の長さ。(半角換算の数)
    549         * @param       encode   Fill埋めする文字列の文字エンコード
    550         *
    551         * @return      全角スペースでFill埋めした新しいStringを返す。
    552         */
    553        public static String stringKFill( final String str,final int su_fill,final String encode ) {
    554                if( su_fill < 0 ) {
    555                        final String errMsg = "指定文字数が負です。[" + su_fill + "]";
    556                        throw new OgRuntimeException( errMsg );
    557                }
    558
    559                final byte[] byteValue = makeByte( str,encode );
    560                final int len = byteValue.length;
    561
    562                // 内部文字列が指定長より長い場合
    563                if( len >= su_fill ) {
    564                        return makeString( byteValue,0,su_fill,encode );
    565                }
    566                else {
    567                        final byte[] bytebuf = new byte[ su_fill ];
    568                        System.arraycopy( byteValue, 0, bytebuf, 0, len );                              // 6.3.9.0 (2015/11/06) System.arraycopy is more efficient(PMD)
    569
    570                        final byte[] space = makeByte( "　",encode );
    571                        final int spaceLen = space.length ;
    572                        int k = 0;
    573                        for( int j=len; j<su_fill; j++ ) {              // 余った部分は、スペース埋め
    574                                if( k >= spaceLen ) { k = 0; }
    575                                bytebuf[j] = space[k++];
    576                        }
    577                        return makeString( bytebuf,0,su_fill,encode );  // 新たに、すべての長さの部分文字列を作成する。
    578                }
    579        }
    580
    581        /**
    582         * 小数点のフォームに合った新しい文字列を作り、文字列を返します。
    583         * 現在は、小数点が頭に付いたり、最後に付く場合の対応はしていません。
    584         * フォームは、12.4 で、 000000000010.1000 という形で、ピリオドを含みます。
    585         *
    586         *  // 半角 整数部 10 桁 小数部 ５桁で固定長の文字を得る。
    587         *  String str = StringUtil.realFill( "123.45" ,10.5 ) ;
    588         *
    589         *  実行結果：0000000123.45000
    590         *
    591         * @param       str             整数の String
    592         * @param       su_fill フォームを表す実数       ( 12.4 で、整数部 １２桁、小数部 ４桁 計１７桁 )
    593         *
    594         * @return      value   小数点のフォーム文字列
    595         * @og.rtnNotNull
    596         */
    597        public static String realFill( final String str,final double su_fill ) {
    598                if( su_fill < 0 ) {
    599                        final String errMsg = "指定文字数が負です。[" + su_fill + "]";
    600                        throw new OgRuntimeException( errMsg );
    601                }
    602
    603                final int su_seisu = (int)(su_fill);                                               // 指定のフォームの整数部を取り出す。
    604                final int su_shosu = (int)(su_fill*10 - su_seisu*10);              // 小数部を取り出しす。
    605                char[] charbuf = new char[ su_seisu + su_shosu + 1 ];  // 移す char 配列
    606                Arrays.fill( charbuf,'0' );
    607
    608                if( str == null ) {
    609                        charbuf[su_seisu] = '.' ;
    610                        return new String( charbuf );
    611                }
    612
    613                // 検査する文字列の加工(検査文字列は、インデックスの値とバイト数で文字数を求める。)
    614                // 小数点の位置を求める。 本当は、String クラスの indexOf で求めず、byte[] で検索すべきである。
    615                final int valueindex = str.indexOf( '.' );
    616                if( valueindex < 0 ) {                                                                  // valueform 自体が、合っていない。
    617                        final String errMsg = "元の文字列に小数点が、含まれません。";
    618                        throw new OgRuntimeException( errMsg );
    619                }
    620                // 6.4.1.1 (2016/01/16) PMD refactoring. Avoid declaring a variable if it is unreferenced before a possible exit point.
    621
    622                // フォームの整数文字数 ー 加工文字の整数文字部 ＝ 転送先配列位置
    623                int toIndex = su_seisu - valueindex;                                                    // 6.4.1.1 (2016/01/16)
    624                if( toIndex < 0 ) {
    625                        final String errMsg = "元の数字が、フォームより長いです。(数字が壊れます。) form[" + su_fill + "]";
    626                        throw new OgRuntimeException( errMsg );
    627                }
    628                int endIndex;
    629                // 転送先配列終了位置は、お互いの小数部の文字数により、短い方を選ぶ。
    630                final char[] charValue  = str.toCharArray();
    631                final int su_valueshosu = charValue.length - valueindex - 1 ;   // 小数部の文字数は、全文字数－整数文字数－１
    632                if( su_shosu < su_valueshosu ) { endIndex = su_seisu + su_shosu + 1; }
    633                else                                               { endIndex = su_seisu + su_valueshosu + 1; }
    634
    635                int fromIndex = 0;
    636                while( toIndex < endIndex ) {
    637                        charbuf[toIndex++] = charValue[fromIndex++];       // 転送(移し替え)
    638                }
    639                return new String( charbuf );            // コピーした配列全てを文字列に変換
    640        }
    641
    642        /**
    643         * ストリングの部分文字列を,別の文字列に置換えたストリングを返します。
    644         * 例えば,リターンコードを&lt; br /&gt;に置換えて,画面上に改行表示させるが可能です。
    645         *
    646         * @og.rev 5.0.0.1 (2009/08/15) 不要なオブジェクトの生成を抑制する。
    647         *
    648         * @param       target 元の文字列
    649         * @param       from   置換元部分文字列
    650         * @param       to         置換先部分文字列
    651         *
    652         * @return      置換えた文字列
    653         */
    654        public static String replace( final String target,final String from,final String to ) {
    655                if( target == null || from == null || to == null || target.indexOf( from ) < 0 ) { return target; }
    656
    657                final StringBuilder strBuf = new StringBuilder( target.length() );
    658
    659                int start = 0;
    660                int end   = target.indexOf( from,start );
    661                while( end >= 0 ) {
    662                        strBuf.append( target.substring( start,end ) );
    663                        strBuf.append( to );
    664                        start = end + from.length();
    665                        end   = target.indexOf( from,start );
    666                }
    667
    668                if( start > 0 ) {
    669                        strBuf.append( target.substring( start ) );
    670                        return strBuf.toString();
    671                }
    672                else {
    673                        return target;                  // 3.4.0.2 (2003/09/05)
    674                }
    675        }
    676
    677        /**
    678         * 変数の置き換え処理を行います。
    679         *
    680         * 変換元の文字列から、prefix と、suffix で囲まれた文字列をピックアップして、
    681         * func で指定の関数を、適用します。
    682         * 変換元の文字列に、複数含まれていてもかまいません。
    683         *
    684         * これは、単純な変数ではなく、${env.XXX}または、{&#064;ENV..XXX} の XXX を環境変数に置き換えたり、
    685         * {&#064;DATE.XXXX} を、日付文字列に置き換えたりする場合に、使用できます。
    686         * 例えば、環境変数 の置き換えは、
    687         * replaceText( orgText , "${env." , "}" , System::getenv ); または、
    688         * replaceText( orgText , "{&#064;ENV." , "}" , System::getenv );
    689         * とします。
    690         * 日付関数の置き換えは、
    691         * replaceText( orgText , "{&#064;DATE." , "}" , HybsDateUtil::getDateFormat );
    692         * とします。
    693         * orgTxt , prefix , suffix , func は必須で、null,ゼロ文字列、空白文字等の判定で、
    694         * true の場合は、変換元の文字列 をそのまま返します。
    695         *
    696         * @og.rev 6.9.2.1 (2018/03/12) 新規追加
    697         *
    698         * @param  orgTxt 変換元の文字列
    699         * @param  prefix 変換処理を行うキーワードの先頭文字列
    700         * @param  suffix 変換処理を行うキーワードの終了文字列
    701         * @param  func 変換処理を行う、関数型インタフェース
    702         * @return  置換処理したテキスト
    703         */
    704        public static String replaceText( final String orgTxt,final String prefix,final String suffix,final UnaryOperator<String> func ) {
    705                if( isEmpty( orgTxt,prefix,suffix ) || func == null ) { return orgTxt; }
    706
    707                final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );
    708
    709                // 環境変数の処理
    710                int st0 = 0;
    711                int st1 = orgTxt.indexOf( prefix );
    712                final int preLen = prefix.length() ;
    713                final int sufLen = suffix.length() ;
    714                while( st1 >= 0 ) {
    715                        final int ed = orgTxt.indexOf( suffix , st1 );
    716                        if( ed >= 0 ) {
    717                                buf.append( orgTxt.substring( st0,st1 ) );
    718                                final String key = orgTxt.substring( st1 + preLen , ed );
    719                                buf.append( func.apply( key ) );
    720
    721                                st0 = ed + sufLen ;                                                             // suffix の長さ分
    722                                st1 = orgTxt.indexOf( prefix,st0 );
    723                        }
    724                        else {
    725                                final String errMsg = orgTxt + "の、prefix[" + prefix + "] と、suffix[" + suffix + "]の整合性が取れていません。" ;
    726                                throw new OgRuntimeException( errMsg );
    727                        }
    728                }
    729
    730                return buf.append( orgTxt.substring( st0 ) ).toString();
    731        }
    732
    733        /**
    734         * 引数の AA:01 BB:02 CC:03 … 形式の、元値:新値のｽﾍﾟｰｽ区切り文字列を元に、
    735         * 元値を新値に置き換えます。
    736         * これは、部分置換ではなく、完全一致で処理します。
    737         * caseStr が null や、マッチしなかった場合は、元の値を返します。
    738         * その場合、ignoreCase=true としている場合は、元の文字列 も大文字に変換されて返されます。
    739         *
    740         * ゼロ文字列を元値や新値で使用することは可能ですが、スペースを使用することはできません。
    741         *
    742         * @og.rev 5.7.2.3 (2014/01/31) 新規追加
    743         *
    744         * @param       target          元の文字列
    745         * @param       caseStr         置換リスト(AA:01 BB:02 CC:03 … 形式)。null の場合は、比較しない。
    746         * @param       ignoreCase      true:大文字として比較 / false:そのまま比較
    747         *
    748         * @return      元の文字列を置き換えた結果。置換リストに存在しなければ、元の文字列を返す。
    749         */
    750        public static String caseReplace( final String target,final String caseStr,final boolean ignoreCase ) {
    751                if( target == null ) { return target; }
    752
    753                String rtn = ignoreCase ? target.toUpperCase(Locale.JAPAN) : target ;
    754
    755                if( caseStr != null ) {
    756                        final String caseTmp = " " + caseStr.trim() + " " ;             // CASE文字列の形式をそろえる。
    757
    758                        final int adrs = caseTmp.indexOf( " " + rtn + ":" );            // 前スペースと後ろコロンで、単語を確定する。
    759                        if( adrs >= 0 ) {
    760                                final int st = caseTmp.indexOf( ':' , adrs+1 );         // 最初のコロンの位置。元値:新値 の 新値 の取出
    761                                final int ed = caseTmp.indexOf( ' ' , st+1 );                   // コロンの次から、最初のスペースの位置
    762                                if( st >= 0 && ed >= 0 ) {
    763                                        rtn = caseTmp.substring( st+1,ed );                     // コロンの次から、スペースの前までを切り出す。
    764                                }
    765                        }
    766                }
    767
    768                return rtn ;
    769        }
    770
    771        /**
    772         * String型の配列から、カンマ(,)で連結されたString を作成します。
    773         * これは，配列を表示用に変換する為のものです。
    774         * array2line( array, ",", 0 ); と同等です。
    775         *
    776         * @param       array           元の文字列配列(可変長引数)
    777         *
    778         * @return      一列に変換した文字列(引数がnullの場合は、長さ０の文字列を返す)
    779         * @og.rtnNotNull
    780         */
    781        public static String array2csv( final String... array ) {
    782                return array2line( array, ",", 0 );
    783        }
    784
    785        /**
    786         * String型の配列から、セパレーターで連結されたString を作成します。
    787         * これは，配列を表示用に変換する為のものです。
    788         *
    789         * @param       array           元の文字列配列
    790         * @param       separator       区切り記号
    791         *
    792         * @return      一列に変換した文字列(引数がnullの場合は、長さ０の文字列を返す)
    793         * @og.rtnNotNull
    794         */
    795        public static String array2line( final String[] array,final String separator ) {
    796                return array2line( array, separator,0 );
    797        }
    798
    799        /**
    800         * String型の配列から、セパレーターで連結されたString を作成します。
    801         * これは，配列を表示用に変換する為のものです。
    802         *
    803         * @param       array           元の文字列配列
    804         * @param       separator       区切り記号
    805         * @param       start           配列の連結開始アドレス
    806         *
    807         * @return      一列に変換した文字列(引数がnullの場合は、長さ０の文字列を返す)
    808         * @og.rtnNotNull
    809         */
    810        public static String array2line( final String[] array,final String separator,final int start ) {
    811                if( array == null || array.length <= start ) { return ""; }
    812
    813                final StringBuilder rtn = new StringBuilder( BUFFER_MIDDLE );
    814
    815                rtn.append( valueOf( array[start] ) );
    816                for( int i=start+1; i<array.length; i++ ) {
    817                        rtn.append( separator );
    818                        rtn.append( valueOf( array[i] ) );
    819                }
    820                return rtn.toString();
    821        }
    822
    823        /**
    824         * Enumerationから、オブジェクト配列データを返します。
    825         * これは，Enumerationを表示用に変換する為のものです。
    826         *
    827         * @param       enume   元のEnumeration
    828         *
    829         * @return      オブジェクト配列
    830         * @og.rtnNotNull
    831         */
    832        public static Object[] enume2Array( final Enumeration<?> enume ) {              // 4.3.3.6 (2008/11/15) Generics警告対応
    833                if( enume == null || ! enume.hasMoreElements() ) { return new Object[0]; }
    834
    835                final ArrayList<Object> obj = new ArrayList<>();
    836
    837                while( enume.hasMoreElements() ) {
    838                        obj.add( enume.nextElement() );
    839                }
    840                return obj.toArray();
    841        }
    842
    843        /**
    844         * Enumerationから、オブジェクト配列データを返します。
    845         * これは，Enumerationを表示用に変換する為のものです。
    846         *
    847         * @param       enume   元のEnumeration
    848         * @param       objs - 配列が十分な大きさを持つ場合は、Vector の要素が格納される配列。
    849         *                      そうでない場合は、要素を格納するために同じ実行時の型の新しい配列が割り当てられる
    850         * @return      オブジェクト配列
    851         */
    852        public static Object[] enume2Array( final Enumeration<?> enume,final Object[] objs ) {  // 4.3.3.6 (2008/11/15) Generics警告対応
    853                if( enume == null || ! enume.hasMoreElements() ) { return objs ; }
    854
    855                final ArrayList<Object> list = new ArrayList<>();
    856
    857                while( enume.hasMoreElements() ) {
    858                        list.add( enume.nextElement() );
    859                }
    860                return list.toArray( objs );
    861        }
    862
    863        /**
    864         * Iteratorから、セパレーターで連結されたString を作成します。
    865         * これは，Enumerationを表示用に変換する為のものです。
    866         *
    867         * @param       ite             元のIterator
    868         * @param       separator       区切り記号
    869         *
    870         * @return      一列に変換した文字列
    871         * @og.rtnNotNull
    872         */
    873        public static String iterator2line( final Iterator<?> ite,final String separator ) {
    874                if( ite == null || ! ite.hasNext() ) { return ""; }
    875
    876                final StringBuilder rtn = new StringBuilder( BUFFER_MIDDLE );
    877
    878                rtn.append( valueOf( ite.next() ) );
    879                while( ite.hasNext() ) {
    880                        rtn.append( separator );
    881                        rtn.append( valueOf( ite.next() ) );
    882                }
    883                return rtn.toString();
    884        }
    885
    886        /**
    887         * カンマ(,)で連結された String を、配列に分解して、その値を返します。
    888         * これは，たとえば、AAA,BBB,CCC などのリソースデータを受けてから配列に入れ直して、
    889         * メニューなりリストを作成するのに便利です。
    890         * 要素が空の場合は、必ずカンマの間にスペースを入れて記述してください。
    891         * 分割後の文字列の前後のスペースは、削除されます。
    892         *
    893         * @param       csvData         元のデータ
    894         *
    895         * @return      文字列配列(引数がnull、ゼロ文字列の場合は、サイズ0の配列を返す)
    896         * @og.rtnNotNull
    897         */
    898        public static String[] csv2Array( final String csvData ) {
    899                return csv2Array( csvData, ',', 0 );
    900        }
    901
    902        /**
    903         * 区切り文字で連結された String を、配列に分解して、その値を返します。
    904         * これは，たとえば、AAA,BBB,CCC などのリソースデータを受けてから配列に入れ直して、
    905         * メニューなりリストを作成するのに便利です。
    906         * 連続した区切り文字は、１文字に分割します。
    907         * 分割後の文字列の前後のスペースは、削除されます。
    908         *
    909         * @param       csvData         元のデータ
    910         * @param       separator       区切り文字
    911         *
    912         * @return      文字列配列(引数がnull、ゼロ文字列の場合は、サイズ0の配列を返す)
    913         * @og.rtnNotNull
    914         */
    915        public static String[] csv2Array( final String csvData,final char separator ) {
    916                return csv2Array( csvData,separator,0 );
    917        }
    918
    919        /**
    920         * 区切り文字で連結された String を、配列に分解して、その値を返します。
    921         * これは，たとえば、AAA,BBB,CCC などのリソースデータを受けてから配列に入れ直して、
    922         * メニューなりリストを作成するのに便利です。
    923         * 連続した区切り文字は、１文字に分割します。
    924         * 分割後の文字列の前後のスペースは、削除されます。(区切り文字がTABの場合を除く：7.0.4.0 (2019/05/31) )
    925         * 第３の引数は、リターンする配列の個数を指定します。
    926         * len=0 だけは特別で、分解したデータの個数分の配列を作成します。指定の長さが短い場合は、
    927         * そこまで分のみ取り込みます。指定の長さが長い場合は、余分に配列を作成します。
    928         * データがNULLや、ゼロ文字列の場合は、長さゼロの配列を返します。
    929         * セットされる値は、"" です。
    930         *
    931         * @og.rev 3.8.5.1 (2006/05/08) 設定配列の数を指定できるように変更
    932         * @og.rev 3.8.8.2 (2007/01/26) 分割後の値の前後のスペースは削除します。
    933         * @og.rev 6.4.5.1 (2016/04/28) CSVTokenizer のインターフェースを、Iterator に変更。
    934         * @og.rev 6.8.5.0 (2018/01/09) 引数lenを最大配列長として処理します。
    935         * @og.rev 7.0.4.0 (2019/05/31) separatorがタブの場合は、trim() しないように変更
    936         *
    937         * @param       csvData         元のデータ
    938         * @param       separator       区切り文字
    939         * @param       len                     指定の最大長さの配列で返します(0の場合は、オリジナルの長さの配列か、長さゼロの配列)。
    940         *
    941         * @return      文字列配列(引数がnull、ゼロ文字列の場合は、サイズ(len)の配列を返す)
    942         * @og.rtnNotNull
    943         */
    944        public static String[] csv2Array( final String csvData,final char separator, final int len ) {
    945//              if( csvData == null || csvData.isEmpty() ) {
    946                if( isEmpty( csvData ) ) {                                              // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    947                        final String[] rtn = new String[len] ;
    948                        Arrays.fill( rtn,"" );
    949                        return rtn;
    950                }
    951
    952                // 7.0.4.0 (2019/05/31) separatorがタブの場合は、trim() しないように変更
    953                final boolean useTrim = separator != '\t' ;
    954
    955                final CSVTokenizer token = new CSVTokenizer( csvData,separator );
    956                final int count = len > 0 ? len : token.countTokens() ;
    957                final String[] rtn = new String[count];
    958                int i = 0;
    959                for( ; i<count && token.hasNext() ; i++ ) {
    960//                      rtn[i] = token.next().trim();                           // 3.8.8.2 (2007/01/26)
    961                        rtn[i] = token.next();                                          // 3.8.8.2 (2007/01/26)
    962                        if( useTrim ) { rtn[i] = rtn[i].trim(); }       // 7.0.4.0 (2019/05/31)
    963                }
    964                for( ; i<count; i++ ) {
    965                        rtn[i] = "" ;
    966                }
    967
    968                return rtn;
    969        }
    970
    971        /**
    972         * 区切り文字で連結された String を、配列に分解して、その値を返します。
    973         * これは，#csv2Array( String,char,int ) メソッドで、分割時のデータが
    974         * ゼロ文字列の場合に、セットする初期値です。
    975         * 元のデータがnull、ゼロ文字列の場合は、defVal がセットされた サイズlenの配列を返します。
    976         *
    977         * データ数が、指定の len より少ない場合、先のメソッドでは、ゼロ文字列を追加していましたが、
    978         * ここでは、初期値の defVal をセットします。
    979         * また、分解後、trim() されたデータが、ゼロ文字列の場合も、defVal をセットします。
    980         *
    981         * @og.rev 6.8.5.0 (2018/01/09) CSVTokenizer のインターフェースを、Iterator に変更。
    982         *
    983         * @param       csvData         元のデータ
    984         * @param       separator       区切り文字
    985         * @param       len                     指定の長さの配列で返します。
    986         * @param       defVal          分割したデータが、ゼロ文字列の場合の初期値
    987         *
    988         * @return      文字列配列(引数がnull、ゼロ文字列の場合は、サイズ0の配列を返す)
    989         * @og.rtnNotNull
    990         */
    991        public static String[] csv2Array( final String csvData,final char separator, final int len , final String defVal ) {
    992                // 処理の中で対応しても良いが、オリジナルを尊重しておきます。
    993                final String[] rtn = csv2Array( csvData,separator,len );
    994
    995                for( int i=0; i<rtn.length; i++ ) {
    996                        if( rtn[i].isEmpty() ) { rtn[i] = defVal ; }
    997                }
    998
    999                return rtn;
    1000        }
    1001
    1002        /**
    1003         * 区切り文字で連結された String を、配列に分解して、その値を返します。
    1004         * これは，たとえば、AAA,BBB,CCC などのリソースデータを受けてから配列に入れ直して、
    1005         * メニューなりリストを作成するのに便利です。
    1006         * csv2Array と異なり、連続した区切り文字は、分割せずにトークンのみ切り出します。
    1007         * トークンは、カンマ(,)のみで区切り、その後 trim() により
    1008         * 前後のスペースを削除します。
    1009         *
    1010         * @param       csvData         元のデータ
    1011         *
    1012         * @return      文字列配列
    1013         * @og.rtnNotNull
    1014         */
    1015        public static String[] csv2ArrayOnly( final String csvData ) {
    1016//              if( csvData == null || csvData.isEmpty() ) { return new String[0] ; }
    1017                if( isEmpty( csvData ) ) { return new String[0]; }                                              // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    1018
    1019                final StringTokenizer token = new StringTokenizer( csvData,"," );
    1020
    1021                final ArrayList<String> list = new ArrayList<>();
    1022                while( token.hasMoreTokens() ) {
    1023                        final String temp = token.nextToken().trim();
    1024                        if( temp.length() > 0 ) { list.add( temp ); }
    1025                }
    1026
    1027                return list.toArray( new String[list.size()] );
    1028        }
    1029
    1030        /**
    1031         * カンマ(,)、ハイフン(-)で連結された String を、配列に分解して、その値を返す処理のスペシャル版です。
    1032         * 0,1,3,5-8,10-* などの数字文字列から、必要な数字をピックアップした数字配列を返します。
    1033         * 引数の maxNo は、"*" が指定された場合の、最大の数値です。
    1034         * よって、"*" は、単独(１文字)では、0-maxNo を表し、N-* では、N-maxNo を意味します。
    1035         * CSV形式で指定される値は、基本的に数字で、重複(1,1,2,2)、逆転(3,2,1)で指定できます。
    1036         * 5-3 と指定した場合は、5,4,3 に分解されます。逆順に登録されます。
    1037         * 重複削除、昇順並べ替え等が、必要な場合は、取得後の配列を操作してください。
    1038         *
    1039         * @og.rev 5.5.7.2 (2012/10/09) 新規追加
    1040         * @og.rev 6.2.6.0 (2015/06/19) アルファベットの対応を廃止し、数字配列のみサポートします。
    1041         *
    1042         * @param       csvData 0,1,3,5-8,10-* などのCSV-ハイフン文字列
    1043         * @param       maxNo "*" が指定された場合の、最大数
    1044         * @return      数字配列(引数がnull、ゼロ文字列の場合は、サイズ0の配列を返す)
    1045         * @og.rtnNotNull
    1046         */
    1047        public static Integer[] csv2ArrayExt( final String csvData , final int maxNo )  {
    1048//              if( csvData == null || csvData.isEmpty() ) { return new Integer[0] ; }
    1049                if( isEmpty( csvData ) ) { return new Integer[0]; }                             // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    1050
    1051                String strData = csvData.replace( "-*" , "-"  + maxNo );        // まず、N-* 形式を、N-maxNo に変換します。
    1052                strData        = strData.replace( "*"  , "0-" + maxNo );        // その後、"*" 単独(１文字)を、0-maxNo に変換します。
    1053
    1054                final ArrayList<Integer> noList = new ArrayList<>();
    1055
    1056                final String[] nos = strData.split( "," );              // カンマで分解。N , N-M , N-* のどれか
    1057                for( int i=0; i<nos.length; i++ ) {
    1058                        final String sno = nos[i] ;
    1059                        final int hai = sno.indexOf( '-' );
    1060                        // ハイフンが含まれているときは前後に分解して、間を埋める
    1061                        if( hai > 0 ) {
    1062                                int       ch1 = Integer.parseInt( sno.substring( 0,hai ) );             // 先頭からハイフンまで
    1063                                final int ch2 = Integer.parseInt( sno.substring( hai+1 ) );             // ハイフンから最後まで
    1064                                if( ch1 < ch2 ) { while( ch1 <= ch2 ) { noList.add( ch1++ ); } }
    1065                                else                    { while( ch1 >= ch2 ) { noList.add( ch1-- ); } }
    1066
    1067                        // また、一文字だけの場合は、アルファベット(a-z,A-Zなど)も指定する事が可能です。
    1068                        // アルファベットの場合は、"*" は指定できません。
    1069                        //      final String st1 = sno.substring( 0,hai );      // 先頭からハイフンまで
    1070                        //      final String st2 = sno.substring( hai+1 );      // ハイフンから最後まで
    1071                        //      if( st1.length() == 1 &&  st2.length() == 1 ) {         // ともに１文字の場合は、char化して処理。(英数字処理)
    1072                        //              char ch1 = st1.charAt(0);
    1073                        //              final char ch2 = st2.charAt(0);
    1074                        //              if( ch1 < ch2 ) { while( ch1 <= ch2 ) { noList.add( String.valueOf(ch1++ ) ); } }
    1075                        //              else                    { while( ch1 >= ch2 ) { noList.add( String.valueOf(ch1--) ); } }
    1076                        //      }
    1077                        //      else {
    1078                        //              int ch1 = Integer.parseInt( st1 );
    1079                        //              final int ch2 = Integer.parseInt( st2 );
    1080                        //              if( ch1 < ch2 ) { while( ch1 <= ch2 ) { noList.add( String.valueOf(ch1++ ) ); } }
    1081                        //              else                    { while( ch1 >= ch2 ) { noList.add( String.valueOf(ch1--) ); } }
    1082                        //      }
    1083                        }
    1084                        else {
    1085                                noList.add( Integer.valueOf( sno ) );
    1086                        }
    1087                }
    1088                return noList.toArray( new Integer[noList.size()] ) ;
    1089        }
    1090
    1091        /**
    1092         * Object 引数の文字列表現を返します。
    1093         * これは，String.valueOf とほぼ同じ動作をしますが、引数が null の場合に、
    1094         * "null" という文字列を返すのではなく、なにもない文字列 "" を返します。
    1095         *
    1096         * @param       obj    文字列表現すべき元のオブジェクト
    1097         *
    1098         * @return      引数が null の場合は、"" に等しい文字列。そうでない場合は、obj.toString() の値
    1099         * @og.rtnNotNull
    1100         */
    1101        public static String valueOf( final Object obj ) {
    1102                // 6.4.1.1 (2016/01/16) PMD refactoring. A method should have only one exit point, and that should be the last statement in the method
    1103                return obj == null ? "" : obj.toString();
    1104        }
    1105
    1106        /**
    1107         * HTML上のエスケープ文字を変換します。
    1108         *
    1109         * HTMLで表示する場合にきちんとエスケープ文字に変換しておかないと
    1110         * Script を実行されたり、不要なHTMLコマンドを潜り込まされたりするため、
    1111         * セキュリティーホールになる可能性があるので、注意してください。
    1112         *
    1113         * @og.rev 5.8.2.2 (2014/12/19) アポストロフィの対応
    1114         * @og.rev 6.2.2.3 (2015/04/10) htmlフィルターに、BR→改行処理機能を追加。互換性の為のメソッド。
    1115         *
    1116         * @param       input HTMLエスケープ前の文字列
    1117         *
    1118         * @return      エスケープ文字に変換後の文字列
    1119         * @og.rtnNotNull
    1120         */
    1121        public static String htmlFilter( final String input ) {
    1122                return htmlFilter( input , false );
    1123        }
    1124
    1125        /**
    1126         * HTML上のエスケープ文字を変換します。
    1127         *
    1128         * HTMLで表示する場合にきちんとエスケープ文字に変換しておかないと
    1129         * Script を実行されたり、不要なHTMLコマンドを潜り込まされたりするため、
    1130         * セキュリティーホールになる可能性があるので、注意してください。
    1131         *
    1132         * 引数のフラグは、BR→改行コード の変換処理を行うかどうかを指定します。
    1133         * true が、変換処理を行うです。
    1134         * titleなどのTips表示する場合、改行は、「\n(改行コード)」で行います。
    1135         * (HTMLで取り扱うので、&amp;#13;&amp;#10; の方が良いかもしれない。
    1136         *  その場合は、エスケープ処理と順番を入れ替えないと、そのまま表示されてしまう。)
    1137         * 一方、タグ等で改行を行うには、&lt;BR/&gt; で改行を指定します。
    1138         * 改行については、「\n」文字列を指定する事で統一します。
    1139         *
    1140         * @og.rev 5.8.2.2 (2014/12/19) アポストロフィの対応
    1141         * @og.rev 6.2.2.3 (2015/04/10) htmlフィルターに、BR→改行処理機能を追加。
    1142         * @og.rev 6.2.5.0 (2015/06/05) htmlフィルターで、BR→改行処理が、引数間違いの為うまくできていなかった。
    1143         *
    1144         * @param       input HTMLエスケープ前の文字列
    1145         * @param       flag  [true:BR変換する/false:BR変換しない]
    1146         *
    1147         * @return      エスケープ文字に変換後の文字列
    1148         * @og.rtnNotNull
    1149         */
    1150        public static String htmlFilter( final String input , final boolean flag ) {
    1151//              if( input == null || input.isEmpty() ) { return ""; }
    1152                if( isEmpty( input ) ) { return ""; }                                                   // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    1153
    1154                String temp = input ;
    1155                if( flag ) {
    1156                        temp = temp.replaceAll( "<[bB][rR][\\s/]*>" , "\n" );           // <br> を置き換える。
    1157                        temp = temp.replaceAll( "\\\\n"             , "\n" );           //「\n」という文字列を置き換える。
    1158                }
    1159
    1160                final StringBuilder rtn = new StringBuilder( BUFFER_MIDDLE );
    1161                char ch;
    1162                for( int i=0; i<temp.length(); i++ ) {
    1163                        ch = temp.charAt(i);            // 6.2.5.0 (2015/06/05) バグ
    1164                        switch( ch ) {
    1165                                case '<'  : rtn.append( "&lt;"   );     break;
    1166                                case '>'  : rtn.append( "&gt;"   );     break;
    1167                                case '"'  : rtn.append( "&quot;" );     break;
    1168                                case '\'' : rtn.append( "&apos;" );     break;          // 5.8.2.2 (2014/12/19) アポストロフィの対応
    1169                                case '&'  : rtn.append( "&amp;"  );     break;
    1170                                default   : rtn.append( ch );           break;          // 6.0.2.5 (2014/10/31) break追記
    1171                        }
    1172                }
    1173                return rtn.toString() ;
    1174        }
    1175
    1176        /**
    1177         * 「\n」という文字列を、BRタグに変換します。
    1178         *
    1179         * titleなどのTips表示する場合、改行は、「\n」で行います。
    1180         * 一方、タグ等で改行を行うには、&lt;BR/&gt; で改行を指定します。
    1181         * BRタグは、リソーステーブル等に書き込みにくい為、また、本当の改行コードも
    1182         * 書き込みにくい為、改行については、「\n」文字列を指定する事で対応できるように
    1183         * 統一します。
    1184         *
    1185         * @og.rev 6.2.2.3 (2015/04/10) 「\n」という文字列を、BRタグに変換する処理を追加
    1186         * @og.rev 7.0.1.0 (2018/10/15) XHTML → HTML5 対応(空要素の、"／＞" 止めを、"＞" に変更します)。
    1187         *
    1188         * @param       input BR,\n変換前の文字列
    1189         *
    1190         * @return      変換後の文字列
    1191         * @og.rtnNotNull
    1192         */
    1193        public static String yenN2br( final String input ) {
    1194                // 6.4.1.1 (2016/01/16) PMD refactoring. A method should have only one exit point, and that should be the last statement in the method
    1195//              return input == null || input.isEmpty() ? "" : input.replaceAll( "\\\\n" , "<br/>" );   // \n ではなく、「\n」という文字列と変換
    1196//              return  isEmpty( input ) ? "" : input.replaceAll( "\\\\n" , "<br/>" );                                  // \n ではなく、「\n」という文字列と変換        // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    1197                return  isEmpty( input ) ? "" : input.replaceAll( "\\\\n" , "<br>" );                                   // \n ではなく、「\n」という文字列と変換        // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    1198        }
    1199
    1200        /**
    1201         * JavaScript 等の引数でのクオート文字をASCII変換します。
    1202         *
    1203         * JavaScript の引数の値に、ダブルクオート(")、シングルクオート(')が
    1204         * 含まれると、文字列を表す為に前後に指定しているクオートと混乱し、
    1205         * データを表現できないケースがあります。その場合には、クオート文字を
    1206         * ASCII文字に置き換える事で、指定の文字を渡すことが可能になります。
    1207         * ここでは、引数文字列に、ダブルクオート(")、シングルクオート(')が、
    1208         * 含まれると、それぞれ、ASCII コード(￥ｘ２２、￥ｘ２７)に置き換えます。
    1209         * なお、null は、ゼロ文字列に変換して返します。
    1210         *
    1211         * @param       input 入力文字列
    1212         *
    1213         * @return      クオート文字をASCII文字に置き換えた文字列
    1214         * @og.rtnNotNull
    1215         */
    1216        public static String quoteFilter( final String input ) {
    1217//              if( input == null || input.isEmpty() ) { return ""; }
    1218                if( isEmpty( input ) ) { return ""; }                                                   // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    1219                if( input.indexOf( '\'' ) < 0 && input.indexOf( '"' ) < 0 ) { return input; }
    1220
    1221                final StringBuilder rtn = new StringBuilder( BUFFER_MIDDLE );
    1222                char ch;
    1223                for( int i=0; i<input.length(); i++ ) {
    1224                        ch = input.charAt(i);
    1225                        switch( ch ) {
    1226                                case '"'  : rtn.append( "\\x22" );      break;
    1227                                case '\'' : rtn.append( "\\x27" );      break;
    1228                                default   : rtn.append( ch );           break;          // 6.0.2.5 (2014/10/31) break追記
    1229                        }
    1230                }
    1231                return rtn.toString() ;
    1232        }
    1233
    1234        /**
    1235         * JSON形式で出力する場合のためのエスケープ処理です。
    1236         *
    1237         * @og.rev 5.9.6.4(2016/03/25) 新規作成
    1238         *
    1239         * @param       input XMLエスケープ前の文字列
    1240         *
    1241         * @return      エスケープ文字に変換後の文字列
    1242         */
    1243        public static String jsonFilter( final String input ) {
    1244//              if( input == null || input.length() == 0 ) { return ""; }
    1245                if( isEmpty( input ) ) { return ""; }                                                   // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    1246
    1247                final StringBuilder rtn = new StringBuilder( BUFFER_MIDDLE );
    1248                for(int i=0; i<input.length(); i++) {
    1249                        final char ch = input.charAt(i);
    1250                        switch( ch ) {
    1251                                case '"'        : rtn.append( "\\\"" ); break;
    1252                                case '\\'       : rtn.append( "\\\\" ); break;
    1253                                case '/'        : rtn.append( "\\/"  ); break;
    1254                                case '\b'       : rtn.append( "\\b"  ); break;
    1255                                case '\f'       : rtn.append( "\\f"  ); break;
    1256                                case '\n'       : rtn.append( "\\n"  ); break;
    1257                                case '\r'       : rtn.append( "\\r"  ); break;
    1258                                case '\t'       : rtn.append( "\\t"  ); break;
    1259                                default         : rtn.append( ch );             break;
    1260                        }
    1261                }
    1262                return rtn.toString() ;
    1263        }
    1264
    1265        /**
    1266         * 特殊文字のエスケープを元に戻す処理です。
    1267         * 元に戻すことで、htmlとして、使用します。
    1268         * scriptタグは動作しないようにしています。
    1269         * またignoreで指定したタグを除いて&lt;にします。
    1270         *
    1271         * @og.rev 5.9.33.0 (2018/06/01) 新規作成
    1272         *
    1273         * @param input 特殊文字がエスケープされた文字列
    1274         * @param ignore 指定したタグを除いて&lt;にします
    1275         *
    1276         * @return エスケープ前の文字列
    1277         */
    1278//      public static String escapeFilter( String input, String ignore ) {
    1279        public static String escapeFilter( final String input, final String ignore ) {
    1280//              if( input == null || input.length() == 0 ) { return ""; }
    1281                if( isEmpty( input ) ) { return ""; }                   // 6.9.8.1 (2018/06/11) isEmpty 置き換え
    1282
    1283                // 6.9.8.1 (2018/06/11) static 変数 ESC_ARY として、定義
    1284//              final String[][] list = new String[][] {
    1285//                       { "&lt;", "<" }
    1286//                      ,{ "&LT;", "<" }
    1287//                      ,{ "&gt;", ">" }
    1288//                      ,{ "&GT;", ">" }
    1289//              };
    1290
    1291//              for( final String[] trg : list ) {
    1292//                      input = replace( input, trg[0], trg[1] );
    1293//              }
    1294
    1295                String output = input;
    1296                for( final String[] trg : ESC_ARY ) {
    1297                        output = replace( input, trg[0], trg[1] );
    1298                }
    1299
    1300                // XSS対策
    1301                // jquery.cleditor.jsと同様の対応。
    1302                // スクリプトは実行させない
    1303//              input = input.replaceAll( "<(?=/?(?i)script)", "&lt;" );
    1304                output = output.replaceAll( "<(?=/?(?i)script)", "&lt;" );
    1305
    1306                // <と>の表示対応
    1307                // jquery.cleditor.custom.jsのupdateFrame(TextRich用)に同様処理を実装。(エスケープ文字の\有無が異なります)
    1308                //strong|font|a|br|p|span|div
    1309                // 指定のタグ前方の<以外の<は、&lt;に変換する。
    1310//              input = input.replaceAll( "<(?!/?(?i)("+ignore+")( |>|/))", "&lt;" );
    1311                // 6.9.8.1 (2018/06/11) ignore の isEmpty 判定を追加
    1312                if( !isEmpty( ignore ) ) {
    1313                        output = output.replaceAll( "<(?!/?(?i)("+ignore+")( |>|/))", "&lt;" );
    1314                }
    1315
    1316//              return input;
    1317                return output;
    1318        }
    1319
    1320        /**
    1321         * 所定のキャラクタコードを取り除いた文字列を作成します。
    1322         *
    1323         * 実現したい機能は、String#replace( 'x','' ) 的な表現です。
    1324         * つまり、指定のキャラクタを取り除きたいのですが、上記コマンドでは、
    1325         * コンパイル時にエラーが発生します。
    1326         * 取り除きたいキャラクタコードが存在しない場合は、指定の文字列を
    1327         * そのまま返します。
    1328         *
    1329         * @param       value 処理対象の文字列
    1330         * @param       ch 取り除きたいキャラクタ
    1331         *
    1332         * @return      処理後の文字列
    1333         */
    1334        public static String deleteChar( final String value,final char ch ) {
    1335                if( value == null || value.indexOf( ch ) < 0 ) { return value; }
    1336                char[] chs = value.toCharArray() ;
    1337                int j=0;
    1338                for( int i=0;i<chs.length; i++ ) {
    1339                        // 6.3.9.0 (2015/11/06) true/false を変更します。
    1340                        if( chs[i] != ch ) { chs[j++] = chs[i]; }
    1341                }
    1342                return String.valueOf( chs,0,j );
    1343        }
    1344
    1345        /**
    1346         * 文字列に含まれる、特定の文字の個数をカウントして返します。
    1347         *
    1348         * @og.rev 5.2.0.0 (2010/09/01)
    1349         *
    1350         * @param       value 処理対象の文字列
    1351         * @param       ch カウントする文字
    1352         *
    1353         * @return      カウント数
    1354         */
    1355        public static int countChar( final String value,final char ch ) {
    1356                if( value == null || value.indexOf( ch ) < 0 ) { return 0; }
    1357                final char[] chs = value.toCharArray() ;
    1358                int cnt=0;
    1359                for( int i=0;i<chs.length; i++ ) {
    1360                        if( chs[i] == ch ) { cnt++; }
    1361                }
    1362                return cnt;
    1363        }
    1364
    1365        /**
    1366         * CODE39 の 文字列を作成します。
    1367         *
    1368         * CODE39 は、『0～9, A～Z,-,・,　,$,/,+,%』のコードが使用できる
    1369         * バーコードの体系です。通常 * で始まり * で終了します。
    1370         * また、チェックデジット に、モジュラス43 が使われます。
    1371         * ここでは、指定の文字列の前後に、* を付与し、必要であれば
    1372         * チェックデジットも付与します。
    1373         * 指定の入力文字列には、* を付けないでください。
    1374         *
    1375         * @param       value 処理対象の文字列
    1376         * @param       checkDigit チェックデジットの付与(true:付ける/false:付けない)
    1377         *
    1378         * @return      処理後の文字列
    1379         * @og.rtnNotNull
    1380         */
    1381        public static String code39( final String value,final boolean checkDigit ) {
    1382                final String rtn = ( value == null ) ? "" : value ;
    1383                if( ! checkDigit ) { return "*" + rtn + "*"; }
    1384
    1385                int kei = 0;
    1386                int cd;
    1387                for( int i=0; i<rtn.length(); i++ ) {
    1388                        cd = MODULUS_43.indexOf( rtn.charAt(i) );
    1389                        if( cd < 0 ) {
    1390                                final String errMsg = "指定の文字中に、CODE39 規定外文字が使用されています。[" + rtn.charAt(i) + "]" ;
    1391                                throw new OgRuntimeException( errMsg );
    1392                        }
    1393                        kei += cd ;
    1394                }
    1395                final char digit = MODULUS_43.charAt( kei % 43 );
    1396
    1397                return "*" + rtn + digit + "*" ;
    1398        }
    1399
    1400        /**
    1401         * 引数 inStr が、null または、ゼロ文字列の場合は､デフォルト値 def を返します。
    1402         * もちろん、inStr も def も null の場合は､null を返します。
    1403         *
    1404         * ※ 影響範囲が大きいので、空白文字の判定は入れません。
    1405         *
    1406         * @param    inStr 基準となる文字列
    1407         * @param    def デフォルト文字列
    1408         *
    1409         * @return   引数 inStr が、null または、ゼロ文字列の場合は､デフォルト値を返す。
    1410         */
    1411        public static String nval( final String inStr,final String def ) {
    1412//              return inStr == null || inStr.isEmpty() ? def : inStr ;
    1413                return isEmpty( inStr ) ? def : inStr ;                                                 // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    1414        }
    1415
    1416        /**
    1417         * 引数 inStr が、null または、ゼロ文字列、空白文字列の場合は､デフォルト値 def を返します。
    1418         *
    1419         * 数値変換なので、空白文字列の場合も、デフォルト値を使用します。
    1420         *
    1421         * @param    inStr 基準となる文字列
    1422         * @param    def デフォルト数字
    1423         *
    1424         * @return   引数 inStr を変換した数字(int)。変換できない場合は デフォルト値 def
    1425         */
    1426        public static int nval( final String inStr,final int def ) {
    1427//              return inStr == null || inStr.isEmpty() ? def : Integer.parseInt( inStr ) ;
    1428                return isNull( inStr ) ? def : Integer.parseInt( inStr ) ;              // 6.9.2.1 (2018/03/12) isNull 置き換え
    1429        }
    1430
    1431        /**
    1432         * 引数 inStr が、null または、ゼロ文字列、空白文字列の場合は､デフォルト値 def を返します。
    1433         *
    1434         * @param    inStr 基準となる文字列
    1435         * @param    def デフォルト数字
    1436         *
    1437         * @return   引数 inStr を変換した数字(long)。変換できない場合は デフォルト値 def
    1438         */
    1439        public static long nval( final String inStr,final long def ) {
    1440//              return inStr == null || inStr.isEmpty() ? def : Long.parseLong( inStr ) ;
    1441                return isNull( inStr ) ? def : Long.parseLong( inStr ) ;                        // 6.9.2.1 (2018/03/12) isNull 置き換え
    1442        }
    1443
    1444        /**
    1445         * 引数 inStr が、null または、ゼロ文字列、空白文字列の場合は､デフォルト値 def を返します。
    1446         *
    1447         * @og.rev 6.9.2.1 (2018/03/12) 新規追加
    1448         *
    1449         * @param    inStr 基準となる文字列
    1450         * @param    def デフォルト数字
    1451         *
    1452         * @return   引数 inStr を変換した数字(double)。変換できない場合は デフォルト値 def
    1453         */
    1454        public static double nval( final String inStr,final double def ) {
    1455                return isNull( inStr ) ? def : Double.parseDouble( inStr ) ;            // 6.9.2.1 (2018/03/12) isNull 置き換え
    1456        }
    1457
    1458        /**
    1459         * 引数 inStr が、null または、ゼロ文字列、空白文字列の場合は､デフォルト値 def を返します。
    1460         * 通常は、"true" または、 "TRUE" 文字列を、論理値の true に変換します。
    1461         * ただし、文字列長が 1文字の場合のみ、"0" 以外を true に変換します。
    1462         *
    1463         * @og.rev 6.8.0.1 (2017/06/30) つづり間違いに対応するため、厳密にチェックします。
    1464         *
    1465         * @param    inStr 基準となる文字列
    1466         * @param    def デフォルト論理値
    1467         *
    1468         * @return   引数 inStr を変換した論理値。変換できない場合は デフォルト値 def
    1469         */
    1470        public static boolean nval( final String inStr,final boolean def ) {
    1471                // 6.8.0.1 (2017/06/30) つづり間違いに対応するため、厳密にチェックします。
    1472                if( inStr != null && inStr.length() > 1 && !"true".equalsIgnoreCase( inStr ) && !"false".equalsIgnoreCase( inStr ) ) {
    1473                        final String errMsg = "指定の文字列には、true か、false を指定してください。[" + inStr + "]" ;
    1474                        throw new OgRuntimeException( errMsg );
    1475                }
    1476
    1477                // 6.4.1.1 (2016/01/16) PMD refactoring.
    1478//              return inStr == null || inStr.isEmpty()
    1479                return isNull( inStr )                                                                                  // 6.9.2.1 (2018/03/12) isNull 置き換え
    1480                                        ? def
    1481                                        : inStr.length() == 1
    1482                                                ? ! "0".equals( inStr )
    1483                                                : "true".equalsIgnoreCase( inStr ) ;
    1484        }
    1485
    1486        /**
    1487         * 引数 inStr が、null、"_"、ゼロ文字列、空白文字列の場合は､デフォルト値 def を返します。
    1488         *
    1489         * さらに、メモリ領域を節約する為、intern() の結果を返します。
    1490         * ※ #nval(String) との整合性を取るため、空白文字の判定は入れません。
    1491         *
    1492         * @og.rev 5.2.2.0 (2010/11/01) "_" の取り扱い変更
    1493         *
    1494         * @param    inStr 基準となる文字列
    1495         * @param    def デフォルト文字列
    1496         *
    1497         * @return  null、ゼロ文字列、"_"の場合は、デフォルト文字列を、そうでなければ、入力文字を返す。
    1498         */
    1499        public static String nval2( final String inStr,final String def ) {
    1500//              return inStr == null || inStr.isEmpty() || "_".equals( inStr ) ? def : inStr.intern() ;
    1501                return isEmpty( inStr ) || "_".equals( inStr ) ? def : inStr.intern() ;         // 6.9.2.1 (2018/03/12) isNull 置き換え
    1502        }
    1503
    1504        /**
    1505         * 引数 inStr が、null または、ゼロ文字列、空白文字列の場合は､デフォルト値 def を返します。
    1506         * ただし、NULL代替文字(_)は デフォルト値 def2 に置き換えます。
    1507         *
    1508         * さらに、メモリ領域を節約する為、intern() の結果を返します。
    1509         * ※ #nval(String) との整合性を取るため、空白文字の判定は入れません。
    1510         *
    1511         * @og.rev 5.2.2.0 (2010/11/01) "_" の取り扱い変更
    1512         *
    1513         * @param    inStr 基準となる文字列
    1514         * @param    def デフォルト文字列
    1515         * @param    def2 NULL代替文字(_)の場合のデフォルト文字列
    1516         *
    1517         * @return  null、ゼロ文字列の場合は、def1文字列を、"_"の場合は、def2文字列を、そうでなければ、入力文字を返す。
    1518         */
    1519        public static String nval2( final String inStr,final String def,final String def2 ) {
    1520//              return inStr == null || inStr.isEmpty() ? def : "_".equals( inStr ) ? def2 : inStr.intern() ;
    1521                return isEmpty( inStr ) ? def : "_".equals( inStr ) ? def2 : inStr.intern() ;           // 6.9.2.1 (2018/03/12) isNull 置き換え
    1522        }
    1523
    1524        /**
    1525         * 引数の CSV形式文字列 が、null または、ゼロ文字列の場合は､デフォルト値 def を返します。
    1526         * それ以外の場合は、CSV形式の文字列を正規化します。
    1527         *
    1528         * 正規化とは、カンマで区切った後、trim() して、ゼロ文字列でない場合のみカンマで再結合します。
    1529         *
    1530         * @og.rev 7.0.5.0 (2019/09/09) 新規追加
    1531         *
    1532         * @param    strCsv 基準となるCSV形式文字列
    1533         * @param    def デフォルト文字列
    1534         *
    1535         * @return   引数の CSV形式文字列 が、null または、ゼロ文字列の場合は､デフォルト値を返す。
    1536         */
    1537        public static String nvalCsv( final String strCsv,final String def ) {
    1538                return isNull( strCsv ) ? def : join( "," , csv2Array( strCsv ) );
    1539        }
    1540
    1541        /**
    1542         * 指定のCharSequence同士を連結させます。
    1543         * CharSequenceが、 null の場合は、連結しません。
    1544         * すべてが null の場合は、ゼロ文字列が返されます。
    1545         *
    1546         * ここでは、空白文字やタブ、改行コードも、指定されていれば、連結されます。
    1547         *
    1548         * @og.rev 6.0.2.4 (2014/10/17) 新規追加
    1549         * @og.rev 6.4.5.0 (2016/04/08) 引数を可変長CharSequenceに変更
    1550         *
    1551         * @param       strs... 可変長CharSequence
    1552         *
    1553         * @return      null以外の文字列が連結された状態
    1554         * @see         #join( String,CharSequence... )
    1555         * @og.rtnNotNull
    1556         */
    1557        public static String nvalAdd( final CharSequence... strs ) {
    1558                final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );
    1559
    1560                for( final CharSequence str : strs ) {
    1561                        if( str != null ) { buf.append( str ); }
    1562                }
    1563
    1564                return buf.toString();
    1565        }
    1566
    1567        /**
    1568         * 最初の null(または、ゼロ文字列、空白文字、タブや改行コード) 以外の値を返します。
    1569         * nval の 変数が、無制限版です。
    1570         * すべてが null(または、ゼロ文字列) の場合は、null が返されます。
    1571//       * 空白文字、タブや改行コードが来ても、返されます。
    1572         *
    1573         * @og.rev 6.0.2.4 (2014/10/17) 新規追加
    1574         * @og.rev 6.4.5.0 (2016/04/08) 引数を可変長CharSequenceに変更
    1575         * @og.rev 6.9.7.0 (2018/05/14) タブや空白文字も null系と判断。
    1576         *
    1577         * @param       strs... 可変長CharSequence
    1578         *
    1579         * @return      最初に現れた、null以外のCharSequenceを、Stringに変換したもの
    1580         */
    1581//      public static CharSequence coalesce( final CharSequence... strs ) {
    1582        public static String coalesce( final CharSequence... strs ) {
    1583                for( final CharSequence str : strs ) {
    1584//                      if( str != null && str.length() > 0 ) { return str.toString(); }
    1585//                      if( ! isEmpty( str ) ) { return str.toString(); }                               // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    1586                        if( ! isNull( str ) ) { return str.toString(); }                                // 6.9.7.0 (2018/05/14) タブや空白文字も null系と判断。
    1587                }
    1588
    1589                return null;
    1590        }
    1591
    1592        /**
    1593         * キーワードに対して、可変長引数の文字列が、含まれているかどうかを判定します。
    1594         * キーワードが、null でなく、比較先の文字列が、ひとつでも含まれると、true が返ります。
    1595         * 大文字小文字は、厳密に判定されます。
    1596         *
    1597         * key != null &amp;&amp; ( key.contains( val1 ) || key.contains( val2 ) ･･･ )
    1598         * の結果と同じです。
    1599         *
    1600         * @og.rev 6.4.4.2 (2016/04/01) contains 判定を行う新しいメソッドを新規追加します。
    1601         *
    1602         * @param       key     キーワード
    1603         * @param       vals... 比較先の可変長文字列(OR判定)
    1604         *
    1605         * @return      キーワード文字列の中に、比較先文字列がひとつでも含まれると、true
    1606         */
    1607        public static boolean contains( final String key , final String... vals ) {
    1608                if( key != null && vals != null ) {
    1609                        for( final String val : vals ) {
    1610                                if( val != null && key.contains( val ) ) { return true; }       // ひとつでも、contains があれば、true
    1611                        }
    1612                }
    1613                return false;
    1614        }
    1615
    1616        /**
    1617         * 連結文字列を使用して、可変長引数のCharSequenceを連結して返します。
    1618         * 連結文字列(delimiter)が、null の場合は、CharSequenceをそのまま連結(nvalAdd)していきます。
    1619         * 連結する文字列が null の場合は、連結しません。
    1620         * 連結文字列は、一番最後は出力されません。
    1621         * 処理できない場合は、長さゼロの文字列を返します。
    1622         *
    1623         * @og.rev 6.4.4.2 (2016/04/01) join 処理を行う新しいメソッドを新規追加します。
    1624         * @og.rev 6.4.5.0 (2016/04/08) 引数を可変長CharSequenceに変更
    1625         *
    1626         * @param       delimiter       連結文字列
    1627         * @param       vals... 連結するCharSequence
    1628         *
    1629         * @return      連結された結果の文字列
    1630         * @see         #nvalAdd( CharSequence... )
    1631         * @og.rtnNotNull
    1632         */
    1633        public static String join( final String delimiter , final CharSequence... vals ) {
    1634                if( delimiter == null ) { return nvalAdd( vals ); }
    1635
    1636                final StringJoiner sjo = new StringJoiner( delimiter );
    1637                for( final CharSequence val : vals ) {
    1638//                      if( val != null && val.length() > 0 ) { sjo.add( val ); }
    1639                        if( ! isEmpty( val ) ) { sjo.add( val ); }                                              // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    1640                }
    1641
    1642                return sjo.toString();
    1643        }
    1644
    1645        /**
    1646         * 引数 vals が、一つでも、null または、ゼロ文字列の場合は､true を返します。
    1647         * それ以外は false を返します。
    1648         *
    1649         * isNull との違いは、スペースやタブ、改行だけの文字列は、null と判定しません。
    1650         * 文字列置換などで、スペースやタブなどと置換する場合、null やゼロ文字列では困る場合などの
    1651         * 判定で使用します。
    1652         *
    1653         * @og.rev 6.9.2.1 (2018/03/12) 新規追加
    1654         *
    1655         * @param    vals 判定するCharSequence(可変長引数)
    1656         *
    1657         * @return  NULL文字列関係の場合は、true を、そうでなければ、false を返す。
    1658         * @see         #isNull( CharSequence... )
    1659         */
    1660        public static boolean isEmpty( final CharSequence... vals ) {
    1661                if( vals != null && vals.length > 0 ) {
    1662                        for( final CharSequence val : vals ) {
    1663                                if( val == null || val.length()==0 ) { return true; }   // val の nullﾁｪｯｸ 必要？
    1664                        }
    1665                        return false;
    1666                }
    1667                return true;
    1668        }
    1669
    1670        /**
    1671         * 引数 vals が、一つでも、null または、ゼロ文字列、またはすべて空白文字(スペース、タブ、改行)の場合は､true を返します。
    1672         * それ以外は false を返します。
    1673         *
    1674         * isEmpty との違いは、判定前に、trim() 処理を行っているため、スペースやタブ、改行だけの文字列も、null と判定します。
    1675         * キーワードとして使用できないケースで、この判定を利用します。
    1676         * また、引数は可変長になっており、指定の｢どれか｣が、成立すれば、true と判定します。
    1677         * 処理的には、 val1 == null || val1.trim().length()==0 || val2 == null || val2.trim().length()==0 ･･･
    1678         *
    1679         * CharSequence 系の配列自体の null チェックも兼ねています。
    1680         *
    1681         * 注意は、オールスペースやタブ文字、改行文字も true になります。
    1682         *
    1683         * @og.rev 6.4.5.0 (2016/04/08) 引数をCharSequenceに変更
    1684         * @og.rev 6.9.0.0 (2018/01/31) 引数を可変長引数に変更
    1685         * @og.rev 6.9.2.1 (2018/03/12) 新規追加
    1686         *
    1687         * @param    vals 判定するCharSequence(可変長引数)
    1688         *
    1689         * @return  NULL文字列関係の場合は、true を、そうでなければ、false を返す。
    1690         * @see         #isNotNull( CharSequence... )
    1691         */
    1692        public static boolean isNull( final CharSequence... vals ) {
    1693                // 6.9.0.0 (2018/01/31) 引数を可変長引数に変更
    1694                if( vals != null && vals.length > 0 ) {
    1695                        for( final CharSequence val : vals ) {
    1696                                if( val == null || val.length()==0 ) { return true; }   // val の nullﾁｪｯｸ 必要？
    1697
    1698                                boolean flag = true;
    1699                                // String.trim().isEmpty() の高速版
    1700                                for( int i=0; i<val.length(); i++ ) {
    1701                                        if( !Character.isWhitespace( val.charAt(i) ) ) {        // 空白文字でなければ
    1702                                                flag = false;                                                                   // 小ループを抜ける。
    1703                                                break;
    1704                                        }
    1705                                }
    1706                                if( flag ) { return true; }                                                             // すべてが空白文字なら、true
    1707                        }
    1708                        return false;
    1709                }
    1710                return true;
    1711        }
    1712
    1713        /**
    1714         * 引数 vals が、すべて、null または、ゼロ文字列、またはすべて空白文字(スペース、タブ、改行)でない場合は､true を返します。
    1715         *
    1716         * #isNull( CharSequence... ) の反転です。
    1717         * そのため、｢すべて｣の文字列が、null か、ゼロ文字、空白文字でない場合のみ、true になります。
    1718         * isNull の表示上、'!' マークのあるなしは、判別しにくいため、メソッドを用意しています。
    1719         *
    1720         * @og.rev 6.9.2.1 (2018/03/12) 新規追加
    1721         *
    1722         * @param    vals 判定するCharSequence(可変長引数)
    1723         *
    1724         * @return  NULL文字列関係でない場合は、true を、｢どれか｣が、NULL文字列関係の場合は、false を返す。
    1725         * @see         #isNull( CharSequence... )
    1726         */
    1727        public static boolean isNotNull( final CharSequence... vals ) {
    1728                return !isNull( vals );
    1729        }
    1730
    1731        /**
    1732         * 浮動小数点数について、カンマ編集を行います。
    1733         *
    1734         * このメソッドでは、1.23 E12 などの数字は扱いません。通常の
    1735         * 数字とピリオドで構成された文字列のみ、変換対象になります。
    1736         * (ただし、不正な文字列を与えてもエラーチェックはしていません。)
    1737         * minFraction には、小数点部に与える固定値を指定します。入力文字列が
    1738         * その桁数より少ない場合は、０埋めします。
    1739         * 多い場合は、四捨五入します。
    1740         * minFraction が 0 の場合は、小数点は付きません。
    1741         * ".12" などの小数点は、必ず先頭に 0 が付きます。
    1742         * 入力文字列が null か、ゼロ文字列時は、そのまま入力データを返します。
    1743         *
    1744         * <pre>
    1745         *      DecimalFormat format = new DecimalFormat( "#,##0.00########" );
    1746         *      double dd = Double.parseDouble( val );
    1747         *      return format.format( dd );
    1748         * </pre>
    1749         * に対して、minFraction分の小数以下のゼロの指定と、inに ',' が
    1750         * 含まれた処理を追加した感じになります。
    1751         *
    1752         * @og.rev 4.0.0.0 (2007/10/26) 空白のトリム処理を追加
    1753         * @og.rev 6.0.4.0 (2014/11/28) 小数点指定が、0 の場合、小数点以下は表示しない
    1754         * @og.rev 6.2.0.0 (2015/02/27) 小数点指定の精度に合わせるのと、内部ロジック完全置換
    1755         * @og.rev 6.2.0.1 (2015/03/06) 互換性の関係で、nullかゼロ文字列の時は、そのまま、in を返す。
    1756         * @og.rev 6.3.6.1 (2015/08/28) throw new OgRuntimeException するのではなく、System.err.println する。
    1757         * @og.rev 6.3.8.5 (2015/10/16) ogErrMsgPrint 使用。
    1758         * @og.rev 6.4.2.0 (2016/01/29) ogErrMsgPrint メソッドを、ThrowUtil クラスに移動のため、修正
    1759         *
    1760         * @param       inStr                   変換元の文字列
    1761         * @param       minFraction     変換時の小数点以下の固定桁数
    1762         *
    1763         * @return      カンマ編集後の数字型文字列
    1764         */
    1765        public static String numberFormat( final String inStr, final int minFraction ) {
    1766//              if( inStr == null || inStr.isEmpty() ) { return inStr ; }               // 6.2.0.1 (2015/03/06) 互換性の関係
    1767                if( isNull( inStr ) ) { return inStr ; }                                                // 6.9.2.1 (2018/03/12) isNull 置き換え
    1768
    1769                String rtn = inStr;
    1770
    1771                try {
    1772                        final double dd = StringUtil.parseDouble( rtn );
    1773
    1774                        if( FMT1.length > minFraction ) {
    1775                                synchronized( FMT1[minFraction] ) {
    1776                                        rtn = FMT1[minFraction].format( dd );
    1777                                }
    1778                        }
    1779                        else {
    1780                                final String fmt = "#,##0." + ZERO.substring( 0,minFraction );
    1781                                rtn = new DecimalFormat( fmt ).format( dd );
    1782                        }
    1783                }
    1784                catch( final Throwable th ) {
    1785                        final String errMsg = "ERROR:" + th.getLocalizedMessage() + CR
    1786                                                        + " in=[" + inStr + "] , minFraction=[" + minFraction + "]" ;
    1787                        // 6.3.8.5 (2015/10/16) ogErrMsgPrint 使用。
    1788                        System.err.println( ThrowUtil.ogThrowMsg( errMsg,th ) );                                // 6.4.2.0 (2016/01/29)
    1789                }
    1790
    1791                return rtn;
    1792        }
    1793
    1794//      /**
    1795//       * 識別id に応じた オブジェクトを作成します。
    1796//       * 作成するには、デフォルトコンストラクターが必要です。
    1797//       *
    1798//       * @og.rev 7.2.5.0 (2020/06/01) ClassLoaderを引数にするnewInstanceメソッドを廃止します。
    1799//       *
    1800//       * @param       cls 作成するクラスのフルネーム
    1801//       *
    1802//       * @return      オブジェクト
    1803//       * @og.rtnNotNull
    1804//       * @throws RuntimeException 何らかのエラーが発生した場合
    1805//       */
    1806//      public static Object newInstance( final String cls ) {
    1807//              return newInstance( cls,Thread.currentThread().getContextClassLoader() );
    1808//      }
    1809
    1810        /**
    1811         * 指定されたクラスローダを使って、識別id に応じた オブジェクトを作成します。
    1812         * 作成するには、デフォルトコンストラクターが必要です。
    1813         * initialize パラメータは true 相当(それまでに初期化されていない場合だけ初期化)です。
    1814         *
    1815         * @og.rev 6.4.3.3 (2016/03/04) リフレクション系の例外の共通クラスに置き換えます。
    1816         * @og.rev 6.8.2.3 (2017/11/10) java9対応(cls.newInstance() → cls.getDeclaredConstructor().newInstance())
    1817         * @og.rev 7.2.5.0 (2020/06/01) ClassLoaderを引数にするnewInstanceメソッドを廃止します。
    1818         *
    1819         * @param       cls             作成するクラスのフルネーム
    1820         *
    1821         * @return      オブジェクト
    1822         * @og.rtnNotNull
    1823         * @throws RuntimeException 何らかのエラーが発生した場合
    1824         */
    1825//      public static Object newInstance( final String cls,final ClassLoader loader ) {
    1826        public static Object newInstance( final String cls ) {
    1827                try {
    1828//                      return Class.forName( cls,true,loader ).getDeclaredConstructor().newInstance();                 // 6.8.2.3 (2017/11/10)
    1829                        return Class.forName( cls ).getDeclaredConstructor().newInstance();                                             // 7.2.5.0 (2020/06/01)
    1830                }
    1831                catch( final NoSuchMethodException | InvocationTargetException ex ) {                                           // 6.8.2.3 (2017/11/10)
    1832                        final String errMsg = "指定のメソッド(コンストラクタ)が見つかりませんでした。class=[" + cls + "]" + CR
    1833                                                + ex.getMessage();
    1834                        throw new OgRuntimeException( errMsg,ex );
    1835                }
    1836                catch( final ReflectiveOperationException ex ) {
    1837                        final String errMsg = "Class.forName( String,boolean,ClassLoader ).newInstance() 処理に失敗しました class=[" + cls + "]" + CR
    1838                                                + ex.getMessage() ;
    1839                        throw new OgRuntimeException( errMsg,ex );
    1840                }
    1841        }
    1842
    1843        /**
    1844         * 指定のURL文字列同士を連結させます。
    1845         * そのとき、後方URLが、絶対パスの場合は、連結せず 後方URLを返します。
    1846         * 第２引数以降は、絶対パス判定をせず直前のURLの末尾判定のみで連結します。
    1847         *
    1848         * 絶対パスかどうかは、通常のファイル属性と同様に、先頭が、'/' (UNIX)または、
    1849         * ２文字目が、":" (Windows)の場合、または、先頭が "\" (ネットワークパス)で
    1850         * 始まる場合で判断します。
    1851         * 連結時に、前方URLの末尾に "/" を付加します。
    1852         *
    1853         * 処理の互換性確保のため、第３引数の可変長引数を追加しています。
    1854         *
    1855         * @og.rev 5.0.0.1 (2009/08/15) 不要なオブジェクトの生成を抑制する。
    1856         * @og.rev 5.6.5.2 (2013/06/21) 第３引数を可変長引数に変更
    1857         * @og.rev 6.4.5.0 (2016/04/08) 引数をCharSequenceに変更
    1858         * @og.rev 6.4.7.2 (2016/06/20) 絶対パスの判定を、可変長URLにも適用する。
    1859         *
    1860         * @param       url1 先頭URLCharSequence
    1861         * @param       urls 後方URL可変長CharSequence(絶対パスの場合は、返り値)
    1862         *
    1863         * @return      URL文字列同士の連結結果 url1 + url2(url2が絶対パスの場合は、url2から連結開始)
    1864         * @og.rtnNotNull
    1865         */
    1866        public static String urlAppend( final CharSequence url1,final CharSequence... urls ) {
    1867                final StringBuilder rtnUrl = new StringBuilder( BUFFER_MIDDLE );
    1868
    1869//              if( url1 != null && url1.length() > 0 ) { rtnUrl.append( url1 ) ; }
    1870                if( isNotNull( url1 ) ) { rtnUrl.append( url1 ) ; }                                     // 6.9.2.1 (2018/03/12) isNotNull 置き換え
    1871
    1872                // ここからが、追加分
    1873                for( final CharSequence url : urls ) {
    1874//                      if( url != null && url.length() > 0 ) {
    1875                        if( isNotNull( url ) ) {                                                                                // 6.9.2.1 (2018/03/12) isNotNull 置き換え
    1876                                if( rtnUrl.length() == 0                                                                        // 戻り値が未設定の場合。
    1877                                        ||       url.charAt(0) == '/'                                                           // 実ディレクトリが UNIX
    1878                                        ||       url.length() > 1 && url.charAt(1) == ':'                       // 実ディレクトリが Windows
    1879                                        ||       url.charAt(0) == '\\' ) {                                                      // 実ディレクトリが ネットワークパス
    1880                                                rtnUrl.setLength( 0 );                          // クリア
    1881                                                rtnUrl.append( url ) ;
    1882                                }
    1883                                else {
    1884                                        final char ch = rtnUrl.charAt( rtnUrl.length()-1 ) ;    // 必ず、何らかのURLがappend済みのはず。
    1885                                        if( ch == '/' || ch == '\\' ) {
    1886                                                rtnUrl.append( url ) ;
    1887                                        }
    1888                                        else {
    1889                                                rtnUrl.append( '/' ).append( url ) ;                            // 6.0.2.5 (2014/10/31) char を append する。
    1890                                        }
    1891                                }
    1892                        }
    1893                }
    1894
    1895                return rtnUrl.toString() ;
    1896        }
    1897
    1898        /**
    1899         * Unicode文字列の値を HTML のエスケープ記号(&amp;#xZZZZ;)に変換します。
    1900         *
    1901         * SJIS(JA16SJIS) で作成されたデータベースに、(NVARCHAR2)を使用して中国語等を登録するのは
    1902         * 非常に複雑でかつ、リスクが大きい処理になります。
    1903         * ORACLE殿でも、自信を持っては勧められない機能とのコメントを頂いています。
    1904         * そこで、HTMLでのエスケープ文字を使用して、Unicodeを文字列化して登録する為の
    1905         * DBType として、新規に作成します。
    1906         * ここでは、入力文字を、キャラクタ(char)型に分解し、(&amp;#xZZZZ;)に変換していきます。
    1907         * よって、通常に１文字(Shift-JISで２Byte,UTF-8で３Byte)が、８Byteになります。
    1908         * この変換された文字列を、HTML上でそのまま取り出すと、元のUnicode文字に戻る為、
    1909         * 通常のShift-JISでは、扱えない文字(中国語など)でも表示可能になります。
    1910         * ここでは、2バイト文字のみ、変換しています。
    1911         *
    1912         * @og.rev 6.4.5.0 (2016/04/08) 引数をCharSequenceに変更
    1913         *
    1914         * @param       value 変換前のCharSequence
    1915         *
    1916         * @return      HTMLのエスケープ記号(&amp;#xZZZZ;)
    1917         * @og.rtnNotNull
    1918         */
    1919        public static String getUnicodeEscape( final CharSequence value ) {
    1920//              if( value == null || value.length() == 0 ) { return ""; }
    1921                if( isEmpty( value ) ) { return ""; }                                   // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    1922
    1923                final StringBuilder rtn = new StringBuilder( value.length() * 4 );
    1924
    1925                for( int i=0; i<value.length(); i++ ) {
    1926                        final char ch = value.charAt(i);
    1927
    1928                        if( ch > 0xff ) {
    1929                                final String hex = Integer.toHexString( (int)ch ) ;
    1930                                rtn.append( UTF_STR[hex.length()] ).append( hex ).append( ';' );                // 6.0.2.5 (2014/10/31) char を append する。
    1931                        }
    1932                        else {
    1933                                rtn.append( ch );
    1934                        }
    1935                }
    1936
    1937                return rtn.toString();
    1938        }
    1939
    1940        /**
    1941         * HTML のエスケープ記号(&amp;#xZZZZ;)をUnicode文字列に戻します。
    1942         *
    1943         * HTMLでのエスケープ文字を使用して登録された文字を、Unicodeに戻します。
    1944         * (&amp;#xZZZZ;)の８Byteを、もとのキャラクタコードに戻し、合成します。
    1945         * ここでは、通常の文字列に混在したエスケープ文字も戻せるようにします。
    1946         *
    1947         * @og.rev 5.9.5.3 (2016/02/26) 無限ループ対応
    1948         *
    1949         * @param       value   HTMLのエスケープ記号(&amp;#xZZZZ;)を含む文字列
    1950         *
    1951         * @return      通常のUnicode文字列
    1952         * @og.rtnNotNull
    1953         */
    1954        public static String getReplaceEscape( final String value ) {
    1955//              if( value == null || value.isEmpty() ) { return ""; }
    1956                if( isEmpty( value ) ) { return ""; }                                   // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    1957
    1958                final StringBuilder rtn = new StringBuilder( value );
    1959
    1960                int st = rtn.indexOf( "&#" );
    1961                while( st >= 0 ) {
    1962                        if( st+7 < rtn.length() && rtn.charAt( st+7 ) == ';' ) {
    1963                                final int ch = Integer.parseInt( rtn.substring( st+3,st+7 ),16 );
    1964                                rtn.replace( st,st+8, Character.toString( (char)ch ) );
    1965                        }
    1966                        st = rtn.indexOf( "&#",st + 1 ); // 5.9.5.3 (2016/02/26) 無限ループ対応
    1967                }
    1968
    1969                return rtn.toString();
    1970        }
    1971
    1972        /**
    1973         * 文字列をdoubleに変換します。
    1974         *
    1975         * これは、Double.parseDouble( value ) と、ほぼ同じ動作を行います。
    1976         * 内部的には、引数の カンマ(,) を削除した文字列を、Double.parseDouble( value )
    1977         * に渡します。
    1978         * また、引数が、null,ゼロ文字列,'_' の時には、0.0 を返します。
    1979         *
    1980         * @og.rev 6.3.9.0 (2015/11/06) もう少し判りやすくする。(処理速度は落ちてます。)
    1981         *
    1982         * @param       value   doubleに変換する元の文字列
    1983         *
    1984         * @return      変換後のdouble数値
    1985         */
    1986        public static double parseDouble( final String value ) {
    1987                double rtn ;
    1988
    1989//              if( value == null || value.isEmpty() || value.equals( "_" ) ) {
    1990                if( isNull( value ) || value.equals( "_" ) ) {                                  // 6.9.2.1 (2018/03/12) isNull 置き換え
    1991                        rtn = 0.0d;
    1992                }
    1993                else if( value.indexOf( ',' ) < 0 ) {
    1994                        rtn = Double.parseDouble( value );
    1995                }
    1996                else {
    1997                        // 6.3.9.0 (2015/11/06) もう少し判りやすくする。(処理速度は落ちてます。)
    1998                        rtn = Double.parseDouble( value.replaceAll( ",","" ) );
    1999                }
    2000
    2001                return rtn ;
    2002        }
    2003
    2004        /**
    2005         * 引数からspanタグを取り除いて返します。
    2006         *
    2007         * 引数が、&lt;span ･･･&gt;YYYY&lt;/span&gt;形式の場合、YYYY のみ出力します。
    2008         * この処理では、先頭にspan が一つだけある場合、削除します。
    2009         * 複数の span や、div などを削除する場合は、#tagCut(String) メソッドで処理します。
    2010         *
    2011         * @og.rev 4.3.4.3 (2008/12/22) TableWriterで利用していたものを移動
    2012         *
    2013         * @param        data 元のString文字列
    2014         *
    2015         * @return      spanタグが取り除かれた文字列(引数が null の場合は、そのまま null が返ります)
    2016         * @see         #tagCut(String)
    2017         */
    2018        public static String spanCut( final String data ) {
    2019                String rtn = data;
    2020                if( data != null && data.startsWith( "<span" ) ) {
    2021                        final int st = data.indexOf( '>' );
    2022                        final int ed = data.indexOf( "</span>",st );
    2023                        rtn = data.substring( st+1,ed );
    2024                }
    2025
    2026                return rtn ;
    2027        }
    2028
    2029        /**
    2030         * 引数からタグを取り除いて返します。
    2031         *
    2032         * 引数が、&lt;xxxx ･･･&gt;YYYY&lt;/xxxx&gt;形式の場合、YYYY のみ出力します。
    2033         * この処理では、すべてのタグを削除し、BODY部をつなげます。
    2034         * &lt;xxxx/&gt; の様な、BODY要素を持たない場合は、ゼロ文字列になります。
    2035         *
    2036         * @og.rev 6.2.0.0 (2015/02/27) 引数からタグを削除し、BODY文字列を切り出します。
    2037         *
    2038         * @param        data 元のString文字列
    2039         *
    2040         * @return       タグが取り除かれた文字列(引数が null の場合は、そのまま null が返ります)
    2041         */
    2042        public static String tagCut( final String data ) {
    2043//              if( data == null || data.isEmpty() || data.indexOf( '<' ) < 0 ) { return data; }
    2044                if( isEmpty( data ) || data.indexOf( '<' ) < 0 ) { return data; }                       // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    2045
    2046                final StringBuilder rtn = new StringBuilder( BUFFER_MIDDLE );
    2047
    2048                boolean tagOut = true;
    2049                for( int i=0; i<data.length(); i++ ) {
    2050                        final char ch =data.charAt( i );
    2051                        if(      ch == '<' ) { tagOut = false; continue; }      // タグの開始
    2052                        else if( ch == '>' ) { tagOut = true;  continue; }      // タグの終了
    2053
    2054                        if( tagOut ) { rtn.append( ch ); }
    2055                }
    2056
    2057                return rtn.toString() ;
    2058        }
    2059
    2060        /**
    2061         * 簡易CSS形式のフォーマットを、Mapにセットします。
    2062         *
    2063         * 簡易CSS形式とは、セレクタのない、{ プロパティ1 : 値1 ; ・・・ } 形式とします。
    2064         * これを、プロパティ1 と 値1 のMap にセットする処理を行います。
    2065         * ブロックコメントは、削除されます。ラインコメントは使えません。
    2066         * また、同一プロパティが記述されている場合は、後処理を採用します。
    2067         *
    2068         * なお、入力テキストが、null か、{…} が存在しない場合は、空のMapを返します。
    2069         *
    2070         * @og.rev 5.6.5.2 (2013/06/21) 新規追加
    2071         * @og.rev 6.4.3.1 (2016/02/12) PMD refactoring. HashMap → ConcurrentHashMap に置き換え。
    2072         * @og.rev 6.4.3.3 (2016/03/04) 戻すMapが、not null制限つきであることを示すため、ConcurrentMap に置き換えます。
    2073         * @og.rev 8.0.0.0 (2021/09/30) CSS形式の整合性チェックを行います。
    2074         *
    2075         * @param        cssText 簡易CSS形式のフォーマット文字列
    2076         *
    2077         * @return      パース結果のMap(ConcurrentMap)
    2078         * @throws      OgRuntimeException 簡易CSS形式のフォーマットの整合性不良の時
    2079         * @og.rtnNotNull
    2080         */
    2081        public static ConcurrentMap<String,String> cssParse( final String cssText ) {
    2082                final ConcurrentMap<String,String> cssMap = new ConcurrentHashMap<>();
    2083
    2084                if( cssText != null ) {
    2085                        // まずコメントを削除します。
    2086                        final StringBuilder buf = new StringBuilder( cssText );
    2087
    2088                        int ad1 = buf.indexOf( "/*" );
    2089                        while( ad1 >= 0 ) {
    2090                                final int ad2 = buf.indexOf( "*/" , ad1 );
    2091                                if( ad2 < 0 ) { buf.delete( ad1,buf.length() ); break; }                // 閉じてなければ以降を全削除
    2092                                buf.delete( ad1,ad2+2 );
    2093                                ad1 = buf.indexOf( "/*" );              // コメントは削除されたので、初めから検索する。
    2094                        }
    2095
    2096                        // 処理対象は、{ ～ } の間の文字列
    2097                        ad1 = buf.indexOf( "{" ) ;                                      // なければ、0:先頭から
    2098                        final int ad2 = buf.lastIndexOf( "}" );         // 後ろから検索(複数存在する場合の中間は無視する)
    2099
    2100                        if( ad1 >= 0 && ad2 > 0 ) {
    2101                                final String tempText = buf.substring( ad1+1,ad2 ).trim();              // これが処理対象の文字列
    2102                                if( tempText.isEmpty() ) { return cssMap ; }                                    // 空文字列の場合は抜ける
    2103
    2104                                if( tempText.contains( "//" ) ) {
    2105                                        final String errMsg = "ラインコメント『//』は使えません。"+ CR
    2106                                                                        + " cssText=[" + cssText + "]" ;
    2107                                        throw new OgRuntimeException( errMsg );
    2108                                }
    2109
    2110                                // 8.0.0.0 (2021/09/30) CSS形式の整合性チェックを行います。
    2111                                // KEY:VAL; なので、':' と ';' の個数は一致するはず
    2112                                int cnt1 = 0;
    2113                                int cnt2 = 0;
    2114                                boolean errFlag = false;
    2115                                for( int i=0; i<tempText.length(); i++ ) {
    2116                                        final char ch = tempText.charAt(i);
    2117                                        if( ch == ':' ) { cnt1++; }                                     // 必ず最初に見つかる
    2118                                        else if( ch == ';' ) { cnt2++; }                        // 次に見つかる
    2119
    2120                                        if( cnt1 != cnt2 && cnt1 != cnt2+1 || ch == '{' || ch == '}' ) {        // ：と;の数と前後関係のﾁｪｯｸ
    2121                                                errFlag = true;
    2122                                                break;
    2123                                        }
    2124                                }
    2125                                if( errFlag || cnt1 == 0 || cnt2 == 0 ) {                                                               // ':' と ';' の個数が不一致か存在しない場合
    2126                                        final String errMsg = "':' と ';' の個数が不一致か存在しないか、{} が不整合です。"+ CR
    2127                                                                        + " cssText=[" + cssText + "]" ;
    2128                                        throw new OgRuntimeException( errMsg );
    2129                                }
    2130
    2131                                // 6.4.3.3 (2016/03/04) ちょっとした変更
    2132                                for( final String recode : tempText.split( ";" ) ) {    // KEY1 : VAL1; の ; で分割する。
    2133                                        final int ad = recode.indexOf( ':' );
    2134                                        if( ad > 0 ) {
    2135                                                final String key = recode.substring( 0,ad ).trim();
    2136                                                final String val = recode.substring( ad+1 ).trim();
    2137                                                if( key.isEmpty() || val.isEmpty() ) { continue; }              // どちらかが空文字列の場合は、設定しない。
    2138
    2139                                                cssMap.put( key,val );
    2140                                        }
    2141                                }
    2142                        }
    2143                }
    2144
    2145                return cssMap ;
    2146        }
    2147
    2148//      /**
    2149//       * 引数から空白文字を削除して返します。
    2150//       *
    2151//       * @og.rev 5.6.9.4 (2013/10/31) TableWriterで利用していたものを移動
    2152//       * @og.rev 6.9.2.1 (2018/03/12) 使用箇所が、１箇所だけなので、StringUtilから移動する。
    2153//       *
    2154//       * @param        data 元のString文字列
    2155//       *
    2156//       * @return       空白文字が取り除かれた文字列
    2157//       */
    2158//      public static String deleteWhitespace( final String data ) {
    2159//              // 6.4.1.1 (2016/01/16) PMD refactoring. A method should have only one exit point, and that should be the last statement in the method
    2160//              return data == null || data.isEmpty() ? data : data.replaceAll( "\\s", "" ) ;           // isNull 判定は使えない。
    2161//      }
    2162
    2163        /**
    2164         * 引数の文字列が、引数の char で始まるかどうか判定します[始まる場合は、true]。
    2165         *
    2166         * これは、PMDで言う所の、String.startsWith can be rewritten using String.charAt(0)
    2167         * の書き換え処理に相当します。
    2168         * boolean flag = data != null &amp;&amp; data.startsWith( chStr ); 的な処理を、
    2169         * boolean flag = data != null &amp;&amp; data.length() &gt; 0 &amp;&amp; data.charAt(0) == ch;
    2170         * に書き換える代わりに、このメソッドを使用します。
    2171         *
    2172         * 内部ロジックは、上記の相当します。
    2173         *
    2174         * @og.rev 6.2.0.0 (2015/02/27) １文字 String.startsWith の String.charAt(0) 変換
    2175         * @og.rev 6.4.5.0 (2016/04/08) 引数をCharSequenceに変更
    2176         *
    2177         * @param        data 引数のCharSequence
    2178         * @param        ch   チェックするchar
    2179         *
    2180         * @return      引数文字列が、nullでなく、ゼロ文字列でなく、引数char で始まる場合は、true
    2181         * @see         java.lang.String#startsWith(String)
    2182         */
    2183        public static boolean startsChar( final CharSequence data , final char ch ) {
    2184                return data != null && data.length() > 0 && data.charAt(0) == ch;                       // スペースも判定対象にするため、isNull は使わない。
    2185        }
    2186
    2187        /**
    2188         * 引数から指定文字の分のバイト数で切った文字列を返します。
    2189         * 文字列のバイト数は指定のエンコードでカウントします。
    2190         * （文字の途中で切れる事はありません）
    2191         *
    2192         * @og.rev 5.9.1.3 (2015/10/30) 新規作成
    2193         * @og.rev 6.4.2.0 (2016/01/29) StringUtil#ogStackTrace(Throwable) を、ThrowUtil##ogStackTrace(Throwable) に変更。
    2194         *
    2195         * @param       org                     元のString文字列
    2196         * @param       cutBytes        切るバイト数
    2197         * @param       enc                     文字列のエンコード
    2198         *
    2199         * @return       バイト数で切った文字列
    2200         */
    2201        public static String cut( final String org, final int cutBytes, final String enc ) {
    2202                try {
    2203//                      if( org == null || org.length() == 0 || cutBytes <= 0 || org.getBytes(enc).length <= cutBytes ) {               // isNul 判定は使いません。
    2204//                              return org;
    2205//                      }
    2206                        if( isEmpty( org,enc ) || cutBytes <= 0 || org.getBytes(enc).length <= cutBytes ) { return org; }               // 6.9.2.1 (2018/03/12) isEmpty 置き換え
    2207
    2208                        final StringBuilder cutSb = new StringBuilder( BUFFER_MIDDLE );
    2209                        final StringBuilder tmpSb = new StringBuilder( BUFFER_MIDDLE );
    2210
    2211                        for( int i=0; i<org.length(); i++ ) {
    2212                                final String cut = org.substring(i, i + 1);
    2213                                if( cutBytes < tmpSb.toString().getBytes(enc).length + cut.getBytes(enc).length ) {
    2214                                        cutSb.append( tmpSb.toString() );
    2215                                        break;
    2216                                }
    2217                                tmpSb.append(cut);
    2218                        }
    2219                        return cutSb.toString();
    2220                }
    2221                catch( final UnsupportedEncodingException ex ) {
    2222                        // 6.4.1.1 (2016/01/16) PMD refactoring.        Avoid printStackTrace(); use a logger call instead.
    2223                        // 6.4.2.0 (2016/01/29) StringUtil#ogStackTrace(Throwable) を、ThrowUtil##ogStackTrace(Throwable) に変更。
    2224                        final String errMsg = "エンコードが不正のため、バイトカットできません。"
    2225                                                                                + " org=[" + org + "] , byteSize=[" + cutBytes + "] , encode=[" + enc + "]" ;
    2226
    2227                        System.err.println( ThrowUtil.ogThrowMsg( errMsg,ex ) );
    2228                        return org;
    2229                }
    2230        }
    2231
    2232        /**
    2233         * 引数から指定文字の分のバイト数で切った文字列を返します。
    2234         * バイト数のカウントはUTF-8として行います。
    2235         *
    2236         * @og.rev 5.9.1.3 (2015/10/30) 新規作成
    2237         *
    2238         * @param       org 元のString文字列
    2239         * @param       cutBytes 切るバイト数
    2240         *
    2241         * @return       バイト数で切った文字列
    2242         */
    2243        public static String cut( final String org, final int cutBytes ) {
    2244                return cut( org, cutBytes, "UTF-8");
    2245        }
    2246
    2247        /**
    2248         * 元の引数から開始文字列と終了文字列の間の文字列と、残りを連結した文字列を生成します。
    2249         * 戻り値は、連結した文字列で、切り取った間の文字列は、関数型インタフェースの引数に設定されます。
    2250         * なお、文字列の切り出しは、1度だけです。最初に見つかった、開始文字列と、その次に見つかった
    2251         * 終了文字列の間を切り取って、前後を連結するだけです。
    2252         *
    2253         * 元の文字列が、nullの場合は、return null で、関数I/Fは call されません。
    2254         * 元の文字列に、stStr(開始文字列)が含まれない/またはnullの場合は、return 元の文字列で、関数I/Fは call されません。
    2255         * 元の文字列に、stStr(開始文字列)が含まれ、edStr(終了文字列)が含まれない場合は、return 開始文字列以前と、(v) -> 開始文字列以降 をcallします。
    2256         * 元の文字列に、stStrもedStrも含む場合は、それらの間の文字列を削除(stStr,edStr含む)と、その間の文字列を引数に、
    2257         *   return 連結した文字列と、(v) -> 切り取った間の文字列 をcallします。
    2258         * 上記の場合、間の文字列が存在しない場合は、空文字列になります。
    2259         *
    2260         * stStr(開始文字列)とed(終了文字列)に関しては、trim() して、前後の空欄は削除します。
    2261         *
    2262         * 例） splitFromTo( "abc class= XYZ ; efg" , "class=" , ";" v -> call(v) );
    2263         * return "abc  efg"
    2264         * call   "XYZ"
    2265         *
    2266         * 例） splitFromTo( "abc class= XYZ efg" , "class=" , ";" , ";" v -> call(v) );
    2267         * return "abc "
    2268         * call   "XYZ efg"
    2269         *
    2270         * 例） splitFromTo( "abc style= XYZ ; efg" , "class=" , ";" , ";" v -> call(v) );
    2271         * return "abc style= XYZ ; efg"
    2272         * call   実行されない(nullだから)
    2273         *
    2274         * @og.rev 8.0.0.2 (2021/10/15) 新規作成
    2275         *
    2276         * @param       org  元のString文字列(nullも可)
    2277         * @param       stStr 開始文字列
    2278         * @param       edStr 終了文字列
    2279         * @param       cons  関数型インタフェースで、切り取った文字列を引数に呼び出されます。
    2280         *
    2281         * @return 削除後連結文字列と切り出した文字列の配列(必ず 2個の配列を返す)
    2282         */
    2283        public static String splitStartEnd( final String org, final String stStr, final String edStr , final Consumer<String> cons ) {
    2284                String val1 = org ;             // 切り取られた、前後の文字列を連結
    2285
    2286                if( org != null && stStr != null ) {
    2287                        final int st = org.indexOf( stStr );
    2288                        if( st >= 0 ) {
    2289                                final int cutSt = st + stStr.length();                          // 見つけた開始文字列＋開始文字列の長さ
    2290                                // edStr の nullﾁｪｯｸと、indexOf 判定を兼ねる。
    2291                                final int ed = edStr == null ? -1 : org.indexOf( edStr , cutSt );
    2292                                // stStr と、edStr の間の文字列を切り取る
    2293                                final String val2 ;             // 間の文字列
    2294                                if( ed >= 0 ) {
    2295                                        val1 = org.substring( 0,st ) + org.substring( ed+edStr.length() );      // edStr は含まない
    2296                                        // "abc class= XYZ ; efg" の場合、"XYZ" を取得
    2297                                        val2 = org.substring( cutSt , ed ).trim();              // 前後の空白は除去
    2298                                }
    2299                                else {
    2300                                        val1 = org.substring( 0,st );
    2301                                        // "abc class= XYZ efg" の場合、"XYZ efg" を取得
    2302                                        val2 = org.substring( cutSt ).trim();                   // 前後の空白は除去
    2303                                }
    2304                                cons.accept( val2 );    // 関数型インタフェースの呼び出し。
    2305                        }
    2306                }
    2307                return val1 ;
    2308        }
    2309}