※上記の広告は60日以上更新のないWIKIに表示されています。更新することで広告が下部へ移動します。


import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.io.UnsupportedEncodingException;

/**
* 文字列ユーティリティクラス。<br>
* <br>
* 以下の機能を提供します。<br>
* <ul>
* <li>null チェック</li>
* <li>空チェック</li>
* <li>有効データチェック</li>
* <li>数値チェック</li>
* <li>末尾空白削除</li>
* <li>半角文字構成チェック</li>
* <li>半角数字構成チェック</li>
* <li>全角カナ構成チェック</li>
* <li>半角カナ構成チェック</li>
* <li>指定文字列存在チェック</li>
* <li>文字列置換</li>
* <li>整数から小数に変換</li>
* <li>小数点以下桁数変換</li>
* <li>小数から整数に変換</li>
* <li>指定桁数まで文字を追加</li>
* <li>ゼロパディング</li>
* <li>ゼロサプレス</li>
* <li>数値計算(加算)</li>
* <li>数値計算(減算)</li>
* <li>数値計算(乗算)</li>
* <li>数値計算(除算)</li>
* <li>全角文字チェック</li>
* <li>文字列置換</li>
* </ul>
*/
public class UtilString {
 
  /**
   * デフォルトコンストラクタ。
   */
  private UtilString(){
  }
 
  /**
   * オブジェクト data がnullであるか検査します。<br>
   * <br>
   * data が null の場合は true を返します。<br>
   * data が null でない場合は falseを返します。<br>
   * <br>
   * @param  data  対象文字列
   * @return  result  チェック結果
   */
  public static boolean isNull(Object data){
    if(data == null)
      return true;
    else
      return false;
  }
 
  /**
   * 文字列 data が空であるか検査します。<br>
   * <br>
   *spaceFlgで末尾の空白を許容するか選択できます。<br>
   * spaceFlg がtrueの場合は末尾の空白を許容します。<br>
   * spaceFlg がfalseの場合は末尾の空白を許容しません。<br>
   * data が空である場合は true を返します。<br>
   * data が空でない場合は false を返します。<br>
   * data が null である場合は true を返します。<br>
   * <br>
   * @param  data    判定対象の文字列
   * @param  spaceFlg  空白許可フラグ
   * @return  result    チェック結果
   */
  public static boolean isEmpty(String data, boolean spaceFlg) {
    // null チェック
    if(isNull(data))
      return true;
   
   //空白を許容しない場合は末尾の空白をトリムする
    if(!spaceFlg)
      data = rtrim(data);
   
    if(data.length() < 1)
      return true;
    else
      return false;
  }

  /**
   * 文字列dataがデータとして有効であるか検査します。<br>
   * <br>
  *データとして有効な範囲は以下の通りです。<br>
   * ・null でない<br>
   * ・空でない<br>
   * ・全角・半角空白だけの文字列でない<br>
   * 有効データである場合は trueを返します。<br>
   * 有効データでない場合はfalseを返します。<br>
   * <br>
   * @param data 対象文字列
   * @return boolean チェック結果
   */
  public static boolean isValid(String data) {
    // 全角空白を半角空白に置換
    String s = replace(data,UtilConstants.S_FULL_SPACE,UtilConstants.S_HALF_SPACE);
   
    // 空白を取り除いて判断
    if(s.trim().length() == 0)
      return false;
    else
      return true;
  }

  /**
   * 文字列 data が数値であるか検査します。<br>
   * <br>
   * 数値の範囲は以下の通りです。<br>
   * ・null でない<br>
   * ・空でない<br>
   * ・全角・半角空白だけの文字列でない<br>
   * マイナスの値と小数に対応しています。<br>
   * 数値である場合は true を返す<br>
   * 数値でない場合は false を返す<br>
   * <br>
   * @param  data  対象文字列
   * @return  result  チェック結果
   */
  public static boolean isNumeric(String data){
    // null チェック
    if(isNull(data))
      return false;
   
    // 有効データチェック
    if(!isValid(data))
      return false;
   
    // BigDecimal に変換
    try{
      new BigDecimal(data);
    }catch(NumberFormatException e){
     //例外が発生した場合は数値として正しくない
      return false;
    }
   
    return true;
  }

