wiki @Wiki

共通関数

最終更新：2006年05月19日 20:42

匿名ユーザー

- view

管理者のみ編集可

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

/**
* 文字列ユーティリティクラス。 
* 
* 以下の機能を提供します。 
* <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であるか検査します。 
　　 * 
　　 * data が null の場合は true を返します。 
　　 * data が null でない場合は falseを返します。 
　　 * 
　　 * @param　 data　対象文字列
　　 * @return　 result　チェック結果
　　 */
　 public static boolean isNull(Object data){
　　　 if(data == null)
　　　　　 return true;
　　　 else
　　　　　 return false;
　 }
　
　 /**
　　 * 文字列 data が空であるか検査します。 
　　 * 
　　 *spaceFlgで末尾の空白を許容するか選択できます。 
　　 * spaceFlg がtrueの場合は末尾の空白を許容します。 
　　 * spaceFlg がfalseの場合は末尾の空白を許容しません。 
　　 * data が空である場合は true を返します。 
　　 * data が空でない場合は false を返します。 
　　 * data が null である場合は true を返します。 
　　 * 
　　 * @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がデータとして有効であるか検査します。 
　　 * 
　　*データとして有効な範囲は以下の通りです。 
　　 * ・null でない 
　　 * ・空でない 
　　 * ・全角・半角空白だけの文字列でない 
　　 * 有効データである場合は trueを返します。 
　　 * 有効データでない場合はfalseを返します。 
　　 * 
　　 * @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 が数値であるか検査します。 
　　 * 
　　 * 数値の範囲は以下の通りです。 
　　 * ・null でない 
　　 * ・空でない 
　　 * ・全角・半角空白だけの文字列でない 
　　 * マイナスの値と小数に対応しています。 
　　 * 数値である場合は true を返す 
　　 * 数値でない場合は false を返す 
　　 * 
　　 * @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 の末尾の空白を削除します。 
　　 * 
　　*末尾の全角空白・半角空白を取り除きます。 
　　 * 引数が不正の場合は null を返します。 
　　 * 
　　 * @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が半角文字で構成されているか検査します。 
　　 * <dr>
　　 * 半角文字の範囲は以下の通りです。 
　　 * ・半角英字 !～~ 
　　 * ・半角カナ｡～ﾟ 
　　 * ・null でない 
　　 * ・空でない 
　　 * 文字列中の半角空白は許容されます。 
　　 *spaceFlgで空白のみの文字列を許容するか選択できます。 
　　 * spaceFlg がtrueの場合は空白のみの文字列も許容します。 
　　 * spaceFlg がfalseの場合は空白のみの文字列は許容しません。 
　　 * 半角文字のみで構成されている場合はtrueを返します。 
　　 * 半角文字のみで構成されていない場合はfalseを返します。 
　　 * 
　　 * @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が半角数字で構成されているか検査します。 
　　 * 
　　 * 半角数字の範囲は以下の通りです。 
　　 * ・半角数字 u0030～u0039 
　　 * ・null でない 
　　 * ・空でない 
　　 * ・全角・半角空白だけの文字列でない 
　　 * ・半角空白が混在していない 
　　 *periodFlgで半角ピリオド(小数点)を許容するか選択できます。 
　　 * periodFlg がtrueの場合はピリオドを許容します。 
　　 * periodFlg がfalseの場合はピリオドを許容しません。 
　　 * ピリオドが複数混在していてもtrueを返します。 
　　 *minusFlgで半角ハイフン(マイナス値)を許容するか選択できます。 
　　 * minusFlg がtrueの場合はハイフンを許容します。 
　　 * minusFlg がfalseの場合はハイフンを許容しません。 
　　 * ハイフンが複数混在している場合もtrueを返します。
　　 * 半角数字のみで構成されている場合はtrueを返します。 
　　 * 半角数字のみで構成されていない場合はfalseを返します。 
　　 * 数値としての検査をする場合はisNumeric()メソッドを使用してください。 
　　 * 
　　 * @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が全角カナで構成されているか検査します。 
　　 * 
　　 * 全角カナの範囲は以下の通りです。 
　　 * ・全角句読点 u3001～u3002 
　　 * ・全角横線点 u30FB～u30FC 
　　 * ・全角濁点半濁点 u309B～u309C 
　　 * ・全角カナ u30A1～u30FE 
　　 * ・全角空白 u3000 
　　 * ・null でない 
　　 * ・空でない 
　　 * ・全角・半角空白だけの文字列でない 
　　 *spaceFlgで全角空白を許容するか選択できます。 
　　 * spaceFlg が trueの場合は空白を許容します。 
　　 * spaceFlg がfalseの場合は空白を許容しません。 
　　 * 全角カナで構成されている場合はtrueを返します。 
　　 * 全角カナで構成されていない場合はfalseを返します。 
　　 * 
　　 * @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が半角カナで構成されているか検査します。 
　　 * 
　　 * 半角カナの範囲は以下の通りです。 
　　 * ・半角カナ uFF61～uFF9F 
　　 * ・半角空白 
　　 * ・null でない 
　　 * ・空でない 
　　 * ・全角・半角空白だけの文字列でない 
　　 *spaceFlgで半角空白を許容するか選択できます。 
　　 * spaceFlg が trueの場合は空白を許容します。 
　　 * spaceFlg がfalseの場合は空白を許容しません。 
　　 * 半角カナのみで構成されている場合はtrueを返します 
　　 * 半角カナのみで構成されていない場合はfalseを返します 
　　 * 
　　 * @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;
　 }

/**
　　*文字列中に指定語句が存在するか検査します。 
　　 * 
　　 * 指定語句が存在する場合はtrueを返します。 
　　 * 指定語句が存在しない場合はfalseを返します。 
　　 * 
　　 * @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;
　 }
　
　 /**
　　 *文字列中の文字を指定文字に置換します。 
　　 * 
　　 * 文字列 data 中の target をvalueに置き換えます。 
　　 * 引数が不正だった場合は nullを返します。 
　　 * 
　　 * @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 を小数に変換します。 
　　 * 
　　 *dataに小数を指定することで端数処理をすることが可能です。 
　　*この場合は指定した小数桁数になるよう端数処理をします。 
　　 * scaleで小数点以下の桁数を指定できます。 
　　 * mode で端数処理の方法を選択できます。 
　　 * mode が1の場合は端数を切り上げます。(RoundUp) 
　　 * mode が2の場合は端数を四捨五入します。(RoundHalfUp) 
　　 * mode が3の場合は端数を切り捨てます。(RoundDown) 
　　 * 引数が不正の場合は null を返します。 
　　 * 
　　 * @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 を整数に変換します。 
　　 * 
　　 *modeで小数点第1桁の端数処理の方法を選択できます。 
　　 * mode が1の場合は端数を切り上げます。(RoundUp) 
　　 * mode が2の場合は端数を四捨五入します。(RoundHalfUp) 
　　 * mode が3の場合は端数を切り捨てます。(RoundDown) 
　　 * 引数が不正の場合は null を返します 
　　 * 
　　 * @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を除いた数値に変換します。 
　　 * 
　　 * 変換イメージ[001000 → 1000] 
　　 * マイナスの値や小数に対応しています。 
　　 * 引数が不正だった場合は nullを返します。 
　　 * 
　　 * @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になるまで追加します。 
　　 * 
　　 * 半角文字に対応しています。 
　　 * 全角文字は対応していません。 
　　 *appendixには半角文字1文字しか指定できません。 
　　 * 引数が不正の場合は null を返します。 
　　 * 
　　 * @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 をゼロパディングします。 
　　 * 
　　 * 半角文字に対応しています。
　　 * 全角文字は対応していません。
　　 *マイナスの値や小数は対応していません。 
　　 * 引数が不正の場合 null を返します。 
　　 * 変換イメージ[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 をゼロパディングします。 
　　 * 
　　 * 半角文字に対応しています。
　　 * 全角文字は対応していません。
　　 *マイナスの値や小数は対応していません。 
　　 * 引数が不正の場合 null を返します。 
　　 * 変換イメージ[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 をゼロサプレスします。 
　　 * 
　　 * 変換イメージ[before:00100 → return: 100] 
　　 * 引数が不正の場合は null を返します。 
　　 * 
　　 * @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 を加算します。 
　　 * 
　　 * 引数が不正の場合は null を返します。 
　　 * 
　　 * @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 を減算します。 
　　 * 
　　 * 引数が不正の場合は null を返します。 
　　 * 
　　 * @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 で乗算します。 
　　 * 
　　 * 引数が不正の場合は null を返します。 
　　 * 
　　 * @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 で除算します。 
　　 * 
　　 * scale で小数点以下桁数を指定できます。 
　　 * mode で端数処理の方法を選択できます。 
　　 * mode が1の場合は端数を切り上げます。(RoundUp) 
　　 * mode が2の場合は端数を四捨五入します。(RoundHalfUp) 
　　 * mode が3の場合は端数を切り捨てます。(RoundDown) 
　　 * 引数が不正の場合は null を返します。 
　　 * 
　　 * @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が全角文字で構成されているか検査します。 
　　 * 
　　 * @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になるまで追加します。 
　　 * 
　　 * 全角文字に対応しています。 
　　 * 半角文字は対応していません。 
　　 *appendixには半角文字1文字しか指定できません。 
　　 * 引数が不正の場合は null を返します。 
　　 * 
　　 * @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の文字に置換し 
　　 * 値を返す
　　 * 
　　 * @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();
　 }

/**
　　 * 入力文字列に指定文字列を付ける。
　　 * 
　　 * 例> 入力文字列 : "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;
　 }

/**
　　*入力文字列に指定した長さと同じように、指定文字列を付ける。
　　 * 
　　 * 例> 入力文字列 : "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;
　 }
　
　 /**
　　 * 対処文字列の長さを得る。
　　 * 
　　 * 例> 対処文字列 : "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;

return len;
　 }
　
　 /**
　　 *数値全角→半角、半角→全角に変換する。 
　　 * "1" : 半角→全角 
　　 * "2" : 全角→半角 
　　 * 
　　 * @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();
　 }
　
　 /**
　　 * 
　　 * @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;
　 }
}

「共通関数」をウィキ内検索

最近更新されたページ

新規Wikiランキング

最近作成されたWikiのアクセスランキングです。見るだけでなく加筆してみよう！

人気Wikiランキング

atwikiでよく見られているWikiのランキングです。新しい情報を発見してみよう！

全体ページランキング

最近アクセスの多かったページランキングです。話題のページを見に行こう！