1549 lines
38 KiB
Java
1549 lines
38 KiB
Java
/*******************************************************************/
|
|
/* Class Name : StringUtil */
|
|
/* Description : 문자열 처리 관련 Class */
|
|
/*******************************************************************/
|
|
/* Modification Log */
|
|
/* No DATE Company Author Description */
|
|
/* 01 2002/06/01 IRAM Initial Release */
|
|
/*******************************************************************/
|
|
|
|
package geoinfo.util;
|
|
|
|
import java.io.*;
|
|
import java.text.*;
|
|
|
|
import org.jfree.util.Log;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
/**
|
|
* <pre>
|
|
* 문자열 처리 관련 Class
|
|
* </pre>
|
|
*
|
|
* @author IRAM
|
|
* @version 1.0
|
|
* @since 2002.01.
|
|
*/
|
|
|
|
public class StringUtil {
|
|
|
|
private static final Logger LOGGER = LoggerFactory.getLogger(StringUtil.class);
|
|
|
|
public static String urlEncode(String str) {
|
|
return replace(java.net.URLEncoder.encode(str), "+", "%20");
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 입력된 문자열에서 source형태의 문자열을 target문자열로 변환하여 리턴한다.
|
|
* 예) replace('엔터프라이즈 자바빈즈','즈','빈') -> 엔터프라이빈 자바빈빈
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @param pattern
|
|
* 바꿀 문자열
|
|
* @param replace
|
|
* 바뀔 문자열
|
|
* @return java.lang.String
|
|
*/
|
|
public static String replace(String str, String pattern, String replace) {
|
|
int s = 0; // 시작위치
|
|
int e = 0; // append하는 위치
|
|
if (pattern.equals(""))
|
|
return str;
|
|
|
|
StringBuffer result = new StringBuffer();
|
|
while ((e = str.indexOf(pattern, s)) >= 0) {
|
|
result.append(str.substring(s, e));
|
|
result.append(replace);
|
|
s = e + pattern.length();
|
|
} // while 종료
|
|
result.append(str.substring(s));
|
|
return result.toString();
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 입력된 문자열에서 source형태의 문자열을 target문자열로 변환하여 리턴한다.
|
|
* 예) 1번째로 나오는 하나만 변환한다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @param pattern
|
|
* 바꿀 문자열
|
|
* @param replace
|
|
* 바뀔 문자열
|
|
* @return java.lang.String
|
|
*/
|
|
public static String replaceFirst1(String str, String pattern, String replace) {
|
|
int s = 0; // 시작위치
|
|
int e = 0; // append하는 위치
|
|
if (pattern.equals(""))
|
|
return str;
|
|
|
|
StringBuffer result = new StringBuffer();
|
|
while ((e = str.indexOf(pattern, s)) >= 0) {
|
|
result.append(str.substring(s, e));
|
|
result.append(replace);
|
|
s = e + pattern.length();
|
|
break; // 한번만 실행한 후 종료
|
|
} // while 종료
|
|
result.append(str.substring(s));
|
|
return result.toString();
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 특정 부분의 문자열을 지정한 문장열로 바꾼다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @param sPos
|
|
* 원래문자열을 자를 시작위치
|
|
* @param ePos
|
|
* 원래문자열을 자를 끝 위치
|
|
* @param replace
|
|
* 자른 문자열 사이에 넣을 문자열
|
|
* @return String 변환된 문자열
|
|
*/
|
|
public static String replace(String str, int sPos, int ePos, String replace) {
|
|
StringBuffer result = new StringBuffer(str.substring(0, sPos));
|
|
result.append(replace);
|
|
result.append(str.substring(ePos));
|
|
return result.toString();
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 스트링을 토큰하여 array로 넘긴다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @param delim
|
|
* 자를 delim 문자
|
|
* @return String[] delim 문자로 토큰된 array
|
|
*/
|
|
public static String[] getArrToken(String str, String delim) {
|
|
java.util.StringTokenizer tk = new java.util.StringTokenizer(str, delim);
|
|
String[] arr = new String[tk.countTokens()];
|
|
for (int i = 0; i < arr.length; i++) {
|
|
arr[i] = tk.nextToken();
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 스트링을 토큰하여 array로 넘긴다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @param delim
|
|
* 자를 delim 문자
|
|
* @return String[] delim 문자로 토큰된 array
|
|
*/
|
|
public static String[] getArrToken2(String str, String delim) {
|
|
return split(str, delim, true);
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* str의 문자열을 " " 으로 구분하여 length마다의 길이에 enter문자를 삽입시켜준다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @param length
|
|
* Enter문자를 넣을 위치
|
|
* @return String 원래 문자열에 Enter를 넣은 문자열
|
|
*/
|
|
public static String HrInsEnterX(String str, int length) {
|
|
|
|
String[] tmp = getArrToken(str, " ");
|
|
String rtnStr = "";
|
|
int line_num = 1;
|
|
for (int i = 0; i < tmp.length; i++) {
|
|
if ((rtnStr + tmp[i]).length() > length * line_num) {
|
|
rtnStr += "\n";
|
|
line_num++;
|
|
}
|
|
rtnStr += " " + tmp[i];
|
|
}
|
|
return rtnStr;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* str의 문자열을 " " 으로 구분하여 length마다의 길이에 enter문자를 삽입시켜준다.
|
|
* enter(\n)다음에 pad 문자를 넣어준다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @param length
|
|
* Enter문자를 넣을 위치
|
|
* @param pad
|
|
* Enter를 넣은 후 다음 줄 시작에 넣을 문자열
|
|
* @return String 원래 문자열에 Enter를 넣은 문자열
|
|
*/
|
|
public static String HrInsEnterX(String str, int length, String pad) {
|
|
return replace(HrInsEnterX(str, length), "\n", "\n" + pad);
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* str의 문자열을 length마다의 길이에 enter문자를 삽입시켜준다.
|
|
* " " 로 토큰한 후 토큰 한 string 이 length보다 클경우 /n 을 넣어준다.
|
|
* HrInsEnterX와 틀린 점은 length 안에 enter가 있을 경우 그 다음부터 다시 length를 체크한다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @param length
|
|
* Enter문자를 넣을 위치
|
|
* @return String 원래 문자열에 Enter를 넣은 문자열
|
|
*/
|
|
public static String HrInsEnterX2(String str, int length) {
|
|
|
|
String[] tmp = getArrToken(str, " ");
|
|
String rtnStr = "";
|
|
String this_line = "";
|
|
for (int i = 0; i < tmp.length; i++) {
|
|
this_line += tmp[i];
|
|
if (this_line.length() > length) {
|
|
rtnStr += this_line + "\n";
|
|
this_line = "";
|
|
} else if (this_line.indexOf("\n") != -1) {
|
|
// 엔터가 있을 경우
|
|
rtnStr += this_line;
|
|
this_line = "";
|
|
}
|
|
}
|
|
rtnStr += this_line;
|
|
return rtnStr;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* string에서 integer에 해당하는 값을 찾아온다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 숫자가 들어있는 문자열
|
|
* @return 숫자로 만들어지는 문자열일 경우 integer에 해당하는 문자열이 넘어오고 아닐경우 공백("")이 넘어온다.
|
|
*/
|
|
public static String getIntString(String str) {
|
|
String rtn = "";
|
|
try {
|
|
rtn = String.valueOf(Integer.parseInt(str));
|
|
} catch (NumberFormatException e) {
|
|
LOGGER.debug("error", e);
|
|
rtn = "";
|
|
} catch (Exception e) {
|
|
LOGGER.debug("error", e);
|
|
rtn = "";
|
|
}
|
|
return rtn;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* str string에서 숫자인 것만 찾아온다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @return String 원래 문자열에서 숫자만 리턴
|
|
*/
|
|
public static String getNumber(String str) {
|
|
if (str == null) {
|
|
return str;
|
|
}
|
|
|
|
StringBuffer sb = new StringBuffer(str);
|
|
StringBuffer newSb = new StringBuffer();
|
|
|
|
int sbLen = sb.length();
|
|
char number;
|
|
for (int i = 0; i < sbLen; i++) {
|
|
number = sb.charAt(i);
|
|
if (number >= 48 && number <= 57)
|
|
newSb.append(sb.charAt(i));
|
|
}
|
|
|
|
return newSb.toString();
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 문자열을 15자 만큼만 보여주고
|
|
* 그 길이에 초과되는 문자열일 경우 "..."를 덧붙여 보여준다.
|
|
* </pre>
|
|
*
|
|
* @param input
|
|
* 변환할 문자열
|
|
* @return String 제한된 길이만큼 자르고 ... 을 붙인 문자열
|
|
*/
|
|
public static String fixLength(String input) {
|
|
return fixLength(input, 15, "...");
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 문자열을 일정길이 만큼만 보여주고
|
|
* 그 길이에 초과되는 문자열일 경우 "..."를 덧붙여 보여준다.
|
|
* </pre>
|
|
*
|
|
* @param input
|
|
* 변환할 문자열
|
|
* @param limit
|
|
* 문자열의 제한 길이
|
|
* @return String 제한된 길이만큼 자르고 ... 을 붙인 문자열
|
|
*/
|
|
public static String fixLength(String input, int limit) {
|
|
return fixLength(input, limit, "...");
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 문자열을 일정길이 만큼만 보여주고
|
|
* 그 길이에 초과되는 문자열일 경우 특정문자를 덧붙여 보여준다.
|
|
* </pre>
|
|
*
|
|
* @param input
|
|
* 변환할 문자열
|
|
* @param limit
|
|
* 문자열의 제한 길이
|
|
* @param postfix
|
|
* 덧붙일 문자열
|
|
* @return String 제한된 길이만큼 자르고 postfix문자열을 붙인 문자열
|
|
*/
|
|
public static String fixLength(String input, int limit, String postfix) {
|
|
char[] charArray = input.toCharArray();
|
|
if (limit >= charArray.length)
|
|
return input;
|
|
return new String(charArray, 0, limit).concat(postfix);
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 문자열을 일정길이 만큼만 보여주고
|
|
* 그 길이(Unicode)에 초과되는 문자열일 경우 "..." 문자를 덧붙여 보여준다.
|
|
*
|
|
* 단 fixLength와의 차이는 제한길이의 기준이 char가 아니라 byte로
|
|
* 처리함으로해서 한글문제를 해결할수 있다.
|
|
* </pre>
|
|
*
|
|
* @param input
|
|
* 변환할 문자열
|
|
* @param limitByte
|
|
* 문자열의 제한 길이(byte)
|
|
* @return 제한된 길이만큼 자르고 ... 을 붙인 문자열
|
|
*/
|
|
public static String fixUnicodeLength(String input, int limitByte) {
|
|
return fixLength(input, limitByte, "...");
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 문자열을 일정길이 만큼만 보여주고
|
|
* 그 길이에 초과되는 문자열일 경우 특정문자를 덧붙여 보여준다.
|
|
*
|
|
* 단 fixLength와의 차이는 제한길이의 기준이 char가 아니라 byte로
|
|
* 처리함으로해서 한글문제를 해결할수 있다.
|
|
* </pre>
|
|
*
|
|
* @param input
|
|
* 변환할 문자열
|
|
* @param limitByte
|
|
* 문자열의 제한 길이(byte)
|
|
* @param postfix
|
|
* 덧붙일 문자열
|
|
* @return String 제한된 길이만큼 자르고 postfix문자열을 붙인 문자열
|
|
*/
|
|
public static String fixUnicodeLength(String input, int limitByte, String postfix) {
|
|
/*
|
|
* 중간에 -1을 해주는 것은. 21바이트짜리 한글 스트링을. 20으로 짤라서 String을 생성하면, 끝글자만 짤리는것이 아니라.
|
|
* 스트링자체가 완전 생성이 되지 않기 때문. 그러므로 길이가 0이면 -1한만큼 스트링을 생성하는 것이다.
|
|
*/
|
|
byte[] outputBytes = input.getBytes();
|
|
|
|
String output = outputBytes.length <= limitByte ? input
|
|
: (new String(outputBytes, 0, limitByte).length() == 0
|
|
? new String(outputBytes, 0, limitByte - 1).concat(postfix)
|
|
: new String(outputBytes, 0, limitByte)).concat(postfix);
|
|
|
|
return output;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* String EUC_KR로 encoding한다.
|
|
* </pre>
|
|
*
|
|
* @param text
|
|
* 한글로 encoding할 문자열
|
|
* @return String 한글로 encoding된 문자열
|
|
*/
|
|
public static String getEUC_KR(String text) {
|
|
String rtn;
|
|
|
|
rtn = "";
|
|
|
|
if (text == null)
|
|
return rtn;
|
|
else {
|
|
try {
|
|
return new String(text.getBytes("8859_1"), "EUC-KR");
|
|
} catch (UnsupportedEncodingException UEE) {
|
|
return rtn;
|
|
}
|
|
}
|
|
// return text;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* String EUC_KR로 encoding한다.
|
|
* </pre>
|
|
*
|
|
* @param text
|
|
* 한글로 encoding할 문자열
|
|
* @return String 한글로 encoding된 문자열
|
|
*/
|
|
public static String getUTF8(String text) {
|
|
String rtn;
|
|
|
|
rtn = "";
|
|
|
|
if (text == null)
|
|
return rtn;
|
|
else {
|
|
try {
|
|
return new String(text.getBytes("8859_1"), "UTF-8");
|
|
} catch (UnsupportedEncodingException UEE) {
|
|
return rtn;
|
|
}
|
|
}
|
|
// return text;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* String EUC_KR로 encoding한다.
|
|
* </pre>
|
|
*
|
|
* @param text
|
|
* 한글로 encoding할 문자열
|
|
* @return String 한글로 encoding된 문자열
|
|
*/
|
|
public static String[] getUTF8(String[] arrText) {
|
|
String[] arrRtn = new String[arrText.length];
|
|
|
|
for (int i = 0; i < arrText.length; i++) {
|
|
arrRtn[i] = getUTF8(arrText[i]);
|
|
}
|
|
return arrRtn;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* String EUC_KR로 encoding한다.
|
|
* </pre>
|
|
*
|
|
* @param text
|
|
* 한글로 encoding할 문자열
|
|
* @return String 한글로 encoding된 문자열
|
|
*/
|
|
public static String[] getEUC_KR(String[] arrText) {
|
|
String[] arrRtn = new String[arrText.length];
|
|
|
|
for (int i = 0; i < arrText.length; i++) {
|
|
arrRtn[i] = getEUC_KR(arrText[i]);
|
|
}
|
|
return arrRtn;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* String 8859_1(Unicode)로 encoding한다.
|
|
* </pre>
|
|
*
|
|
* @param text
|
|
* 8859_1로 encoding할 문자열
|
|
* @return String 8859_1로 encoding한 문자열
|
|
*/
|
|
public static String get8859_1(String text) {
|
|
String rtn;
|
|
|
|
rtn = "";
|
|
|
|
if (text == null)
|
|
return rtn;
|
|
else {
|
|
try {
|
|
return new String(text.getBytes("euc-kr"), "8859_1");
|
|
} catch (UnsupportedEncodingException UEE) {
|
|
return rtn;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* String 을 from enc 에서 to enc 형태로 변환한다.
|
|
* </pre>
|
|
*
|
|
* @param text
|
|
* @param fromenc
|
|
* @param toenc
|
|
* @return
|
|
*/
|
|
public static String[] getEncodeStr(String[] arrText, String fromenc, String toenc) {
|
|
String[] arrRtn = new String[arrText.length];
|
|
|
|
for (int i = 0; i < arrText.length; i++) {
|
|
arrRtn[i] = getEncodeStr(arrText[i], fromenc, toenc);
|
|
}
|
|
return arrRtn;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* String 을 from enc 에서 to enc 형태로 변환한다.
|
|
* </pre>
|
|
*
|
|
* @param text
|
|
* @param fromenc
|
|
* @param toenc
|
|
* @return
|
|
*/
|
|
public static String getEncodeStr(String text, String fromenc, String toenc) {
|
|
String rtn;
|
|
|
|
rtn = "";
|
|
|
|
if (text == null)
|
|
return rtn;
|
|
else {
|
|
try {
|
|
return new String(text.getBytes(fromenc), toenc);
|
|
} catch (UnsupportedEncodingException UEE) {
|
|
return rtn;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* String을 encoding한다.
|
|
* </pre>
|
|
*
|
|
* @param text
|
|
* encoding할 문자열
|
|
* @param fromEncode
|
|
* text의 원래 encoding
|
|
* @param toEncode
|
|
* 변환할 encoding
|
|
* @return String 변환된 문자열
|
|
*/
|
|
public static String getConvertCharset(String text, String fromEncode, String toEncode) {
|
|
String rtn;
|
|
|
|
rtn = "";
|
|
|
|
if (text == null)
|
|
return rtn;
|
|
else {
|
|
try {
|
|
return new String(text.getBytes(fromEncode), toEncode);
|
|
} catch (UnsupportedEncodingException UEE) {
|
|
return rtn;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* HTML과 관련하여 일부 특수문자를 반환한다.
|
|
* & --->> &
|
|
* < --->> <
|
|
* > --->> >
|
|
* ' --->> ´
|
|
* " --->> "
|
|
* | --->> ¦
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 일부 html 특수문자가 포함된 문자열
|
|
* @return String 일부 html 특수문자를 변환한 문자열
|
|
*/
|
|
public static String getSpecialCharacters(String str) {
|
|
str = replace(str, "&", "&");
|
|
str = replace(str, "<", "<");
|
|
str = replace(str, ">", ">");
|
|
// str = replace(str, "'", "´");
|
|
str = replace(str, "\"", """);
|
|
// str = replace(str, "|", "¦");
|
|
//
|
|
// str = replace(str, "\n", "<BR>");
|
|
// str = replace(str, "\r", "");
|
|
|
|
return str;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* HTML과 관련하여 일부 특수문자를 변환한다.
|
|
* & --->> &
|
|
* < --->> <
|
|
* > --->> >
|
|
* ´ --->> '
|
|
* " --->> "
|
|
* ¦ --->> |
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* html로 변환될 문자를 포함하는 문자열
|
|
* @return String 일부가 html문자로 변환된 문자열
|
|
*/
|
|
public static String getRreplaceSpecialCharacters(String str) {
|
|
str = replace(str, "<BR>", "\n");
|
|
|
|
str = replace(str, "&", "&");
|
|
str = replace(str, "<", "<");
|
|
str = replace(str, ">", ">");
|
|
str = replace(str, "´", "'");
|
|
str = replace(str, """, "\"");
|
|
str = replace(str, "¦", "|");
|
|
|
|
return str;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* String에 comma를 삽입한다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 숫자로 이루어진 문자열
|
|
* @return String 천단위 comma를 삽입한 문자열
|
|
*/
|
|
public static String getComma(String str) {
|
|
return getComma(str, true);
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* String에 comma를 삽입한다.
|
|
* isTruncated가 false이면 소수점 이하를 자르지 않는다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 숫자로 이루어진 문자열
|
|
* @param isTruncated
|
|
* true이면 소숫점이하를 자른다.
|
|
* @return String 천단위 comma를 삽입한 문자열
|
|
*/
|
|
public static String getComma(String str, boolean isTruncated) {
|
|
DecimalFormat commaFormat; // comma 삽입을 위한 변수
|
|
|
|
if (str == null)
|
|
return "";
|
|
else if (str.trim().equals(""))
|
|
return "";
|
|
else if (str.trim().equals(" "))
|
|
return " ";
|
|
else {
|
|
// str에 .이 있으면 Float으로 처리한다.
|
|
int pos = str.indexOf(".");
|
|
if (pos != -1) {
|
|
if (!isTruncated) {
|
|
commaFormat = new DecimalFormat("#,##0.00");
|
|
return commaFormat.format(Float.parseFloat(str.trim()));
|
|
} else {
|
|
commaFormat = new DecimalFormat("#,##0");
|
|
return commaFormat.format(Long.parseLong(str.trim().substring(0, pos)));
|
|
}
|
|
} else {
|
|
commaFormat = new DecimalFormat("#,##0");
|
|
return commaFormat.format(Long.parseLong(str.trim()));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* val 문자열을 우편번호 형식으로 변환하여 반환한다. ex)000-000
|
|
*
|
|
* @param val
|
|
* @return
|
|
*/
|
|
public static String getZip(String val) {
|
|
String tmp = val.replaceAll("-", "");
|
|
if (tmp.length() > 5) {
|
|
tmp = tmp.substring(0, 3) + "-" + tmp.substring(3);
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
/**
|
|
* val 문자열을 주민등록번호 형식으로 변환하여 반환한다. ex)000000-0000000
|
|
*
|
|
* @param val
|
|
* @return
|
|
*/
|
|
public static String getJumin(String val) {
|
|
String tmp = val.replaceAll("-", "");
|
|
if (tmp.length() > 6) {
|
|
tmp = tmp.substring(0, 6) + "-" + tmp.substring(6);
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
public static String getJumin(String val, String fmt) {
|
|
String tmp = val.replaceAll("-", "");
|
|
if (tmp.length() > 6) {
|
|
tmp = tmp.substring(0, 6) + "-" + tmp.substring(6, 7);
|
|
for (int i = 0; i < 6; i++) {
|
|
tmp += fmt;
|
|
}
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* Long값에 comma를 삽입한 String을 리턴한다.
|
|
* </pre>
|
|
*
|
|
* @param lstr
|
|
* long형 데이터
|
|
* @return String long값에 천단위 comma를 삽입한 문자열
|
|
*/
|
|
public static String getComma(Long lstr) {
|
|
DecimalFormat commaFormat; // comma 삽입을 위한 변수
|
|
commaFormat = new DecimalFormat("#,##0");
|
|
|
|
if (lstr == null)
|
|
return "";
|
|
else
|
|
return commaFormat.format(lstr);
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* text를 format에 맞추어 출력한다.
|
|
* getFormatedText("0193372412","???-???-????") --->> 019-337-2412로 출력
|
|
* </pre>
|
|
*
|
|
* @param text
|
|
* 원래 문자열
|
|
* @param format
|
|
* 포맷 문자열
|
|
* @return String 포맷에 맞게 변환된 문자열
|
|
*/
|
|
public static String getFormatedText(String text, String format) {
|
|
String rtn;
|
|
int start, i, j, len;
|
|
int tCount, fCount;
|
|
|
|
tCount = text.length();
|
|
fCount = format.length();
|
|
|
|
rtn = "";
|
|
|
|
if (text.equals(""))
|
|
return rtn;
|
|
if (text.equals(" "))
|
|
return " ";
|
|
// text가 01252412 이고 format 이 ????-???? 이면 0125-2412로 출력
|
|
// text에서 -를 제거한다.
|
|
for (i = 0; i < tCount; ++i) {
|
|
if (!text.substring(i, i + 1).equals("-"))
|
|
rtn = rtn + text.substring(i, i + 1);
|
|
}
|
|
|
|
text = rtn;
|
|
tCount = text.length();
|
|
|
|
// 포멧에서 ?의 count
|
|
len = 0;
|
|
for (j = 0; j < fCount; ++j) {
|
|
if (format.substring(j, j + 1).equals("?"))
|
|
++len;
|
|
}
|
|
// text의 길이가 len보다 작으면 앞에 0를 붙인다.
|
|
if (tCount < len) {
|
|
for (i = 0; i < (len - tCount); ++i) {
|
|
text = '0' + text;
|
|
}
|
|
tCount = len;
|
|
}
|
|
|
|
rtn = "";
|
|
start = 0;
|
|
for (i = 0; i < tCount; ++i) {
|
|
for (j = start; j < fCount; ++j) {
|
|
if (format.substring(j, j + 1).equals("?")) {
|
|
rtn = rtn + text.substring(i, i + 1);
|
|
start = start + 1;
|
|
break;
|
|
} else {
|
|
rtn = rtn + format.substring(j, j + 1);
|
|
start = start + 1;
|
|
}
|
|
}
|
|
}
|
|
return rtn + format.substring(start);
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* format형태의 String에서 문자만을 추출하여 리턴한다.
|
|
* getFormatedText("019-337-2412","???-???-????") --->> 0193372412로 출력
|
|
* </pre>
|
|
*
|
|
* @param text
|
|
* 원래 문자열
|
|
* @param format
|
|
* 포맷 문자열
|
|
* @return String 원래 문자열에서 포맷에 해당하는 문자만을 추출한 문자열
|
|
*/
|
|
public static String getRawText(String text, String format) {
|
|
int start, i, j, tCount, fCount;
|
|
String rtn;
|
|
|
|
tCount = text.length();
|
|
fCount = format.length();
|
|
|
|
rtn = "";
|
|
if (text.equals(""))
|
|
return rtn;
|
|
if (text.equals(" "))
|
|
return " ";
|
|
// test가 0125-2412 이고 format 이 ????-???? 이면 01252412로 출력
|
|
|
|
start = 0;
|
|
for (i = 0; i < tCount; ++i) {
|
|
for (j = start; j < fCount; ++j) {
|
|
if (format.substring(j, j + 1).equals("?")) {
|
|
rtn = rtn + text.substring(i, i + 1);
|
|
start = start + 1;
|
|
break;
|
|
} else {
|
|
start = start + 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return rtn;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 주어진 size내에서 0으로 채워진 String을 리턴한다.
|
|
* </pre>
|
|
*
|
|
* @param num
|
|
* 원래 숫자
|
|
* @param size
|
|
* 0을 넣어 만들 문자열의 길이
|
|
* @return String 주어진 size 앞부분에 0을 채운 문자열
|
|
*/
|
|
public static String getZeroBaseString(int num, int size) {
|
|
return getZeroBaseString(String.valueOf(num), size);
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 주어진 size내에서 0으로 채워진 String을 리턴한다.
|
|
* </pre>
|
|
*
|
|
* @param num
|
|
* 원래 숫자 문자열
|
|
* @param size
|
|
* 0을 넣어 만들 문자열의 길이
|
|
* @return String 주어진 size 앞부분에 0을 채운 문자열
|
|
*/
|
|
public static String getZeroBaseString(String num, int size) {
|
|
String zeroBase = "";
|
|
|
|
if (num.length() >= size)
|
|
return num;
|
|
|
|
for (int index = 0; index < (size - num.length()); ++index) {
|
|
zeroBase += "0";
|
|
}
|
|
|
|
return zeroBase + num;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 문자열을 getMethod에 맞는 형태로 변환한다.
|
|
* 엔터를 공백으로 하고 공백은 "%20"으로 변환한다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @return String 변환된 문자열
|
|
*/
|
|
public static String getGetMethodFormat(String str) {
|
|
String rtn = "";
|
|
rtn = replace(str, "\n", " ");
|
|
rtn = replace(rtn, " ", "%20");
|
|
return rtn;
|
|
}
|
|
|
|
/**
|
|
* val 문자열을 사건번호 형식으로 변환하여 반환한다.
|
|
*
|
|
* @param val
|
|
* @return
|
|
*/
|
|
public static String getCaseNo(String case_no, String merge_no) {
|
|
String case_nm = "";
|
|
if (!merge_no.equals("")) {
|
|
case_nm = merge_no;
|
|
} else if (case_no.length() >= 10) {
|
|
case_nm = "제" + case_no.substring(0, 4) + "-";
|
|
if (case_no.substring(4, 5).equals("A")) {
|
|
case_nm += "심사";
|
|
} else if (case_no.substring(4, 5).equals("B")) {
|
|
case_nm += "조정";
|
|
} else if (case_no.substring(4, 5).equals("C")) {
|
|
case_nm += "재심";
|
|
} else if (case_no.substring(4, 5).equals("D")) {
|
|
case_nm += "조";
|
|
} else if (case_no.substring(4, 5).equals("X")) {
|
|
case_nm += "";
|
|
}
|
|
|
|
if (case_no.substring(10).equals("M")) {
|
|
case_nm += "(병합)";
|
|
}
|
|
try {
|
|
case_nm += String.valueOf(Integer.parseInt(case_no.substring(5, 10))) + "호";
|
|
} catch(NumberFormatException e) {
|
|
LOGGER.debug("error", e);
|
|
case_nm += String.valueOf(case_no.substring(5, 10)) + "호";
|
|
} catch(IndexOutOfBoundsException e) {
|
|
LOGGER.debug("error", e);
|
|
case_nm += String.valueOf(case_no.substring(5, 10)) + "호";
|
|
} catch(Exception e) {
|
|
LOGGER.debug("error", e);
|
|
case_nm += String.valueOf(case_no.substring(5, 10)) + "호";
|
|
}
|
|
}
|
|
return case_nm;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 서버 도메인.
|
|
* </pre>
|
|
*
|
|
* @return String
|
|
*/
|
|
public static String svrDomain(String pageUrl, String protocol) {
|
|
String svr_domain = "";
|
|
int startPos = pageUrl.indexOf("http://");
|
|
int endPos = -1;
|
|
if (startPos >= 0) {
|
|
endPos = pageUrl.indexOf("/", startPos + 7);
|
|
} else {
|
|
startPos = pageUrl.indexOf("https://");
|
|
endPos = pageUrl.indexOf("/", startPos + 8);
|
|
}
|
|
svr_domain = pageUrl.substring(startPos, endPos);
|
|
return replace(svr_domain, "https://", protocol + "://");
|
|
}
|
|
|
|
public static String svrDomain(String pageUrl) {
|
|
return svrDomain(pageUrl, "http");
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* str을 size길이에 맞도록 왼쪽에 f_char로 채운다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @param f_char
|
|
* 원래 문자열 뒤에 붙일 문자열
|
|
* @param size
|
|
* f_char를 붙여 만들 문자열의 길이
|
|
* @return String 원래 문자열에 f_char를 붙여 만든 문자열
|
|
*/
|
|
public static String lpad(String str, String f_char, int size) {
|
|
if (str.length() >= size)
|
|
return str;
|
|
else
|
|
return getFillChar("", f_char, size - str.length()) + str;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* str을 size길이에 맞도록 오른쪽에 f_char로 채운다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @param f_char
|
|
* 원래 문자열 뒤에 붙일 문자열
|
|
* @param size
|
|
* f_char를 붙여 만들 문자열의 길이
|
|
* @return String 원래 문자열에 f_char를 붙여 만든 문자열
|
|
*/
|
|
public static String rpad(String str, String f_char, int size) {
|
|
if (str.length() >= size)
|
|
return str;
|
|
else
|
|
return str + getFillChar("", f_char, size - str.length());
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* str을 size길이에 맞도록 뒤에 f_char로 채운다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @param f_char
|
|
* 원래 문자열 뒤에 붙일 문자열
|
|
* @param size
|
|
* f_char를 붙여 만들 문자열의 길이
|
|
* @return String 원래 문자열에 f_char를 붙여 만든 문자열
|
|
*/
|
|
public static String getFillChar(String str, String f_char, int size) {
|
|
String fillChar = "";
|
|
|
|
if (str.length() >= size)
|
|
return str;
|
|
|
|
for (int index = 0; index < (size - str.length()); ++index) {
|
|
fillChar += f_char;
|
|
}
|
|
|
|
return str + fillChar;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* str을 size(Byte)길이에 맞도록 뒤에 f_char로 채운다.
|
|
* str의 길이를 byte로 계산한다.
|
|
* </pre>
|
|
*
|
|
* @param str
|
|
* 원래 문자열
|
|
* @param f_char
|
|
* 원래 문자열 뒤에 붙일 문자열
|
|
* @param size
|
|
* f_char를 붙여 만들 문자열의 길이
|
|
* @return String 원래 문자열에 f_char를 붙여 만든 문자열
|
|
*/
|
|
public static String getFillCharByte(String str, String f_char, int size) {
|
|
String fillChar = "";
|
|
|
|
if (str.getBytes().length >= size)
|
|
return str;
|
|
|
|
for (int index = 0; index < (size - str.getBytes().length); ++index) {
|
|
fillChar += f_char;
|
|
}
|
|
|
|
return str + fillChar;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 대상문자열(strTarget)에서 구분문자열(strDelim)을 기준으로 문자열을 분리하여
|
|
* 각 분리된 문자열을 배열에 할당하여 반환한다.
|
|
* </pre>
|
|
*
|
|
* @param strTarget
|
|
* 분리 대상 문자열
|
|
* @param strDelim
|
|
* 구분시킬 문자열로서 결과 문자열에는 포함되지 않는다.
|
|
* @param bContainNull
|
|
* 구분되어진 문자열중 공백문자열의 포함여부. true : 포함, false : 포함하지 않음.
|
|
* @return 분리된 문자열을 순서대로 배열에 격납하여 반환한다.
|
|
*/
|
|
public static String[] split(String strTarget, String strDelim, boolean bContainNull) {
|
|
// StringTokenizer는 구분자가 연속으로 중첩되어 있을 경우 공백 문자열을 반환하지 않음.
|
|
// 따라서 아래와 같이 작성함.
|
|
int index = 0;
|
|
String[] resultStrArray = new String[getStrCnt(strTarget, strDelim) + 1];
|
|
String strCheck = new String(strTarget);
|
|
while (strCheck.length() != 0) {
|
|
int begin = strCheck.indexOf(strDelim);
|
|
if (begin == -1) {
|
|
resultStrArray[index] = strCheck;
|
|
break;
|
|
} else {
|
|
int end = begin + strDelim.length();
|
|
if (bContainNull) {
|
|
resultStrArray[index++] = strCheck.substring(0, begin);
|
|
}
|
|
strCheck = strCheck.substring(end);
|
|
if (strCheck.length() == 0 && bContainNull) {
|
|
resultStrArray[index] = strCheck;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return resultStrArray;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* strTarget 문자열에서 strSearch문자열이 몇개가 나오는지 찾아 리턴
|
|
* </pre>
|
|
*
|
|
* @param strTarget
|
|
* 찾을 소스 문자열
|
|
* @param strSearch
|
|
* 찾을 문자열
|
|
* @return int 발생한 갯수
|
|
*/
|
|
public static int getStrCnt(String strTarget, String strSearch) {
|
|
int result = 0;
|
|
String strCheck = new String(strTarget);
|
|
for (int i = 0; i < strTarget.length();) {
|
|
int loc = strCheck.indexOf(strSearch);
|
|
if (loc == -1) {
|
|
break;
|
|
} else {
|
|
result++;
|
|
i = loc + strSearch.length();
|
|
strCheck = strCheck.substring(i);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// URL 변환
|
|
public static String encodeURL(String theURL) {
|
|
return replace(replace(theURL, "?", "@QUES@"), "&", "@AMP@");
|
|
}
|
|
|
|
public static String decodeURL(String theURL) {
|
|
return replace(replace(theURL, "@QUES@", "?"), "@AMP@", "&");
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* src문자열에서 맨 첫 글자를 대문자로 만들어 반환한다.
|
|
* </pre>
|
|
*
|
|
* @param src
|
|
* 바꿀문자열
|
|
* @return Strin 바뀐 문자열
|
|
*/
|
|
public static String makeFUpper(String src) {
|
|
if (src != null && src.length() > 0) {
|
|
return src.substring(0, 1).toUpperCase() + src.substring(1).toLowerCase();
|
|
} else {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 1차원배열에서 특정 String객체의 존재여부를 확인한다.
|
|
* </pre>
|
|
*
|
|
* @param array
|
|
* 1차원배열
|
|
* @param str
|
|
* 찾을 문자열
|
|
* @param ignorecase
|
|
* true 일경우 대소문자 구별
|
|
* @return boolean 존재하면 true 없으면 false
|
|
*/
|
|
public static boolean isExistInArray(String[] array, String str, boolean ignorecase) {
|
|
if (array == null)
|
|
return false;
|
|
|
|
for (int i = 0; i < array.length; ++i) {
|
|
if (ignorecase) {
|
|
if (array[i].toUpperCase().equals(str.toUpperCase()))
|
|
return true;
|
|
} else {
|
|
if (array[i].equals(str))
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 구분자로 분리된 스트링에서 특정 인덱스의 값을 리턴.
|
|
* </pre>
|
|
*
|
|
* @param arrayStr
|
|
* 구분자로 분리된 스트링
|
|
* @param pos
|
|
* 특정 인덱스
|
|
* @param dmt
|
|
* 구분자
|
|
* @return String
|
|
*/
|
|
public static String arrayCol(String arrayStr, int pos) {
|
|
return arrayCol(arrayStr, pos, "|");
|
|
}
|
|
|
|
public static String arrayCol(String arrayStr, int pos, String dmt) {
|
|
if (arrayStr.equals("")) {
|
|
return "";
|
|
}
|
|
String array[] = split(arrayStr, dmt, true);
|
|
return array.length < pos - 1 ? "" : array[pos - 1];
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 구분자로 분리된 스트링에서 특정 값 존재여부 리턴.
|
|
* </pre>
|
|
*
|
|
* @param arrayStr
|
|
* 구분자로 분리된 스트링
|
|
* @param key
|
|
* 특정 값
|
|
* @param dmt
|
|
* 구분자
|
|
* @return String
|
|
*/
|
|
public static boolean arrayFind(String arrayStr, String key, String dmt) {
|
|
if (arrayStr.equals("")) {
|
|
return false;
|
|
}
|
|
String array[] = split(arrayStr, dmt, true);
|
|
for (int i = 0; i < array.length; i++) {
|
|
if (array[i].equals(key)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* String 객체의 substring 메쏘드의 에러방지
|
|
* </pre>
|
|
*
|
|
* @return String
|
|
*/
|
|
public static String substr(String str, int sPos, int ePos) {
|
|
if (sPos > ePos)
|
|
return "";
|
|
return str.length() < ePos ? "" : str.substring(sPos, ePos);
|
|
}
|
|
|
|
public static String substr(String str, int sPos) {
|
|
return substr(str, sPos, str.length());
|
|
}
|
|
|
|
// HTML내의 RGB값을 16진수로 변황
|
|
public static String rgbToHexInHtml(String cHtml) throws Exception {
|
|
while (true) {
|
|
int sPos = cHtml.toLowerCase().indexOf("rgb(");
|
|
if (sPos < 0) {
|
|
break;
|
|
}
|
|
|
|
int ePos = cHtml.toLowerCase().indexOf(")", sPos);
|
|
String rgb_text = cHtml.substring(sPos + 4, ePos);
|
|
String rgb[] = StringUtil.split(StringUtil.replace(rgb_text, " ", "") + ",,", ",", true);
|
|
String rgb16 = "";
|
|
for (int i = 0; i < 3; i++) {
|
|
rgb16 += Integer.toHexString(Integer.parseInt(rgb[i]));
|
|
}
|
|
cHtml = StringUtil.replace(cHtml, "rgb(" + rgb_text + ")", rgb16);
|
|
cHtml = StringUtil.replace(cHtml, "RGB(" + rgb_text + ")", rgb16);
|
|
}
|
|
return cHtml;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 스트링의 왼쪽공백을 없애준다.
|
|
* </pre>
|
|
*
|
|
* @return String
|
|
*/
|
|
public static String ltrim(String str) {
|
|
int len = str.length();
|
|
int st = 0;
|
|
int off = 0;
|
|
char[] val = str.toCharArray();
|
|
|
|
while ((st < len) && (val[off + st] <= ' ')) {
|
|
st++;
|
|
}
|
|
|
|
return st > 0 ? str.substring(st) : str;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 스트링의 오른쪽공백을 없애준다.
|
|
* </pre>
|
|
*
|
|
* @return String
|
|
*/
|
|
public static String rtrim(String str) {
|
|
int len = str.length();
|
|
int st = 0;
|
|
int off = 0;
|
|
char[] val = str.toCharArray();
|
|
|
|
while ((st < len) && (val[off + len - 1] <= ' ')) {
|
|
len--;
|
|
}
|
|
return len < str.length() ? str.substring(0, len) : str;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 스트링에 BackSlash 를 추가해준다.
|
|
* </pre>
|
|
*
|
|
* @return String
|
|
* @changed 2002.09.14 이광렬
|
|
*/
|
|
public static String addBackSlash(String pm_sString) {
|
|
String lm_sRetString = "";
|
|
|
|
for (int i = 0; i < pm_sString.length(); i++) {
|
|
if (pm_sString.charAt(i) == '\\') {
|
|
lm_sRetString += "\\\\";
|
|
} else if (pm_sString.charAt(i) == '\'') {
|
|
lm_sRetString += "\\\'";
|
|
} else {
|
|
lm_sRetString += pm_sString.charAt(i);
|
|
}
|
|
}
|
|
return lm_sRetString;
|
|
}
|
|
|
|
|
|
/**
|
|
* <pre>
|
|
* 문자열 합하기
|
|
* </pre>
|
|
*
|
|
* @return String
|
|
* @changed 2017.09.14 정진수
|
|
*/
|
|
public static String concatStr(String[] strArr, String delimeter) {
|
|
String rtnStr = "";
|
|
for(int i=0; i < strArr.length; i++) {
|
|
if(!strArr[i].trim().equals("")) {
|
|
if(!rtnStr.equals("")) { rtnStr += delimeter; }
|
|
rtnStr += strArr[i].trim();
|
|
}
|
|
}
|
|
return rtnStr;
|
|
}
|
|
/**
|
|
* <pre>
|
|
* 스트링 암호화.
|
|
* </pre>
|
|
*
|
|
* @return String
|
|
* @changed 2002.09.23 정진수
|
|
*/
|
|
public static String strEncode(String inputStr) {
|
|
String result = "";
|
|
inputStr = inputStr.trim();
|
|
|
|
for (int i = 0; i < inputStr.length(); i++) {
|
|
int val = (int) inputStr.charAt(i) + i * 29;
|
|
result = result + lpad(String.valueOf(val), "0", 3);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 암호화된 스트링 복호화.
|
|
* </pre>
|
|
*
|
|
* @return String
|
|
* @changed 2002.09.23 정진수
|
|
*/
|
|
public static String strDecode(String inputStr) {
|
|
String result = "";
|
|
inputStr = inputStr.trim();
|
|
|
|
//웹 취약점 때문에 수정
|
|
if (inputStr.length() > 0) {
|
|
for (int i = 0; i < inputStr.length() / 3; i++) {
|
|
int num = Integer.parseInt(inputStr.substring(i * 3, i * 3 + 3)) - (i * 29);
|
|
//웹 취약점 때문에 수정
|
|
if (num > 0) {
|
|
result = result + (char) num;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* 주어진 갯수만큼 출력
|
|
* </pre>
|
|
*
|
|
* @return String
|
|
* @changed 2002.09.23 정진수
|
|
*/
|
|
public static String nbsp(int count) {
|
|
String result = "";
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
result = result + " ";
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static boolean containsCharOnly(String input, String chars) {
|
|
for (int i = 0; i < input.length(); i++) {
|
|
boolean isOk = false;
|
|
for (int j = 0; j < chars.length(); j++) {
|
|
if (input.charAt(i) == chars.charAt(j)) {
|
|
isOk = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!isOk) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static boolean containsBadChar(String input, String chars) {
|
|
for (int i = 0; i < input.length(); i++) {
|
|
boolean isOk = false;
|
|
for (int j = 0; j < chars.length(); j++) {
|
|
if (input.charAt(i) == chars.charAt(j)) {
|
|
isOk = true;
|
|
break;
|
|
}
|
|
}
|
|
if (isOk) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static String streamToStr(InputStream in) throws Exception {
|
|
ByteArrayOutputStream bout = new ByteArrayOutputStream();
|
|
int bcount = 0;
|
|
byte[] buf = new byte[2048];
|
|
int read_retry_count = 0;
|
|
try {
|
|
while (true) {
|
|
int n = in.read(buf);
|
|
if (n > 0) {
|
|
bcount += n;
|
|
bout.write(buf, 0, n);
|
|
} else if (n == -1)
|
|
break;
|
|
}
|
|
bout.flush();
|
|
bout.close();
|
|
return new String(bout.toByteArray());
|
|
} catch (NumberFormatException e) {
|
|
LOGGER.debug("error", e);
|
|
return "";
|
|
} catch (IndexOutOfBoundsException e) {
|
|
LOGGER.debug("error", e);
|
|
return "";
|
|
} catch (IOException e) {
|
|
LOGGER.debug("error", e);
|
|
return "";
|
|
} catch (Exception e) {
|
|
LOGGER.debug("error", e);
|
|
return "";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* GET 방식의 파라메터를 제한
|
|
* </pre>
|
|
*
|
|
* @return boolean
|
|
* @changed 2015.10.13 정진수
|
|
*/
|
|
public static boolean blockParam(String queryStr, String okParam) {
|
|
if (queryStr != null && !queryStr.equals("")) {
|
|
String[] params = split(queryStr, "&", true);
|
|
for (int i = 0; i < params.length; i++) {
|
|
String[] arr = split(params[i], "=", true);
|
|
if (arr[0].equals("method")) {
|
|
continue;
|
|
}
|
|
if (okParam.indexOf(arr[0] + ",") < 0) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static String nvl(String src, String target) {
|
|
if (src == null) {
|
|
return target;
|
|
} else {
|
|
return src;
|
|
}
|
|
}
|
|
|
|
public static void main(String[] args) {
|
|
try {
|
|
java.io.InputStream in = new FileInputStream(
|
|
"D:/iram/iramlib/src/iram/lib/db/helper/JDBCStatementHelper.java");
|
|
System.out.println(StringUtil.streamToStr(in));
|
|
in.close();
|
|
} catch (NumberFormatException e) {
|
|
LOGGER.debug("error", e);
|
|
} catch (IndexOutOfBoundsException e) {
|
|
LOGGER.debug("error", e);
|
|
} catch (IOException e) {
|
|
LOGGER.debug("error", e);
|
|
} catch (Exception e) {
|
|
LOGGER.debug("error", e);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* <pre>
|
|
* \t 제거하기
|
|
* </pre>
|
|
*
|
|
* @return String
|
|
* @changed 2025.11.03 YJI
|
|
*/
|
|
public static String removeTabStr(String str) {
|
|
String rtnStr = "";
|
|
if (str != null && !"".equals(str)) {
|
|
rtnStr = str.replace("\t", "");
|
|
}
|
|
return rtnStr;
|
|
}
|
|
}
|