  /**
   * 文字列 data の末尾の空白を削除します。<br>
   * <br>
  *末尾の全角空白・半角空白を取り除きます。<br>
   * 引数が不正の場合は null を返します。<br>
   * <br>
   * @param  data  文字列
   * @return result 文字列の末尾のスペースを取り除いた文字列
   */
  public static String rtrim(String data) {
    // null チェック
    if(isNull(data))
      return UtilConstants.S_HALF_SPACE;
   
    while(data.endsWith(" ") || data.endsWith(" ")) {
      data = data.substring(0, data.length() - 1);
    }
   
    return data;
  }
  
  /**
   * 文字列dataが半角文字で構成されているか検査します。<br>
   * <dr>
   * 半角文字の範囲は以下の通りです。<br>
   * ・半角英字 !~~<br>
   * ・半角カナ 。~゚<br>
   * ・null でない<br>
   * ・空でない<br>
   * 文字列中の半角空白は許容されます。<br>
   *spaceFlgで空白のみの文字列を許容するか選択できます。<br>
   * spaceFlg がtrueの場合は空白のみの文字列も許容します。<br>
   * spaceFlg がfalseの場合は空白のみの文字列は許容しません。<br>
   * 半角文字のみで構成されている場合はtrueを返します。<br>
   * 半角文字のみで構成されていない場合はfalseを返します。<br>
   * <br>
   * @param  data     対象の文字列
   * @param  spaceFlg  空白許容フラグ
   * @return result    チェック結果
   */
  public static boolean isHalfChar(String str, boolean spaceFlg){
    // null チェック
    if(isNull(str))
      return false;
   
    if(!spaceFlg){
      // 有効データチェック
      if (!UtilString.isValid(str))
        return false;
    }

    char[] chars = str.toCharArray( );
    int length = chars.length;

    for (int i = 0; i < length; i++){
      // 範囲に入っていない場合は false
      if(chars[i] != UtilConstants.C_HALF_SPACE
       &&!(UtilConstants.C_HALF_NUMBER_AND_ALPHABET_START <= chars[i]&&chars[i] <= UtilConstants.C_HALF_NUMBER_AND_ALPHABET_END)
        && !(UtilConstants.C_HALF_KATAKANA_START<=chars[i] && chars[i] <=UtilConstants.C_HALF_KATAKANA_END)){
        return false;
      }
    }
    return true;
  }
 
  /**
   * 文字列dataが半角数字で構成されているか検査します。<br>
   * <br>
   * 半角数字の範囲は以下の通りです。<br>
   * ・半角数字 u0030~u0039<br>
   * ・null でない<br>
   * ・空でない<br>
   * ・全角・半角空白だけの文字列でない<br>
   * ・半角空白が混在していない<br>
   *periodFlgで半角ピリオド(小数点)を許容するか選択できます。<br>
   * periodFlg がtrueの場合はピリオドを許容します。<br>
   * periodFlg がfalseの場合はピリオドを許容しません。<br>
   * ピリオドが複数混在していてもtrueを返します。<br>
   *minusFlgで半角ハイフン(マイナス値)を許容するか選択できます。<br>
   * minusFlg がtrueの場合はハイフンを許容します。<br>
   * minusFlg がfalseの場合はハイフンを許容しません。<br>
   * ハイフンが複数混在している場合もtrueを返します。
   * 半角数字のみで構成されている場合はtrueを返します。<br>
   * 半角数字のみで構成されていない場合はfalseを返します。<br>
   * 数値としての検査をする場合はisNumeric()メソッドを使用してください。<br>
   * <br>
   * @param  data    対象の文字列
   * @param  periodFlg  ピリオド許可フラグ
   * @param  minusFlg  ハイフン許可フラグ
   * @return  result    チェック結果
   */
  public static boolean isHalfNumber(String data, boolean periodFlg,booleanhyphenFlg) {
    // null チェック
    if(isNull(data))
      return false;
   
    // 有効データチェック
    if(!isValid(data))
      return false;

    char[] chars = data.toCharArray( );
   
    // チェック結果
    boolean result = false;
   
    for(int i = 0; i < chars.length; i++) {
      // 初期化
      result = false;
     
      // 範囲に入っている場合に true となる
      // 半角数字
      if((UtilConstants.C_HALF_NUMBER_START <= chars[i]&&chars[i] <= UtilConstants.C_HALF_NUMBER_END))
        result = true;
     
      // 半角ピリオド
      if(periodFlg)
        if(UtilConstants.C_HALF_PERIOD == chars[i])
          result = true;
     
      // 半角マイナス
      if(hyphenFlg)
        if(UtilConstants.C_HALF_HYPHEN == chars[i])
          result = true;
     
      if(!result)
        return false;
    }
    return result;
  }
 
