Java 편의성 Util #1

문자(String)처리 편의성 메소드 모음

자바에서 String 처리 메소드, 객체 Empty 처리 메소드 등 자주 사용하지만, 개발자 마다 다르게 사용할 소지가 있는 메소드를 동일한 가이드로 사용할 수 있게 적용함.

장점 : 이미 검증된 소스로, Empty, null등에 대한 고민 없이 편하게 사용
단점 : 없어 보임? 누가 알면 댓글좀 ㅎ

SetParameter Class는 차후 추가 예정
위 클래스는 제거하고 임시로 사용

package util;

import static constants.Constants.AMP;
import static constants.Constants.EMPTY_STRING;
import static constants.Constants.EQUAL;
import static constants.Constants.HYPHEN;
import static constants.Constants.QUESTION;
import static constants.Constants.Y;
import static constants.Constants.ZERO;

import java.math.BigDecimal;
import java.util.Collection;
import java.util.List;
import java.util.regex.Pattern;
import constants.Constants;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

public class SimpStringUtil {
	/**
	 * str 값이 NULL, str 이 공백으로만 이루어진 경우 ""로 치환해서 리턴
	 * */
	public static String NVL(String str) {
		if (str == null || str.trim().equals(EMPTY_STRING)) {
			return EMPTY_STRING;
		} else {
			return str;
		}
	}

	/**
	 * str 값이 NULL, str 이 공백으로만 이루어진 경우 rtnStr 로 치환해서 리턴
	 */
	public static String NVL(String str, String rtnStr) {
		if (str == null || str.trim().equals(EMPTY_STRING)) {
			return rtnStr;
		} else {
			return str;
		}
	}

	/**
	 * Object 값이 NULL 일경우 T 에 해당 하는 형식으로 리턴
	 * @return T
	 */
	public static <T> T NVL(Object obj, Class<T> tClass) {

		if (obj == null) {
			if (tClass.getName().equals(Long.class.getName())) {
				return tClass.cast(0L);
			} else if (tClass.getName().equals(Integer.class.getName())) {
				return tClass.cast(0);
			} else if (tClass.getName().equals(String.class.getName())) {
				return tClass.cast(EMPTY_STRING);
			} else if (tClass.getName().equals(BigDecimal.class.getName())) {
				return tClass.cast(new BigDecimal(0L));
			} else if (tClass.getName().equals(Boolean.class.getName())) {
				return tClass.cast(false);
			}
		}
		return tClass.cast(obj);
	}

	/** 
	 * Object 공백 check
	 * */
	public static boolean isEmpty(Object object){
		return ObjectUtils.isEmpty(object);
	}
	
	/** if 문이 길어져서 생성 (순서 지켜야함!! ex. object, object.getValue 순서로..)
	 * @param objects 체크할 객체들
	 * @return boolean 비어있는 객체가 나오는 순간 true 리턴
	 * */
	public static boolean isContainEmpty(Object... objects) {
		for (Object object : objects) {
			if( ObjectUtils.isEmpty(object)) {
				return true;
			}
		}
		return false;
	}
	public static boolean isNotEmpty(Object object){
		return !ObjectUtils.isEmpty(object);
	}

	/** 
	 * String 공백 check
	 * */
	public static boolean isEmpty(String str) {
		return StringUtils.isEmpty(str);
	}
	public static boolean isNotEmpty(String str) {
		return !StringUtils.isEmpty(str);
	}

	/** 
	 * long 공백 check
	 * */
	public static boolean isEmpty(Long number){
		return number == null;
	}
	public static boolean isNotEmpty(Long number){
		return number != null;
	}

	/** 
	 * string equals
 	 */
	public static boolean equals(String firstStr, String secondStr){
		if(isEmpty(firstStr) || isEmpty(secondStr)) return false;
		return firstStr.equals(secondStr);
	}

