Springboot(java) :: 문자 관련 StringUtil 모음집

 

파일로 보기는 아래에..

StringUtil.java

0.02MB

 

 

 

악성코드 無 only java..

 

 

 

/**
 * @Class Name : StringUtil.java
 * @Description : 문자열 데이터 처리 관련 유틸리티
 * @Modification Information
 * @author ony
 **/

package com.sample.controller; // 이름 임의 변경함
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.security.SecureRandom;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.Locale;

public class StringUtil {

    /** [1]
     *  빈 문자열 ""
     *  **/
    public static final String EMPTY = "";


    /** [2]
     * Padding을 할 수 있는 최대 수치
     * // private static final int PAD_LIMIT = 8192;
     * An array of Strings used for padding
     * Used for efficient space padding. The length of each String expands as needed **/
    private static final String[] PADDING = new String[Character.MAX_VALUE];

    static {
        /** space padding is most common, start with 64 chars **/
        PADDING[32]  = "                                ";
    }

    /** [3]
     * 문자열이 지정한 길이를 초과하였을 때
     * 지정한 길이까지 출력 + 특정 문자열을 붙혀주는 메서드
     * @param source 원본 문자열 배열
     * @param output 추가할 문자열
     * @param slength 지정 길이
     * @return 지정 길이 만큼 출력 후, 특정 문자열 합쳐주는 메서드
     * **/
    public static String cutStringAdd(String source, String output, int slength){
        String returnVal = null;
        if (source != null) {
            if (source.length() > slength) {
                returnVal = source.substring(0, slength) + output;
            } else
                returnVal = source;
        }
        return returnVal;
    }

    /** [4]
     * 문자열이 지정한 길이를 초과한 경우, 초과한 문자열을 삭제하는 메서드
     * @param source 원본 문자열 배열
     * @param slength 지정 길이
     * @return 지정 길이 만큼 문자열 자름
     * **/
    public static String cutString(String source, int slength){
        String result = null;
        if (source != null) {
            if (source.length() > slength) {
                result = source.substring(0, slength);
            } else
                result = source;
        }
        return result;
    }

    /** [5]
     * 문자열 검증: String이 비었거나("") null인지 검증
     *
     * in case)
     * "", null = true
     * " ", "string", " string " = false
     *
     * @param str 체크 대상 String Object이며 null 허용
     * @return 입력받은 문자열이 빈 문자열이거나 null인 경우 true 배출
     * **/
    public static boolean isEmpty(String str){
        return str == null || str.length() == 0;
    }