  /**
   * 文字列dataが全角カナで構成されているか検査します。<br>
   * <br>
   * 全角カナの範囲は以下の通りです。<br>
   * ・全角句読点 u3001~u3002<br>
   * ・全角横線点 u30FB~u30FC<br>
   * ・全角濁点半濁点 u309B~u309C<br>
   * ・全角カナ u30A1~u30FE<br>
   * ・全角空白 u3000<br>
   * ・null でない<br>
   * ・空でない<br>
   * ・全角・半角空白だけの文字列でない<br>
   *spaceFlgで全角空白を許容するか選択できます。<br>
   * spaceFlg が trueの場合は空白を許容します。<br>
   * spaceFlg がfalseの場合は空白を許容しません。<br>
   * 全角カナで構成されている場合はtrueを返します。<br>
   * 全角カナで構成されていない場合はfalseを返します。<br>
   * <br>
   * @param  data    対象の文字列
   * @param  spaceFlg  全角空白許可フラグ
   * @return  result    チェック結果
   */
  public static boolean isFullKana(String data, boolean spaceFlg) {
    // null チェック
    if(isNull(data))
      return false;
   
    // 有効データチェック
    if(!isValid(data))
      return false;
   
    char[] chars = data.toCharArray( );
    int length = chars.length;
   
    // チェック結果
    boolean result = false;
   
    for(int i = 0; i < length; i++){
      // 初期化
      result = false;
     
      // 範囲に入っている場合に true となる
      // 全角カナ
      if((UtilConstants.C_FULL_KATAKANA_START <=chars[i]&& chars[i] <= UtilConstants.C_FULL_KATAKANA_END)
        || (UtilConstants.C_FULL_KUTOUTEN_START <=chars[i]&& chars[i] <= UtilConstants.C_FULL_KUTOUTEN_END)
        || (UtilConstants.C_FULL_DAKUTEN_HANDAKUTEN_START<=chars[i] && chars[i]<=UtilConstants.C_FULL_DAKUTEN_HANDAKUTEN_END)
        || (UtilConstants.C_FULL_YOKOSEN_AND_TEN_START<=chars[i] && chars[i] <=UtilConstants.C_FULL_YOKOSEN_AND_TEN_END)){
        result = true;
      }
     
      // 全角空白
      if(spaceFlg)
        if(UtilConstants.C_FULL_SPACE == chars[i])
          result = true;
     
      // result が false の場合、false を返す
      if(!result)
        return result;
    }
   
    return result;
  }

  /**
   * 文字列dataが半角カナで構成されているか検査します。<br>
   * <br>
   * 半角カナの範囲は以下の通りです。<br>
   * ・半角カナ uFF61~uFF9F<br>
   * ・半角空白 <br>
   * ・null でない<br>
   * ・空でない<br>
   * ・全角・半角空白だけの文字列でない<br>
   *spaceFlgで半角空白を許容するか選択できます。<br>
   * spaceFlg が trueの場合は空白を許容します。<br>
   * spaceFlg がfalseの場合は空白を許容しません。<br>
   * 半角カナのみで構成されている場合はtrueを返します<br>
   * 半角カナのみで構成されていない場合はfalseを返します<br>
   * <br>
   * @param  data    対象の文字列
   * @param  spaceFlg  半角空白許可フラグ
   * @return  result    チェック結果
   */
  public static boolean isHalfKana(String data, boolean spaceFlg) {
    // null チェック
    if(isNull(data))
      return false;
   
    // 有効データチェック
    if(!isValid(data))
      return false;
   
    char[] chars = data.toCharArray( );
    int length = chars.length;
   
    // チェック結果
    boolean result = false;
   
    for(int i = 0; i < length; i++) {
      // 初期化
      result = false;
     
      // 範囲に入っている場合に true となる
      // 半角カナ
      if((UtilConstants.C_HALF_KATAKANA_START <=chars[i]&& chars[i] <= UtilConstants.C_HALF_KATAKANA_END)) {
        result = true;
      }
     
      // 半角空白
      if(spaceFlg)
        if(UtilConstants.C_HALF_SPACE == chars[i])
          result = true;
     
      // result が false の場合 false を返す
      if(!result)
        return result;
    }
    return result;
  }