	/** string Not equals */
	public static boolean notEquals(String firstStr, String secondStr){
		if(isEmpty(firstStr) || isEmpty(secondStr)) return false;
		return !firstStr.equals(secondStr);
	}

	/**
	 * 휴대번호 포맷 변경
	 */
	public static String phoneNumberHyphenAdd(String num, String mask) {
		String formatNum = EMPTY_STRING;
		if (SimpStringUtil.NVL(num).equals(EMPTY_STRING)) {
			return formatNum;
		}
		num = num.replaceAll(HYPHEN, EMPTY_STRING);

		// 휴대번호가 11자리 (010-1234-7890)
		if (num.length() == 11) {
			if (mask.equals(Y)) {
				formatNum = num.replaceAll("(\\d{3})(\\d{3,4})(\\d{4})", "$1-****-$3");
			} else {
				formatNum = num.replaceAll("(\\d{3})(\\d{3,4})(\\d{4})", "$1-$2-$3");
			}
		// 휴대번호가 12자리 (1234-5678-9123)
		} else if (num.length() == 12) {
			if (mask.equals(Y)) {
				formatNum = num.replaceAll("(\\d{4})(\\d{4})(\\d{4})", "$1-****-$3");
			} else {
				formatNum = num.replaceAll("(\\d{4})(\\d{4})(\\d{4})", "$1-$2-$3");
			}
		// 휴대번호가 8자리 (1234-5678)
		} else if (num.length() == 8) {
			formatNum = num.replaceAll("(\\d{4})(\\d{4})", "$1-$2");
		// 그 외 휴대번호
		} else {
			if (num.indexOf("02") == 0) {
				if (mask.equals(Y)) {
					formatNum = num.replaceAll("(\\d{2})(\\d{3,4})(\\d{4})", "$1-****-$3");
				} else {
					formatNum = num.replaceAll("(\\d{2})(\\d{3,4})(\\d{4})", "$1-$2-$3");
				}
			} else {
				if (mask.equals(Y)) {
					formatNum = num.replaceAll("(\\d{3})(\\d{3,4})(\\d{4})", "$1-****-$3");
				} else {
					formatNum = num.replaceAll("(\\d{3})(\\d{3,4})(\\d{4})", "$1-$2-$3");
				}
			}
		}
		return formatNum;
	}

	/**
	 * url parameter 만들기
	 *
	 * @param setParameterList param 이 담긴 List
	 * @return
	 * @see SetParameter
	 */
	public static String getParameter(List<SetParameter> setParameterList){
		return setParameterList.stream().map(p -> p.getKey() + EQUAL + p.getValue())
						  	     	    .reduce((p1, p2) -> p1 + AMP + p2)
							     		.map(s -> QUESTION + s)
							     		.orElse(EMPTY_STRING);
	}

	/**
	 * url parameter 만들기
	 *
	 * @param setParameterList param 이 담긴 List
	 * @return
	 * @see SetParameter
	 */
	public static String getParameterNotQuestion(List<SetParameter> setParameterList){
		return setParameterList.stream().map(p -> p.getKey() + EQUAL + p.getValue())
			.reduce((p1, p2) -> p1 + AMP + p2)
			.map(s -> "" + s)
			.orElse(EMPTY_STRING);
	}

	/**
	 * 전체 숫자 길이(zeroLength)에서 num길이를 제외한만큼 0을 채워준다
	 * ex) num = 10, zeroLength = 5
	 * output : 00010 리턴
	 * @param num .
	 * @param zeroLength .
	 * @return .
	 */
	public static String zeroFill(int num, int zeroLength) {
		String rtnStr = "";
		if (zeroLength == 0) {
			zeroLength = 1;
		}
		rtnStr = String.format("%0"+zeroLength+"d",num);
		return rtnStr;

	}

	/**
	 * 개행문자(\r\n) 빈 값으로 치환
	 * @param str .
	 * @return String .
	 */
	public static String spaceEscape(String str) {
		if (SimpStringUtil.isEmpty(str)) {
			return EMPTY_STRING;
		}
		return str.replaceAll("(\r\n|\r|\n|\n\r)",EMPTY_STRING);
	}