    /** [6]
     * 문자열에 포함된 모든 대상 문자(char) 제거
     *
     * in case)
     * StringUtil.remove("test",'t') = "es"
     *
     * @param str 기준 문자열
     * @param remove 입력받은 문자열에서 제거할 대상 문자열
     * @return 제거할 대상이 제거된 문자열.
     * **/
    public static String remove(String str, char remove){
        if(isEmpty(str) || str.indexOf(remove) == -1){
            return str;
        }
        char[] chars = str.toCharArray();
        int pos = 0;
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] != remove) {
                chars[pos++] = chars[i];
            }
        }
        return new String(chars, 0, pos);
    }

    /** [7]
     * 문자열 내부의 콤마 character(,)을 제거 - 6번 func 사용
     *
     * in case)
     * StringUtil.removeCommaChar("hi,hello,goodmorning") = "hihellogoodmorning"
     *
     * @param str 문자열
     * @return ","(콤마) 가 제거된 str
     * **/
    public static String removeCommaChar(String str){
        return remove(str, ',');
        // -, / 등등 활용 가능성을 위한 예제
    }

    /** [8]
     * 원본 문자열에 포함된 특정 문자열을 새로운 문자열로 치환
     *
     * @param source 원본 문자열
     * @param subject 변환 시킬 문자열
     * @param object 변환 텍스트
     * @return 치환 완료된 문자열
     * **/
    public static String replace(String source, String subject, String object) {
        StringBuffer rtnStr = new StringBuffer();
        String preStr = "";
        String nextStr = source;
        String srcStr = source;

        while (srcStr.indexOf(subject) >= 0) {
            preStr = srcStr.substring(0, srcStr.indexOf(subject));
            nextStr = srcStr.substring(srcStr.indexOf(subject) + subject.length(), srcStr.length());
            srcStr = nextStr;
            rtnStr.append(preStr).append(object);
        }

        rtnStr.append(nextStr);

        return rtnStr.toString();
    }

    /** [9]
     * 원본 문자열에 포함된 특정 문자열 첫번째 한 개 만을 새로운 문자열로 치환
     *
     * @param source 원본 문자열
     * @param subject 변환 시킬 문자열
     * @param object 변환 텍스트
     * @return 치환 완료된 문자열
     *
     * source에 subject가 없는 경우는 원본 source 제출
     * **/
    public static String replaceOnce(String source, String subject, String object) {
        StringBuffer rtnStr = new StringBuffer();
        String preStr = "";
        String nextStr = source;

        if (source.indexOf(subject) >= 0) {
            preStr = source.substring(0, source.indexOf(subject));
            nextStr = source.substring(source.indexOf(subject) + subject.length(), source.length());
            rtnStr.append(preStr).append(object).append(nextStr);
            return rtnStr.toString();
        } else {
            return source;
        }
    }

    /** [10]
     * str 중 searchStr의 시작 위치를 반환
     * (입력 값 중 null이 있는 경우/searchStr이 없는 경우 -1을 반환)
     *
     * @param str 검색 문자열
     * @param searchStr 검색 대상 문자열
     * @return searchStr의 위치 index
     * **/
    public static int indexOf(String str, String searchStr) {

        if (str == null || searchStr == null)
        {
            return -1;
        }

        return str.indexOf(searchStr);
    }

    /** [11]
     * 객체가 null인지 확인하고 null인 경우 ""로 변경하는 메서드
     *
     * @param object 원본 객체
     * @return resultVal 문자열
     * **/
    public static String isNullToString(Object object) {
        String string = "";

        if (object != null) {
            string = object.toString().trim();
        }

        return string;
    }

    /** [12]
     * 문자열에서 {@link Character#isWhitespace(char)}에 정의된
     * 모든 공백문자 제거
     *
     * in case)
     * StringUtil.removeWhitespace(null) = null
     * StringUtil.removeWhitespace(" a b c    ") = "abc"
     *
     * @param str 공백문자를 제거할 문자열
     * @return 공백문자가 제거된 문자열.
     * **/
    public static String removeWhitespace(String str) {

        if (isEmpty(str)) {
            return str;
        }

        int sz = str.length();
        char[] chs = new char[sz];
        int count = 0;

        for (int i = 0; i < sz; i++) {
            if (!Character.isWhitespace(str.charAt(i))) {
                chs[count++] = str.charAt(i);
            }
        }

        if (count == sz) {
            return str;
        }

        return new String(chs, 0, count);
    }

    /** [13]
     * HTML 코드가 들어간 문서를 표시하는 경우 태그에 손상을 막아주는 메서드
     *
     * @param strString 체크 대상 문자열
     * @return HTML 태그를 치환한 문자열
     * **/
    public static String checkHtmlView(String strString) {
        String strNew = "";
        StringBuffer strTxt = new StringBuffer("");
        char chrBuff;
        int len = strString.length();

        for (int i = 0; i < len; i++) {
            chrBuff = (char) strString.charAt(i);
            switch (chrBuff) {
                case '<':
                    strTxt.append("&lt;");
                    break;
                case '>':
                    strTxt.append("&gt;");
                    break;
                case '"':
                    strTxt.append("&quot;");
                    break;
                case 10:
                    strTxt.append("<br>");
                    break;
                case ' ':
                    strTxt.append("&nbsp;");
                    break;
                default:
                    strTxt.append(chrBuff);
            }
        }

        strNew = strTxt.toString();

        return strNew;
    }

    /** [14]
     * 문자열을 지정한 분리자로 분리하여 배열로 리턴하는 메서드
     *
     * @param source 원본 문자열
     * @param separator 분리자
     * @return 분리자로 나누어진 문자열 배열
     * **/
    public static String[] split(String source, String separator) throws NullPointerException {
        String[] returnVal = null;
        int cnt = 1;
        int index = source.indexOf(separator);
        int index0 = 0;

        while (index >= 0) {
            cnt++;
            index = source.indexOf(separator, index + 1);
        }

        returnVal = new String[cnt];
        cnt = 0;
        index = source.indexOf(separator);

        while (index >= 0) {
            returnVal[cnt] = source.substring(index0, index);
            index0 = index + 1;
            index = source.indexOf(separator, index + 1);
            cnt++;
        }

        returnVal[cnt] = source.substring(index0);

        return returnVal;
    }

    /** [15]
     * {@link String#toLowerCase()}를 사용하여 소문자 변환
     *
     * @param str 소문자로 변환시킬 문자열
     * @return 소문자로 변환된 문자열. null 입력시 null 리턴
     * **/
    public static String lowerCase(String str) {
        if (str == null) {
            return null;
        }

        return str.toLowerCase();
    }

    /** [16]
     * {@link String#toUpperCase()}를 사용하여 대문자 변환
     *
     * @param str 대문자로 변환시킬 문자열
     * @return 대문자로 변환된 문자열. null 입력시 null 리턴
     * **/
    public static String upperCase(String str) {
        if (str == null) {
            return null;
        }

        return str.toUpperCase();
    }

    /** [17]
     * 입력된 string의 앞 쪽에서 인자로 전달된 문자를 모두 제거하는 메서드
     *
     * in case)
     * StringUtil.stripStart("abcd  ","cat") = "bd  "
     *
     * @param str 기준 문자열
     * @param stripChars 제거 대상 문자열
     * @return 지정된 문자가 제거된 기준 문자열. null 입력 시 null 리턴
     * **/
    public static String stripStart(String str, String stripChars) {
        int strLen;

        if (str == null || (strLen = str.length()) == 0)
        {
            return str;
        }

        int start = 0;
        if (stripChars == null) {
            while ((start != strLen) && Character.isWhitespace(str.charAt(start)))
            {
                start++;
            }
        }
        else if (stripChars.length() == 0) {
            return str;
        }
        else {
            while ((start != strLen) && (stripChars.indexOf(str.charAt(start)) != -1))
            {
                start++;
            }
        }

        return str.substring(start);
    }

    /** [18]
     * 입력된 string의 뒷 쪽에서 인자로 전달된 문자를 모두 제거하는 메서드
     *
     * in case)
     * StringUtil.stripStart("  abcd","cat") = "  bd"
     *
     * @param str 기준 문자열
     * @param stripChars 제거 대상 문자열
     * @return 지정된 문자가 제거된 기준 문자열. null 입력 시 null 리턴
     * **/
    public static String stripEnd(String str, String stripChars) {
        int end;
        if (str == null || (end = str.length()) == 0) {
            return str;
        }

        if (stripChars == null) {
            while ((end != 0) && Character.isWhitespace(str.charAt(end - 1))) {
                end--;
            }
        } else if (stripChars.length() == 0) {
            return str;
        } else {
            while ((end != 0) && (stripChars.indexOf(str.charAt(end - 1)) != -1)) {
                end--;
            }
        }

        return str.substring(0, end);
    }

    /** [19]
     * 입력된 string의 양 방향에서 인자로 전달된 문자를 모두 제거하는 메서드
     *
     * @param str 기준 문자열
     * @param stripChars 제거 대상 문자열
     * @return 지정된 문자가 제거된 기준 문자열. null 입력 시 null 리턴
     * **/
    public static String strip(String str, String stripChars) {
        if (isEmpty(str)) {
            return str;
        }

        String srcStr = str;
        srcStr = stripStart(srcStr, stripChars);

        return stripEnd(srcStr, stripChars);
    }

    /** [20]
     * 문자열 A~Z 사이의 랜덤 문자열을 구하는 기능
     * (시작 문자열, 종료 문자열 지정 가능)
     *
     * @param startChr 첫 문자
     * @param endChr 마지막 문자
     * @exception
     * @return 첫 문자와 마지막 문자 사이의 랜덤 문자
     * **/
    public static String getRandomStr(char startChr, char endChr) {
        int randomInt;
        String randomStr = null;
        // 시작 문자 와 종료 문자 아스키숫자로 변환
        int startInt = Integer.valueOf(startChr);
        int endInt = Integer.valueOf(endChr);
        // 시작 문자가 종료 문자보다 클 경우 exception 발생
        if (startInt > endInt) {
            throw new IllegalArgumentException("Start String: " + startChr + " End String: " + endChr);
        }
        // 랜덤 객체 생성
        SecureRandom rnd = new SecureRandom();
        do {
            // 시작 문자 와 종료문자 사이에서 랜덤 숫자 발생
            randomInt = rnd.nextInt(endInt + 1);
        } while (randomInt < startInt);
        // 입력 받은 문자 'A'(65)보다 작으면 다시 랜덤 숫자 발생.
        // 랜덤 숫자를 문자로 변환 후 String 으로 재변환

        randomStr = (char) randomInt + "";
        return randomStr;
    }

    /** [21]
     * 날짜 형식 문자열 내부에 마이너스 char(-) 추가
     *
     * in case)
     * StringUtil.addMinusChar("20231227") = "2023-12-27"
     *
     * @param date 입력 문자열
     * @return "-"가 추가된 입력 문자열
     * **/
    public static String addMinusChar(String date) {
        if (date.length() == 8)
            return date.substring(0, 4).concat("-").concat(date.substring(4, 6)).concat("-").concat(date.substring(6, 8));
        else
            return "";
    }

    /** [22]
     * 응용 어플리케이션에서 고유값 사용하기 위해
     * 시스템에서 17자리의 timestamp 값 구하는 메서드
     *
     * @return timestamp 값
     * @exception
     * **/
    public static String getTimeStamp() {
        String rtnStr = null;

        // 문자열로 변환하기 위한 패턴 설정(년도-월-일 시:분:초:초(자정이후 초))
        String pattern = "yyyyMMddhhmmssSSS";
        SimpleDateFormat sdfCurrent = new SimpleDateFormat(pattern, Locale.KOREA);
        Timestamp ts = new Timestamp(System.currentTimeMillis());
        rtnStr = sdfCurrent.format(ts.getTime());

        return rtnStr;
    }

}

 

 

노가다 String Util 모음집... 꺼내쓰시면 됩니다...

정신 건강에 도움이 되길 바라며...

 

행복하세요 ^^...