  /**
  *文字列中に指定語句が存在するか検査します。<br>
   * <br>
   * 指定語句が存在する場合はtrueを返します。<br>
   * 指定語句が存在しない場合はfalseを返します。<br>
   * <br>
   * @param  data  対象文字列
   * @param  target  検索語句
   * @return  result  チェック結果
   */
  public static boolean isOccurrence(String data, String target){
    // null チェック
    if(isNull(data) || isNull(target))
      return false;
   
    // size チェック
    if(data.length() < target.length())
      return false;
   
    // インデックスリスト
    List indexList = new ArrayList();
   
    // 文字存在チェック
    for(int i= 0; i < target.length(); i++){
      // インデックス取得
      int index = data.indexOf(target.charAt(i));
     
     //指定語句の文字が対象文字列中に存在するかチェック
      if(index == -1)
        return false;
     
      // インデックスリストに追加
      indexList.add(String.valueOf(index));
    }
   
   //文字一致チェック(インデックスが連番になっているかチェック)
    for(int i = 0; i < indexList.size(); i++){
      // i番目のインデックスを取得
      int index = Integer.parseInt((String)indexList.get(i));
     
      // 仮の前インデックスを設定
      int preIndex = index - 1;
     
     //iが0番目以外の時にpreIndexにi-1のインデックスを設定する
      if(i != 0)
        preIndex = Integer.parseInt((String)indexList.get(i-1));
     
      // 連番であるか判断
      if(!(index - 1 == preIndex))
        return false;
    }
   
    return true;
  }
 
  /**
   *文字列中の文字を指定文字に置換します。<br>
   * <br>
   * 文字列 data 中の target をvalueに置き換えます。<br>
   * 引数が不正だった場合は nullを返します。<br>
   * <br>
   * @param  data  文字列
   * @param  target  対象の文字
   * @param  value  置き換える文字
   * @return  result  置換後の文字列
   */
  public static String replace(String data, String target, String value){
    // null チェック
    if(isNull(data) || isNull(target) || isNull(value))
      return null;
   
    StringBuffer sb = new StringBuffer(data);
   
    String w = new String(data);
   
    int start = 0;
    int end = 0;

    while(true){
      start = w.indexOf(target);
     
      if (start == -1)
        return w;
     
      end = start + target.length();
      if(end == -1)
        return w;
     
      if(value == null)
        value = UtilConstants.S_EMPTY;
     
      w = sb.replace(start, end, value).toString();
    }
  }
 
  /**
   * 文字列整数 data を小数に変換します。<br>
   * <br>
   *dataに小数を指定することで端数処理をすることが可能です。<br>
  *この場合は指定した小数桁数になるよう端数処理をします。<br>
   * scaleで小数点以下の桁数を指定できます。<br>
   * mode で端数処理の方法を選択できます。<br>
   * mode が1の場合は端数を切り上げます。(RoundUp)<br>
   * mode が2の場合は端数を四捨五入します。(RoundHalfUp)<br>
   * mode が3の場合は端数を切り捨てます。(RoundDown)<br>
   * 引数が不正の場合は null を返します。<br>
   * <br>
   * @param  data  整数(または小数)
   * @param  scale  小数点以下桁数
   * @param  mode  端数処理
   * @return  result  小数
   */
  public static String cnvDecimal(String data, int scale, int mode){
   
    // data 数値チェック
    if(!isNumeric(data))
      return null;
   
    // 端数処理設定
    switch(mode){
      case 1:
        mode = BigDecimal.ROUND_UP;
        break;
      case 2:
        mode = BigDecimal.ROUND_HALF_UP;
        break;
      case 3:
        mode = BigDecimal.ROUND_DOWN;
        break;
      default:
        return null;
    }
   
    // BigDecimal に変換
    BigDecimal result = new BigDecimal(data);
    // 桁数設定・端数処理
    result.setScale(scale, mode);
   
    return result.toString();
  }
 