	/**
	 * 입력가능 문자에 대한 최소 / 최대 입력길이 체크
	 * 정상일경우 true 반환
	 * @param str String
	 * @param minLength int
	 * @param maxLength int
	 * @return boolean
	 */
	public static boolean isLengthCheck(String str, int minLength, int maxLength) {
		if (SimpStringUtil.isEmpty(str)) return false;
		boolean rtnBool = true;
		int strLength = str.length();
		if (strLength < minLength) {
			rtnBool = false;
		}
		if (strLength > maxLength) {
			rtnBool = false;
		}
		return rtnBool;
	}
	/**
	 * 입력가능 문자에 대한 패턴 확인
	 * 정상일경우 true 리턴
	 * @param str String
	 * @param types String
	 * @return boolean
	 */
	public static boolean isPattern(String str, String... types) {
		if (SimpStringUtil.isEmpty(str)) return false;
		boolean isBool = true;

		if (!org.apache.commons.lang3.StringUtils.isBlank(str)) {
			String regx = "^[";
			if (types != null && types.length > 0) {
				for (String p : types) {
					switch (p) {
						case Constants.KOR:
							regx += Constants.KOR_FORMAT;
							break;
						case Constants.ENG:
							regx += Constants.ENG_FORMAT;
							break;
						case Constants.NUM:
							regx += Constants.NUM_FORMAT;
							break;
						case Constants.SPC_1:
							regx += Constants.SPC_1_FORMAT;
							break;
						case Constants.SPC_2:
							regx += Constants.SPC_2_FORMAT;
							break;
						case Constants.SPC_3:
							regx += Constants.SPC_3_FORMAT;
							break;
						case Constants.SPC_4:
							regx += Constants.SPC_4_FORMAT;
							break;
						default:
							break;
					}
				}
				regx += "\\s]*$";
			}
			isBool = Pattern.matches(regx, str);
		}

		return isBool;
	}

	/**
	 * 입력불가능 문자 체크
	 * @param str
	 * @return
	 */
	public static boolean isLimitPattern(String str) {
		if (SimpStringUtil.isNotEmpty(str) && SimpStringUtil.isNotEmpty(Constants.LIMIT_SPC)) {
			return Pattern.matches(Constants.LIMIT_SPC_PATTERN, str);
		}
		return false;
	}
	/**
	 * Collection 의 사이즈 리턴
	 * null 이면 0
	 * null safe
	 * */
	public static int collectSize(Collection<?> c) {
		return c == null ? 0 : c.size();
	}

	/**
	 * null safe
	 * list addAll
	 * */
	public static <T> void addAll(List<T> sourceList, List<T> addlist) {
		if (SimpStringUtil.isNotEmpty(addlist)) {
			sourceList.addAll(addlist);
		}
	}

	/**
	 * Y|N 의 반대값 리턴
	 * - Y -> N
	 * - N - >Y
	 */
	public static String notYn(String yn) {
		if (SimpStringUtil.isNotEmpty(yn)) {
			if (SimpStringUtil.equals(yn, Constants.Y)) {
				// 값이 비어있지 않고 'Y' 인경우 -> 'N' 리턴
				yn = Constants.N;
			} else if (SimpStringUtil.equals(yn, Constants.N)) {
				// 값이 비어있지 않고 'N' 인경우 -> 'Y' 리턴
				yn = Constants.Y;
			}
		}

		return yn;
	}

	/**
	 * 문자열 최대 length 까지 잘라서 리턴
	 */
	public static String getShortString(String message, int maxLength) {
		if (SimpStringUtil.isNotEmpty(message) && message.length() > maxLength) {
			message = message.substring(ZERO, maxLength);
		}

		return message;
	}
}

(Git 계정 만든 후 소스 Upload 예정)