  /**
   * 文字列小数 data を整数に変換します。<br>
   * <br>
   *modeで小数点第1桁の端数処理の方法を選択できます。<br>
   * mode が1の場合は端数を切り上げます。(RoundUp)<br>
   * mode が2の場合は端数を四捨五入します。(RoundHalfUp)<br>
   * mode が3の場合は端数を切り捨てます。(RoundDown)<br>
   * 引数が不正の場合は null を返します<br>
   * <br>
   * @param  data  小数
   * @param  mode  端数処理
   * @return  result  整数
   */
  public static String cnvIntegral(String data, int mode){
   
    // data 数値チェック
    if(!isNumeric(data))
      return null;
   
    // 端数処理設定
    switch(mode){
      case 1:
        mode = BigDecimal.ROUND_UP;
        break;
      case 2:
        mode = BigDecimal.ROUND_HALF_UP;
        break;
      case 3:
        mode = BigDecimal.ROUND_DOWN;
        break;
      default:
        return null;
    }
   
    // BigDecimal に変換
    BigDecimal result = new BigDecimal(data);
    // 端数処理
    result = result.setScale(0, mode);
   
    return result.toString();
  }
 
  /**
   * 文字列数値を先頭の0を除いた数値に変換します。<br>
   * <br>
   * 変換イメージ[001000 → 1000]<br>
   * マイナスの値や小数に対応しています。<br>
   * 引数が不正だった場合は nullを返します。<br>
   * <br>
   * @param  data  変換前文字列
   * @return  result  変換後文字列
   */
  public static String cnvNumber(String data){
    // null チェック
    if(UtilString.isNull(data))
      return null;
   
    // 数値チェック
    if(!UtilString.isNumeric(data))
      return null;
   
    // 変換
    return new BigDecimal(data).toString();
  }
 
  /**
   * 文字列 data に挿入文字 appendix を指定桁数digitになるまで追加します。<br>
   * <br>
   * 半角文字に対応しています。<br>
   * 全角文字は対応していません。<br>
   *appendixには半角文字1文字しか指定できません。<br>
   * 引数が不正の場合は null を返します。<br>
   * <br>
   * @param  data    対象文字列
   * @param  appendix  挿入文字
   * @param  digit    指定桁数
   * @return  result    変換結果文字
   */
  public static String cnvHalfString(String data, String appendix,intdigit){
   
    // 対象文字列 null チェック
    if(isNull(data))
      return null;
   
    // 挿入文字 null チェック
    if(isNull(appendix))
      return null;
   
    // 挿入文字 空チェック
    if(appendix.length() == 0)
      return null;
   
    // 挿入文字 サイズチェック
    if(appendix.length() != 1)
      return null;
   
    // 対象文字列 半角文字チェック
    if(data.length() != 0)
      if(!isHalfChar(data, true))
        return null;
   
    // 挿入文字 半角文字チェック
    if(!isHalfChar(appendix, true))
      return null;
   
    // data を StringBuffer に変換
    StringBuffer after = new StringBuffer(data);
   
    // ループ回数取得
    int loop = digit - data.length();
   
    // 挿入文字を指定された桁になるまで挿入
    for(int i = 0; i < loop; i++)
      after.insert(0, appendix);
   
    return after.toString();
  }
 
  /**
   * 文字列 data をゼロパディングします。<br>
   * <br>
   * 半角文字に対応しています。
   * 全角文字は対応していません。
   *マイナスの値や小数は対応していません。<br>
   * 引数が不正の場合 null を返します。<br>
   * 変換イメージ[before:100,digit:5 → return:00100]
   *
   * @param  data  変換前の文字列数値
   * @param  digit  桁数
   * @return  result  変換後の文字列数値
   */
  public static String cnvZeroPadding(String data, int digit){
   
    // 半角数字チェック
    if(!isHalfNumber(data, false, false))
      return null;
   
    // 渡された数値を StringBuffer に変換
    StringBuffer after = new StringBuffer(data);
   
    // 渡された数値の桁数と要求された桁数を比較
    if(after.length() < digit){
     
      // 差分桁数
      int ins = digit - after.length();
     
      // 差分桁数分ループ
      for(int i = 0; i < ins; i++){
        // 数値(StringBuffer型)の頭に0を追加
        after.insert(0, UtilConstants.S_0);
      }
    }
   
    // String型に変換
    return after.toString();
  }
 
  /**
   * 文字列 data をゼロパディングします。<br>
   * <br>
   * 半角文字に対応しています。
   * 全角文字は対応していません。
   *マイナスの値や小数は対応していません。<br>
   * 引数が不正の場合 null を返します。<br>
   * 変換イメージ[before:100,digit:5 → return:00100]
   *
   * @param  data  変換前の文字列数値
   * @param  digit  桁数
   * @return  result  変換後の文字列数値
   */
  public static String cnvZeroPadding(int data, int digit){
    return cnvZeroPadding(String.valueOf(data), digit);
  }
 
  /**
   * 文字列 data をゼロサプレスします。<br>
   * <br>
   * 変換イメージ[before:00100 → return: 100]<br>
   * 引数が不正の場合は null を返します。<br>
   * <br>
   * @param  data  変換前の文字列数値
   * @return  result  変換後の文字列数値
   */
  public static String cnvZeroSuppress(String data){
   
    // 半角数字チェック
    if(!isHalfNumber(data, true, true))
      return null;
   
    StringBuffer result = new StringBuffer();
   
    for(int i = 0; i < data.length(); i++){
      char c = data.charAt(i);
      if(c == UtilConstants.C_0){
        result.append(UtilConstants.S_HALF_SPACE);
      }else{
        result.append(data.substring(i, data.length()));
        break;
      }
    }
   
    // String型に変換
    return result.toString();
  }
 
  /**
   * 数値 data1 に数値 data2 を加算します。<br>
   * <br>
   * 引数が不正の場合は null を返します。<br>
   * <br>
   * @param  data1  左項
   * @param  data2  右項
   * @return  result  計算結果
   */
  public static String cmpAddition(String data1, String data2){
   
    // null チェック
    if(isNull(data1) || isNull(data2))
      return null;
   
    // 数値チェック
    if(!isNumeric(data1) || !isNumeric(data2))
      return null;
   
    // BigDecimalに変換
    BigDecimal deci1 = new BigDecimal(data1);
    BigDecimal deci2 = new BigDecimal(data2);
   
    // 計算
    deci1 = deci1.add(deci2);
   
    return deci1.toString();
  }
 
  /**
   * 数値 data1 から数値 data2 を減算します。<br>
   * <br>
   * 引数が不正の場合は null を返します。<br>
   * <br>
   * @param  data1  左項
   * @param  data2  右項
   * @return  result  計算結果
   */
  public static String cmpSubstract(String data1, String data2){
   
    // null チェック
    if(isNull(data1) || isNull(data2))
      return null;
   
    // 数値チェック
    if(!isNumeric(data1) || !isNumeric(data2))
      return null;
   
    // BigDecimalに変換
    BigDecimal deci1 = new BigDecimal(data1);
    BigDecimal deci2 = new BigDecimal(data2);
   
    // 計算
    deci1 = deci1.subtract(deci2);
   
    return deci1.toString();
  }
 
  /**
   * 数値 data1 を数値 data2 で乗算します。<br>
   * <br>
   * 引数が不正の場合は null を返します。<br>
   * <br>
   * @param  data1  左項
   * @param  data2  右項
   * @return  result  計算結果
   */
  public static String cmpMultiply(String data1, String data2){
   
    // null チェック
    if(isNull(data1) || isNull(data2))
      return null;
   
    // 数値チェック
    if(!isNumeric(data1) || !isNumeric(data2))
      return null;
   
    // BigDecimalに変換
    BigDecimal deci1 = new BigDecimal(data1);
    BigDecimal deci2 = new BigDecimal(data2);
   
    // 計算
    deci1 = deci1.multiply(deci2);
   
    return deci1.toString();
  }
 
  /**
   * 数値 data1 を数値 data2 で除算します。<br>
   * <br>
   * scale で小数点以下桁数を指定できます。<br>
   * mode で端数処理の方法を選択できます。<br>
   * mode が1の場合は端数を切り上げます。(RoundUp)<br>
   * mode が2の場合は端数を四捨五入します。(RoundHalfUp)<br>
   * mode が3の場合は端数を切り捨てます。(RoundDown)<br>
   * 引数が不正の場合は null を返します。<br>
   * <br>
   * @param  data1  左項
   * @param  data2  右項
   * @param  scale  小数点以下桁数
   * @param  mode  端数処理
   * @return  result  計算結果
   */
  public static String cmpDivide(String data1, String data2, int scale,intmode){
   
    // null チェック
    if(isNull(data1) || isNull(data2))
      return null;
   
    // data1 と data2 の数値チェック
    if(!isNumeric(data1) || !isNumeric(data2))
      return null;
   
    // 端数処理設定
    switch(mode){
      case 1:
        mode = BigDecimal.ROUND_UP;
        break;
      case 2:
        mode = BigDecimal.ROUND_HALF_UP;
        break;
      case 3:
        mode = BigDecimal.ROUND_DOWN;
        break;
      default:
        return null;
    }
   
    // BigDecimalに変換
    BigDecimal deci1 = new BigDecimal(data1);
    BigDecimal deci2 = new BigDecimal(data2);
   
    // 計算
    deci1 = deci1.divide(deci2, scale, mode);
   
    return deci1.toString();
  }

  /**
   * 文字列dataが全角文字で構成されているか検査します。<br>
   * <br>
   * @param  item    対象の文字列
   * @return result   チェック結果
   *   */
  // 全角入力チェック
  public static boolean fullSizeCheck(String item) {

    byte[] bytes;
    String encode = "MS932";

    try {
      bytes = item.getBytes(encode);

      int beams = item.length() * 2;

      StringBuffer sb = new StringBuffer(item);

      for (int i = 0; i < item.length(); i++) {
        if (' ' == sb.charAt(i)) {
          beams = beams - 2;
        }
      }

      if (beams != bytes.length) {
        return false;
      }
    } catch (UnsupportedEncodingException uee) {
      uee.printStackTrace();
    }
    return true;
  }
 
  /**
   * 文字列 data に挿入文字 appendix を指定桁数digitになるまで追加します。<br>
   * <br>
   * 全角文字に対応しています。<br>
   * 半角文字は対応していません。<br>
   *appendixには半角文字1文字しか指定できません。<br>
   * 引数が不正の場合は null を返します。<br>
   * <br>
   * @param  data    対象文字列
   * @param  appendix  挿入文字
   * @param  digit    指定桁数
   * @return  result    変換結果文字
   */
  public static String cnvFullString(String data, String appendix, intdigit){
   
    // 対象文字列 null チェック
    if(isNull(data))
      return null;
   
    // 挿入文字 null チェック
    if(isNull(appendix))
      return null;
   
    // 挿入文字 空チェック
    if(appendix.length() == 0)
      return null;
   
    // 挿入文字 サイズチェック
    if(appendix.length() != 1)
      return null;
   
    // 対象文字列 半角文字チェック
    if(data.length() != 0)
      if(!fullSizeCheck(data))
        return null;
   
    // 挿入文字 半角文字チェック
    if(!fullSizeCheck(appendix))
      return null;
   
    // data を StringBuffer に変換
    StringBuffer after = new StringBuffer(data);
   
    // ループ回数取得
    int loop = digit - data.length();
   
    // 挿入文字を指定された桁になるまで挿入
    for(int i = 0; i < loop; i++)
      after.append(appendix);
   
    return after.toString();   
  }

  /**
   * 文字列 mainStr 内の From の文字をToの文字に置換し<br>
   * 値を返す
   * <br>
   * @param  mailStr    変換対象の文字列
   * @param  fromStr    置換対象文字
   * @param  toStr     置換後文字
   * @return retStr    変換後文字列
   *   */
  public static String changeString(String mainStr,
                    String fromStr,
                    String toStr) {
    StringBuffer retStr = new StringBuffer();
    for (int i=0;i<mainStr.length();i++){
      if (mainStr.substring(i, i+1).equals(fromStr)) {
        retStr.append(toStr);
      } else {
        retStr.append(mainStr.substring(i, i+1));
      }
    }
    return retStr.toString();
  }

  /**
   * 入力文字列に指定文字列を付ける。
   * <br>
   * 例> 入力文字列 : "abc", 指定文字列: "1",カウント:3,位置:0
   *   ===> 結果文字列: "111abc"
   * @param  source  入力文字列
   * @param  fillStr  指定文字列
   * @param  count   付けるカウント
   * @param  position 付ける位置 (0:前, 0の以外:後)
   * @return target  結果文字列
   */
  public static String addStringNolimited (String source,
                       StringfillStr,
                       intcount,
                       intposition) {
    // 入力データをチェックする。
    if (source == null
    || fillStr == null
    || count <= 0
    || position < 0) {
      return source;
    }
    String target = null;
    StringBuffer buf = new StringBuffer();

    for (int i = 0; i < count; i++) {
      buf.append(fillStr);
    }
    if (position == 0) {
      target = buf.toString() + source;
    } else {
      target = source + buf.toString();
    }
    return target;
  }

  /**
  *入力文字列に指定した長さと同じように、指定文字列を付ける。
   * <br>
   * 例> 入力文字列 : "abc", 指定文字列: "1",全体長さ:5,位置:0
   *   ===> 結果文字列: "11abc"
   * @param  source    入力文字列
   * @param  fillStr   指定文字列
   * @param  totalLength 全体長さ
   * @param  position   付ける位置 (0:前, 0の以外:後)
   * @return target    結果文字列
   */
  public static String addStringLimited (String source,
                      StringfillStr,
                      inttotalLength,
                       intposition){
    // 入力データチェックする。
    if (source == null
    || fillStr == null
    || totalLength <= 0
    || position < 0) {
      return source;
    }
    if (source.length() >= totalLength) {
      return source;
    }
    int count = 0;
    String target = null;
    StringBuffer buf = new StringBuffer();

    count = totalLength - source.length();
    for (int i = 0; i < count; i++) {
      buf.append(fillStr);
    }
    if (position == 0) {
      target = buf.toString() + source;
    } else {
      target = source + buf.toString();
    }
    return target;
  }
 
  /**
   * 対処文字列の長さを得る。
   * <br>
   * 例> 対処文字列 : "ab学校c"
   *   ===> 文字列の長さ: 7
   * @param  str 対処文字列
   * @return len 文字列の長さ
   */ 
  public static int getStrLenZenHan(String str) {
    // nullをチェックする。
    if (isNull(str)) {
      return 0;
    }
   
    char[] chars = str.toCharArray( );
    int len = 0;
    int length = chars.length;

    for (int i = 0; i < length; i++) {
      // 範囲に入っていない場合は false
      if ( chars[i] != UtilConstants.C_HALF_SPACE
      &&!(UtilConstants.C_HALF_NUMBER_AND_ALPHABET_START<= chars[i]
      &&  chars[i]<=UtilConstants.C_HALF_NUMBER_AND_ALPHABET_END)
      && !(UtilConstants.C_HALF_KATAKANA_START<=chars[i]
      &&  chars[i] <=UtilConstants.C_HALF_KATAKANA_END)){ // 全角
        len += 2;
      } else { // 半角
        len += 1;
      }
    }  // end of for loop

    return len;
  }
 
  /**
   *数値全角→半角、半角→全角に変換する。<br>
   * "1" : 半角→全角<br>
   * "2" : 全角→半角<br>
   * <br>
   * @param type  フラグ
   * @return str  変換対象の文字列
   */
  public static String cnvNumberZenHan(int type, String str) {
    StringBuffer sb = new StringBuffer();
   
    if (str ==null
    || str.length() == 0
    || (type != 1 && type != 2)) {
      return str;
    }
   
    int chr;
    for (int count = 0; count < str.length(); count++) {
      chr = str.charAt(count);
      if (type == 1) {
        chr = chr + 65248;
      } else if (type == 2){
        chr = chr - 65248;
     
      }
      sb.append((char)chr);
    }

    return sb.toString();
  }
 
  /**
   * <br>
   * @param str     String
   * @param startIndex int
   * @param endIndex  int
   * @return ret  変換対象の文字列
   */
  
  public static String substringB(String str, int startIndex, intendIndex){
   
    int index = 0;
    String work = "";
    String ret = "";
   
    for (int i = 0; i < str.length(); i++) {
      work = str.substring(i, i + 1);
      index = index + work.getBytes().length;
      if (index > startIndex && index <= endIndex){
        ret = ret + work;
      } else if (index >= endIndex) {
        break;
      }
    }
    return ret;
  }
}





| 新しいページ | 編集 | 差分 | 編集履歴 | ページ名変更 | アップロード | 検索 | ページ一覧 | タグ | RSS | ご利用ガイド | 管理者に問合せ |
@wiki - 無料レンタルウィキサービス | プライバシーポリシー