[Java] 정규표현식(RegExp) 이해하기 : 패턴, 문자 클래스, 자주 사용 패턴

Java/이론 및 문법

[Java] 정규표현식(RegExp) 이해하기 : 패턴, 문자 클래스, 자주 사용 패턴

adjh54 2023. 1. 23. 22:44

728x170

해당 글의 목적은 주요 정규식 조작함수를 이해하고 예제를 통한 이해를 돕기 위해 작성한 글입니다. 해당 글에서는 모든 함수에 대해서는 포함하고 있지 않으며 자주 사용되는 함수 위주로 작성하였습니다.

1) 정규표현식(Regular Expression)

💡 정규표현식(Regular Expression)

- 정규표현식 혹은 정규식은 특정 문자열의 규칙을 가지는 문자열의 집합을 표현하는 데 사용되는 언어를 의미합니다.

1. 정규표현식 패턴(Regular Expression Pattern)

1.1. 문자 클래스(Character classes)

💡 문자 클래스(Character classes)

- 문자와 숫자를 구분하는 것과 같이 문자 종류를 구분하는 데 사용합니다.

정규식 패턴	설명	패턴 종류	예제
\\w	'문자만' 허용하는 정규표현식	(a-z, A-Z, 0-9, …)	String REGEXP_PATTERN_CHAR = "^[\\w]*$";
\\W	'문자가 아닌 경우에만' 허용하는 정규표현식	! (a-z, A-Z, 0-9, …)	String REGEXP_PATTERN_NO_CHAR = "^[\\W]*$";
\\d	'숫자만' 허용하는 정규표현식	(0-9)	String REGEXP_PATTERN_NUMBER = "^[\\d]*$";
\\D	'숫자가 아닌 경우에만' 허용하는 정규표현식	! (0-9)	String REGEXP_PATTERN_NO_NUMBER = "^[\\D]*$";
\\s	'공백 문자, 탭만'을 허용만 정규 표현식	(space, tabe, newline)	String REGEXP_PATTERN_SPACE_CHAR = "^[\\s]*$";
\\S	'공백 문자, 탭이 아닌 경우에만' 허용하는 정규표현식	! (space, tabe, newline)	String REGEXP_PATTERN_SPACE_NO_CHAR = "^[\\s]*$";

Character classes - JavaScript | MDN

Character classes distinguish kinds of characters such as, for example, distinguishing between letters and digits.

developer.mozilla.org

1.2. 어설션(Assertions)

💡 어선션(Assertions)

- 행이나 단어의 시작 · 끝을 나타내는 경계와 (앞, 뒤 읽고 조건식을 포함한) 어떤 식으로든 매치가 가능한 것을 나타내는 다른 패턴이 포함됩니다.

정규식 패턴	설명	예제
^	문장의 시작 (특정 문자열로 시작)	String regExp = “^www”;
$	문장의 끝 (특정 문자열로 끝남)	String regExp = “com$”;

Assertions - JavaScript | MDN

Assertions에는 행이나 단어의 시작 · 끝을 나타내는 경계와 (앞, 뒤 읽고 조건식을 포함한) 어떤 식 으로든 매치가 가능한 것을 나타내는 다른 패턴이 포함됩니다.

developer.mozilla.org

[ 더 알아보기 ]

💡반복은 무엇을 의미하는 걸까?

- 특정 패턴이 연속해서 나타나는 것을 의미합니다. 이는 문자, 문자 집합, 또는 그룹이 여러 번 출현하는 경우를 나타냅니다.

- 예를 들어서 "^[\\d]*$" 형태로 숫자만 허용하는 정규식을 구성했다고 가정하면 userNum1 = "4321";를 정규식을 테스트하려고 할 때는, 모든 문자에 대해서 반복하여 숫자임을 판단하기에 true라는 값을 반환합니다.
- 그러나 “^[\\d]$”를 정규식으로 구성하고 수행했을 때는 false의 값을 반환합니다. 이유는 1개의 단어(4)에 대해서만 정규식을 수행하기 때문입니다.

1.3. 수량자(Quantifiers)

💡 수량자(Quantifiers)

- 일치시킬 문자 또는 표현식의 수를 의미합니다.

정규식 패턴	설명	반복 여부
?	없거나 있거나 (zero or one)	0회 또는 1회 반생
*	없거나 있거나 많거나 (zero or more)	0회 이상 반복
+	하나 또는 많이 (one or more)	0회 또는 1회 반복
{n}	n개가 있는	정확히 n번 반복
{min,}	최소	n번 이상 반복
{min, max}	최소, 그리고 최대	n번 이상 m번 이하 반복

Quantifiers - JavaScript | MDN

Quantifiers indicate numbers of characters or expressions to match.

developer.mozilla.org

1.4. 그룹과 범위(Group and Range)

💡그룹과 범위(Group and Range)

- 정규식 문법을 그룹화하거나 범위를 지정할 때 사용하는 패턴입니다.

정규식 패턴	설명
()	그룹
[]	문자셋, 괄호안의 어떤 문자든
[^]	부정 문자셋, 괄호안의 어떤 문자가 아닐때
(?:)	찾지만 기억하지는 않음

[참고] MDN - 설명이 잘되어 있는 API 문서

Groups and Ranges - JavaScript | MDN

그룹(Groups)과 범위(ranges)는 표현 문자의 그룹과 범위를 나타냅니다.

developer.mozilla.org

2) 정규식을 위한 정규 메서드

💡 정규식을 위한 정규 메서드

- 해당 정규식을 기반으로 유효성 검증을 수행을 할지 아니면 치환을 할지에 대해서 정합니다.

1. Pattern Class

💡 Pattern Class

- 해당 java.util.rege.Pattern 클래스는 import 하여서 정규식을 기반으로 문자열에 대한 검증을 수행합니다.

메서드	설명
Pattern.matcher(String regex, CharSequence input)	대상이 되는 문자열과 정규식이 일치하는 경우 true, 아닌 경우 false를 반환합니다.
Pattern.pattern()	컴파일된 정규표현식을 String 형태로 반환합니다.
Pattern.compile(String regex)	컴파일된 정규 표현식을 반환해줍니다.
Pattern.asPredicate()	문자열을 일치시키는 데 사용할 수있는 술어를 작성합니다.
Pattern.split(CharSequence input)	문자열을 주어진 인자값 CharSequence 패턴에 따라 분리합니다.

/*
 * 1. Pattern - matches() 메서드를 이용한 예시
 */
String userNum1 = "1234";
String userNum2 = "U1234";
String REGEXP_ONLY_NUM = "^[\\d]*$";

boolean isNumber1 = Pattern.matches(REGEXP_ONLY_NUM, userNum1);
boolean isNumber2 = Pattern.matches(REGEXP_ONLY_NUM, userNum2);

2. Matcher Class

💡 Matcher Class

- import java.util.regex.Matcher를 import 하여서 문자열 내에 일치하는 문자열을 확인하기 위해 “정규식” 이용하여 찾고 존재여부를 반환해 주는 함수입니다.

메서드	설명
matches()	대상 문자열과 패턴이 일치할 경우 true 반환합니다.
find()	대상 문자열과 패턴이 일치하는 경우 true를 반환하고, 그 위치로 이동합니다.
find(int start)	start위치 이후부터 매칭검색을 수행합니다.
start()	매칭되는 문자열 시작위치 반환합니다.
start(int group)	지정된 그룹이 매칭되는 시작위치 반환합니다.
end()	매칭되는 문자열 끝 다음 문자위치 반환합니다.
end(int group)	지정되 그룹이 매칭되는 끝 다음 문자위치 반환합니다.
group()	매칭된 부분을 반환합니다.
group(int group)	매칭된 부분중 group번 그룹핑 매칭부분 반환합니다.
groupCount()	패턴내 그룹핑한(괄호지정) 전체 갯수를 반환합니다.

/*
 * 2. Matcher - compile() & matcher
 */

String userNum1 = "1234";
String userNum2 = "U1234";
String REGEXP_ONLY_NUM = "^[\\d]*$";

boolean pattern1 = Pattern.compile(REGEXP_ONLY_NUM).matcher(userNum1).find();
boolean pattern2 = Pattern.compile(REGEXP_ONLY_NUM).matcher(userNum1).find();

3. replaceAll Class

💡 replaceAll Class

- 해당 함수는 문자열 내에 포함이 되어있는 문자를 제거 혹은 대체하기 위해 정규식을 이용하여 찾고 치환을 해주는 함수입니다.
- 문자열(String) 형태의 정규식과 변환하려는 문자열(String)을 파라미터로 넣고 변환한 값을 문자열(String)로 반환받습니다.

// API 
public String replaceAll(String regex, String replacement) {
    return Pattern.compile(regex).matcher(this).replaceAll(replacement);
}

String replaceAllStr = "A.B.C.D.E.F";
String removeDot = replaceAllStr.replaceAll("\\.", "");     // ABCDEF
String chageDotToHypen = replaceAllStr.replaceAll("\\.", "-");    // A-B-C-D-E-F

3) 문자 클래스를 이용한 정규식 사용 예시

1. 문자 클래스를 이용(\w, \W) - 문자열에 대한 정규식 수행

정규식 패턴	설명
*"^[\\w]$"**	문자열만 허용하는 정규식 - 공백 미 허용
*"^[\\W]$"**	문자열만 허용하는 정규식 - 공백 허용

// 1. 문자열만 허용하는 정규식 - 공백 미 허용
public static final String REGEXP_PATTERN_CHAR = "^[\\w]*$";

// 2. 문자열만 허용하는 정규식 - 공백 허용
public static final String REGEXP_PATTERN_NO_CHAR = "^[\\W]*$";

String str1 = "hellow";         // 문자열로만 구성
String str2 = "hellow23";       // 문자열과 숫자로 구성
String str3 = "안녕하세요 :D";     // 문자열과 특수문자로 구성
String tabStr = "hellow    ";   // 탭이 포함된 문자열
String spaceStr = "hellow ";    // 스페이스바가 포함된 문자열

/*
 * 문자열 [(a-z, A-Z, 0-9, …)]이 맞는지에 대한 정규식을 수행합니다. (탭, 공백 허용 X)
 * "^[\\w]*$" 정규식 패턴을 사용
 */
boolean isCheckStr1 = Pattern.matches(REGEXP_PATTERN_CHAR, str1);               // true
boolean isCheckStr2 = Pattern.matches(REGEXP_PATTERN_CHAR, str2);               // true
boolean isCheckStr3 = Pattern.matches(REGEXP_PATTERN_CHAR, str3);               // false
boolean isCheckStr4 = Pattern.matches(REGEXP_PATTERN_CHAR, tabStr);             // false
boolean isCheckStr5 = Pattern.matches(REGEXP_PATTERN_CHAR, spaceStr);           // false

/*
 * 문자열이 아닌지 [!(a-z, A-Z, 0-9, …)]에 대햔 정규식을 수행합니다.(탭, 공백 허용 X)
 * "^[\\W]*$" 정규식 패턴을 사용
 */
boolean isCheckNonStr1 = Pattern.matches(REGEXP_PATTERN_NO_CHAR, str1);         // false
boolean isCheckNonStr2 = Pattern.matches(REGEXP_PATTERN_NO_CHAR, str2);         // false
boolean isCheckNonStr3 = Pattern.matches(REGEXP_PATTERN_NO_CHAR, str3);         // false
boolean isCheckNonStr4 = Pattern.matches(REGEXP_PATTERN_NO_CHAR, tabStr);       // false
boolean isCheckNonStr5 = Pattern.matches(REGEXP_PATTERN_NO_CHAR, spaceStr);     // false

2. 문자 클래스 이용(\d, \D) - 숫자에 대한 정규식 수행

정규식 패턴	설명
*"^[\\d]$"**	숫자만 허용하는 정규식
*"^[\\D]$"**	숫자가 아닌 경우 허용하는 정규식

// 3. 숫자만 허용하는 정규식
public static final String REGEXP_PATTERN_NUMBER = "^[\\d]*$";

// 4. 숫자가 아닌 경우 허용하는 정규식
public static final String REGEXP_PATTERN_NO_NUMBER = "^[\\D]*$";

String intString1 = "1234";           // 숫자로만 구성
String intString2 = "1234AD";         // 숫자와 문자로 구성
String intString3 = "1234   ";        // 숫자와 탭의 조합으로 구성

/*
 * 숫자 [(0-9)]가 맞는지에 대한 정규식을 수행합니다. (탭, 공백 허용 X)
 * "^[\\d]*$" 정규식 패턴을 사용
 */
boolean isCheckNumber1 = Pattern.matches(REGEXP_PATTERN_NUMBER, intString1);                // true
boolean isCheckNumber2 = Pattern.matches(REGEXP_PATTERN_NUMBER, intString2);                // false
boolean isCheckNumber3 = Pattern.matches(REGEXP_PATTERN_NUMBER, intString3);                // false

/*
 * 숫자 [!(0-9)]가 맞는지에 대한 정규식을 수행합니다. (탭, 공백 허용 X)
 * "^[\\D]*$" 정규식 패턴을 사용
 */
boolean isCheckNonNumber1 = Pattern.matches(REGEXP_PATTERN_NO_NUMBER, intString1);          // false
boolean isCheckNonNumber2 = Pattern.matches(REGEXP_PATTERN_NO_NUMBER, intString2);          // false
boolean isCheckNonNumber3 = Pattern.matches(REGEXP_PATTERN_NO_NUMBER, intString3);          // false

3. 문자 클래스 이용(\s, \S) - 공백과 탭에 대한 정규식 수행

정규식 패턴	설명
*"^[\\s]$"**	공백, 탭을 허용하는 정규식
*"^[\\S]$"**	공백, 탭이 아닌 경우를 허용하는 정규식

// 5. 공백, 탭을 허용하는 정규식
public static final String REGEXP_PATTERN_SPACE_CHAR = "^[\\s]*$";

// 6. 공백, 탭이 아닌 경우를 허용하는 정규식
public static final String REGEXP_PATTERN_SPACE_NO_CHAR = "^[\\S]*$";

String normalString = "공백/스페이스 테스트";        // 문자열로만 구성
String spaceString = "공백/스페이스 테스트     ";    // 문자열과 스페이스로 구성
String tabString = "공백/스페이스 테스트        ";   // 문자열과 탭으로 구성
String onlySpace = "  ";                        // 스페이스만으로 구성
String onlyTab = "  ";                          // 탭으로만 구성

/*
 * 공백과 탭으로만 구성되어 있는지에 대한 정규식을 수행합니다.
 * "^[\\s]*$" 정규식 패턴을 사용
 */
boolean isCheckSpaceTabStr1 = Pattern.matches(REGEXP_PATTERN_SPACE_CHAR, normalString);     // false
boolean isCheckSpaceTabStr2 = Pattern.matches(REGEXP_PATTERN_SPACE_CHAR, spaceString);      // false
boolean isCheckSpaceTabStr3 = Pattern.matches(REGEXP_PATTERN_SPACE_CHAR, tabString);        // false
boolean isCheckSpaceTabStr4 = Pattern.matches(REGEXP_PATTERN_SPACE_CHAR, onlySpace);        // true
boolean isCheckSpaceTabStr5 = Pattern.matches(REGEXP_PATTERN_SPACE_CHAR, onlyTab);          // true

/*
 * 공백과 탭으로만 구성되어 있지 아닌지에 대한 정규식을 수행합니다,
 * "^[\\S]*$" 정규식 패턴을 사용
 */
boolean isCheckNonSpaceTabStr1 = Pattern.matches(REGEXP_PATTERN_SPACE_NO_CHAR, normalString);       // true
boolean isCheckNonSpaceTabStr2 = Pattern.matches(REGEXP_PATTERN_SPACE_NO_CHAR, spaceString);        // false
boolean isCheckNonSpaceTabStr3 = Pattern.matches(REGEXP_PATTERN_SPACE_NO_CHAR, tabString);          // false
boolean isCheckNonSpaceTabStr4 = Pattern.matches(REGEXP_PATTERN_SPACE_NO_CHAR, onlySpace);          // false
boolean isCheckNonSpaceTabStr5 = Pattern.matches(REGEXP_PATTERN_SPACE_NO_CHAR, onlyTab);            // false

4) 사용자 정의에 따른 정규식 사용 예시

1. 문자열에 대한 상세 정규식

정규식 패턴	설명
*"^[a-z\|A-Z]$"**	대소구분 없는 영문만 허용하는 정규식
*"^[a-z]$"**	소문자만 허용하는 정규식
*"^[A-Z]$"**	대문자만 허용하는 정규식
*"^[ㄱ-ㅎ\|가-힣]$"**	한글만 허용하는 정규식
*"^[a-z\|A-Z\|ㄱ-ㅎ\|가-힣]$"**	대소구분 없는 영문과 한글만 허용하는 정규식
*"^[a-z\|A-Z\|ㄱ-ㅎ\|가-힣\| ]$"**	대소구분 없는 영문과 한글만 허용하는 정규식 (스페이스바 포함)
*"^[0-9a-zA-Zㄱ-ㅎ가-힣]$";**	대소구분 없는 영문과 한글만 허용하는 정규식
*"^[0-9a-zA-Zㄱ-ㅎ가-힣 ]$";**	대소구분 없는 영문과 한글, 숫자를 허용하는 정규식(스페이스바 포함)

/**
 * [정규식 모음-2] '문자열'에 대한 정규식
 */
// 1. 대소구분 없는 영문만 허용하는 정규식
public static final String REGEXP_EN = "^[a-z|A-Z]*$";

// 2. 소문자만 허용하는 정규식
public static final String REGEXP_LOWER_CASE = "^[a-z]*$";

// 3. 대문자만 허용하는 정규식
public static final String REGEXP_UPPER_CASE = "^[A-Z]*$";

// 4. 한글만 허용하는 정규식
public static final String REGEXP_KR = "^[ㄱ-ㅎ|가-힣]*$";

// 5. 대소구분 없는 영문과 한글만 허용하는 정규식
public static final String REGEXP_ONLY_CHAR = "^[a-z|A-Z|ㄱ-ㅎ|가-힣]*$";
public static final String REGEXP_ONLY_SPACE_CHAR = "^[a-z|A-Z|ㄱ-ㅎ|가-힣| ]*$";

// 6. 대소구분 없는 영문과 한글, 숫자를 허용하는 정규식
public static final String REGEXP_CHAR_NUM = "^[0-9a-zA-Zㄱ-ㅎ가-힣]*$";
public static final String REGEXP_CHAR_SPACE_NUM = "^[0-9a-zA-Zㄱ-ㅎ가-힣 ]*$";

/*
 * 대소문자의 알파벳만 허용합니다.(공백 허용 X)
 * "^[a-z|A-Z]*$" 정규식 패턴 사용
 */
boolean isEngStr1 = Pattern.matches(REGEXP_EN, "adJh");         // true
boolean isEngStr2 = Pattern.matches(REGEXP_EN, "adJh54");       // false

/*
 * 소문자의 허용합니다.(공백 허용 X)
 * "^[a-z]*$" 정규식 패턴 사용
 */
boolean isEngLowerCaseStr1 = Pattern.matches(REGEXP_LOWER_CASE, "adjh");       // true
boolean isEngLowerCaseStr2 = Pattern.matches(REGEXP_LOWER_CASE, "ADJH");       // false

/*
 *  대문자만 허용합니다.(공백 허용 X)
 * "^[A-Z]*$" 정규식 패턴 사용
 */
boolean isEngUpperCaseStr1 = Pattern.matches(REGEXP_UPPER_CASE, "adjh");       // false
boolean isEngUpperCaseStr2 = Pattern.matches(REGEXP_UPPER_CASE, "ADJH");       // true

/*
 * 한글만 허용합니다.(공백 허용 X)
 * "^[ㄱ-ㅎ|가-힣]*$" 정규식 패턴 사용
 */
boolean isKorStr1 = Pattern.matches(REGEXP_KR, "반갑습니다");    // true
boolean isKorStr2 = Pattern.matches(REGEXP_KR, "adJh");       // false

/*
 * 숫자와 특수문자를 제외한 문자만 허용합니다(공백 허용 X)
 * "^[a-z|A-Z|ㄱ-ㅎ|가-힣]*$" 정규식 패턴 사용
 */
boolean isNonSpecialChar1 = Pattern.matches(REGEXP_ONLY_CHAR, "반갑습니다adjh님");            // true
boolean isNonSpecialChar2 = Pattern.matches(REGEXP_ONLY_CHAR, "반갑습니다^^");               // false
boolean isNonSpecialChar3 = Pattern.matches(REGEXP_ONLY_CHAR, "반갑습니다 adjh님");           // false

/*
 * 숫자와 특수문자를 제외한 문자만 허용합니다(공백 허용 O)
 * "^[0-9a-zA-Zㄱ-ㅎ가-힣]*$" 정규식 패턴 사용
 */
boolean isNonSpecialCharSpace1 = Pattern.matches(REGEXP_ONLY_SPACE_CHAR, "반갑습니다adjh님");       // true
boolean isNonSpecialCharSpace2 = Pattern.matches(REGEXP_ONLY_SPACE_CHAR, "반갑습니다^^");          // false
boolean isNonSpecialCharSpace3 = Pattern.matches(REGEXP_ONLY_SPACE_CHAR, "반갑습니다 adjh님");      // true

/*
 * 특수문자를 제외한 문자만 허용합니다(공백 허용 X, 숫자 허용 O)
 * "^[0-9a-zA-Zㄱ-ㅎ가-힣]*$" 정규식 패턴 사용
 */
boolean isOnlyNonSpecialChar1 = Pattern.matches(REGEXP_CHAR_NUM, "반갑습니다adjh54님");          // true
boolean isOnlyNonSpecialChar2 = Pattern.matches(REGEXP_CHAR_NUM, "반갑습니다^^");               // false
boolean isOnlyNonSpecialChar3 = Pattern.matches(REGEXP_CHAR_NUM, "반갑습니다 adjh54님");         // false

/*
 * 특수문자를 제외한 문자만 허용합니다(공백 허용 O, 숫자 허용 O)
 * "^[0-9a-zA-Zㄱ-ㅎ가-힣 ]*$" 정규식 패턴 사용
 */
boolean isOnlyNonSpecialCharSpace1 = Pattern.matches(REGEXP_CHAR_SPACE_NUM, "반갑습니다adjh54님");          // true
boolean isOnlyNonSpecialCharSpace2 = Pattern.matches(REGEXP_CHAR_SPACE_NUM, "반갑습니다^^");               // false
boolean isOnlyNonSpecialCharSpace3 = Pattern.matches(REGEXP_CHAR_SPACE_NUM, "반갑습니다 adjh54님");         // true

2. 사용자 정보 대한 상세 정규식

💡 회원가입 및 사용자 정보에 관련된 정규식입니다.

정규식 패턴	설명
"^[a-zA-Z0-9]+@[0-9a-zA-Z]+\\.[a-z]$"	사용자 이메일에 대한 정규식
*"^[0-9a-zA-Z]([-_\\.]?[0-9a-zA-Z])@[0-9a-zA-Z]([-_\\.]?[0-9a-zA-Z])\\.[a-zA-Z]{2,3}$"*	사용자 이메일에 대한 정규식 - 언더바(_), 하이픈(-) 포함 및 길이 지정
"^[a-z]{1}[a-z0-9]{5,10}$"	사용자 아이디에 대한 정규식 - 영문 숫자 조합 6~10자리
*"^(?=.[a-zA-Z])((?=.\\d)\|(?=.\\W)).{10,128}$";**	사용자 패스워드에 대한 정규식 - 대소문자 + 숫자 + 특수문자 조합으로 10 ~ 128자리로 정의 한다.
"^[\\d]{11}$";	핸드폰 번호 타입1에 대한 정규식 => ex) 01012345678
"^01([0\|1\|6\|7\|8\|9])-([0-9]{3,4})-([0-9]{4})$"	핸드폰 번호 타입2에 대한 정규식-1 => ex) 010-1234-5678
"^[\\d]{2,3}-[\\d]{3,4}-[\\d]{4}$"	핸드폰 번호 타입2에 대한 정규식-2 => ex) 010-1234-5678
"^\\+82-01([0\|1\|6\|7\|8\|9])-([\\d]{3,4})-([\\d]{4})$"	핸드폰 번호 타입3에 대한 정규식 => ex) +82-010-1234-5678
"^\\+82-10-([\\d]{3,4})-([\\d]{4})$"	핸드폰 번호 타입4에 대한 정규식 => ex) +82-10-1234-5678
"^[\\d]{6}-[1-4][\\d]{6}$"	주민등록번호 타입에 대한 정규식
"^[\\d]{3}-[\\d]{2}$"	우편 번호에 대한 정규식

/**
 * [정규식 모음-4] 사용자 정보 관련 정규식
 */
// 1. 사용자 이메일에 대한 정규식
public static final String REGEXP_LIGHT_USER_EMAIL = "^[a-zA-Z0-9]+@[0-9a-zA-Z]+\\.[a-z]+$";  // 언더바(_), 하이픈(-) 제외
public static final String REGEXP_TIGHT_USER_EMAIL = "^[0-9a-zA-Z]([-_\\.]?[0-9a-zA-Z])*@[0-9a-zA-Z]([-_\\.]?[0-9a-zA-Z])*\\.[a-zA-Z]{2,3}$"; // 언더바(_), 하이픈(-) 포함 및 길이 지정

// 2. 사용자 아이디에 대한 정규식 - 영문 숫자 조합 6~10자리
public static final String REGEXP_USER_ID = "^[a-z]{1}[a-z0-9]{5,10}$";

// 3. 사용자 패스워드에 대한 정규식 - 대소문자 + 숫자 + 특수문자 조합으로 10 ~ 128자리로 정의 한다.
public static final String REGEXP_USER_PW_TYPE1 = "^(?=.*[a-zA-Z])((?=.*\\d)|(?=.*\\W)).{10,128}$";

// 4. 핸드폰 번호 타입1에 대한 정규식 => ex) 01012345678
public static final String REGEXP_PHONE_TYPE1 = "^[\\d]{11}$";

// 5. 핸드폰 번호 타입2에 대한 정규식 => ex) 010-1234-5678
public static final String REGEXP_PHONE_TYPE2_1 = "^01([0|1|6|7|8|9])-([0-9]{3,4})-([0-9]{4})$";
public static final String REGEXP_PHONE_TYPE2_2 = "^[\\d]{2,3}-[\\d]{3,4}-[\\d]{4}$";

// 6. 핸드폰 번호 타입3에 대한 정규식 => ex) +82-010-1234-5678
public static final String REGEXP_PHONE_TYPE3 = "^\\+82-01([0|1|6|7|8|9])-([\\d]{3,4})-([\\d]{4})$";

// 7. 핸드폰 번호 타입4에 대한 정규식 => ex) +82-10-1234-5678
public static final String REGEXP_PHONE_TYPE4 = "^\\+82-10-([\\d]{3,4})-([\\d]{4})$";

// 8. 주민등록번호 타입에 대한 정규식
public static final String REGEXP_REGISTRATION_NUM = "^[\\d]{6}-[1-4][\\d]{6}$";

// 9. 우편 번호에 대한 정규식
public static final String REGEXP_POSTAL_CODE = "^[\\d]{3}-[\\d]{2}$";


/*
 * 사용자 이메일 형태 유효성 검증-1 : 아이디 내에 언더바(_), 하이픈(-) 제외
 * "^[a-zA-Z0-9]+@[0-9a-zA-Z]+\.[a-z]$" 정규식 패턴 사용
 */
boolean isValidType1UserEmail1 = Pattern.matches(REGEXP_LIGHT_USER_EMAIL, "adjh54@naver.com");      // true
boolean isValidType1UserEmail2 = Pattern.matches(REGEXP_LIGHT_USER_EMAIL, "adjh_54@naver.com");     // false
boolean isValidType1UserEmail3 = Pattern.matches(REGEXP_LIGHT_USER_EMAIL, "adjh&&@naver.com");      // false

/*
 * 사용자 이메일 형태 유효성 검증-2 : 아이디 내에 언더바(_), 하이픈(-) 포함
 * "^[0-9a-zA-Z]([-_\.]?[0-9a-zA-Z])*@[0-9a-zA-Z]([-_\.]?[0-9a-zA-Z])*\.[a-zA-Z]{2,3}$" 정규식 패턴 사용
 */
boolean isValidType2UserEmail1 = Pattern.matches(REGEXP_TIGHT_USER_EMAIL, "adjh54@naver.com");      // true
boolean isValidType2UserEmail2 = Pattern.matches(REGEXP_TIGHT_USER_EMAIL, "adjh_54@naver.com");     // true
boolean isValidType2UserEmail3 = Pattern.matches(REGEXP_TIGHT_USER_EMAIL, "adjh^^_54@naver.com");   // false


/*
 * 사용자 아이디에 대한 정규식 - 영문 숫자 조합 6~10자리
 * "^[a-z]{1}[a-z0-9]{5,10}$" 정규식 패턴
 */
boolean isValidUserId1 = Pattern.matches(REGEXP_USER_ID, "adjh54");     // true
boolean isValidUserId2 = Pattern.matches(REGEXP_USER_ID, "adjh");       // false
boolean isValidUserId3 = Pattern.matches(REGEXP_USER_ID, "adjh_54");    // false
boolean isValidUserId4 = Pattern.matches(REGEXP_USER_ID, "Adjh54");     // false
boolean isValidUserId5 = Pattern.matches(REGEXP_USER_ID, "12adjh54");   // false


/*
 * 사용자 패스워드에 대한 정규식 - 대소문자 + 숫자 + 특수문자 조합으로 10 ~ 128자리로 정의 한다.
 * "^[a-z]{1}[a-z0-9]{5,10}$" 정규식 패턴
 */
boolean isValidUserPw1 = Pattern.matches(REGEXP_USER_PW_TYPE1, "qwer123456");     // true
boolean isValidUserPw2 = Pattern.matches(REGEXP_USER_PW_TYPE1, "qwer1234!!");     // true
boolean isValidUserPw3 = Pattern.matches(REGEXP_USER_PW_TYPE1, "Qwer1234!!");     // true
boolean isValidUserPw4 = Pattern.matches(REGEXP_USER_PW_TYPE1, "패스워드!123");     // false

/*
 * 핸드폰 번호 타입1에 대한 정규식 => ex) 01023205454
 */
boolean isValidType1UserPhone1 = Pattern.matches(REGEXP_PHONE_TYPE1, "01912345678");            // true
boolean isValidType1UserPhone2 = Pattern.matches(REGEXP_PHONE_TYPE1, "019123456789");           // false
boolean isValidType1UserPhone3 = Pattern.matches(REGEXP_PHONE_TYPE2_1, "019-1234-5678");        // true
boolean isValidType1UserPhone4 = Pattern.matches(REGEXP_PHONE_TYPE2_1, "019-1234-5678");        // true
boolean isValidType1UserPhone5 = Pattern.matches(REGEXP_PHONE_TYPE2_2, "019-1234-5678");        // true
boolean isValidType1UserPhone6 = Pattern.matches(REGEXP_PHONE_TYPE3, "+82-019-1234-5678");      // true
boolean isValidType1UserPhone7 = Pattern.matches(REGEXP_PHONE_TYPE4, "+82-10-1234-5678");       // true

boolean isValidRegistrationCode = Pattern.matches(REGEXP_REGISTRATION_NUM, "123456-1234567");   // true
boolean isValidPostalCode = Pattern.matches(REGEXP_POSTAL_CODE, "123-45");                      // true

3. 기타 날짜와 시간에 대한 상세 정규식

정규식 패턴	설명
"^[\\d]{4}-(0[1-9]\|1[012])-(0[1-9]\|[12][0-9]\|3[01])$"	날짜에 대한 타입1에 대한 정규식 => ex) 2022-08-03 (YYYY-MM-DD)
"^[\\d]{4}]\\/(0[1-9]\|1[012])\\/(0[1-9]\|[12][0-9]\|3[01])$"	날짜에 대한 타입2에 대한 정규식 => ex) 2022/08/03 (YYYY/MM/DD)
"^[\\d]{4}\\.(0[1-9]\|1[012])\\.(0[1-9]\|[12][0-9]\|3[01])$"	날짜에 대한 타입에 대한 정규식 => ex) 2022.08.03 (YYYY.MM.DD)
"^(19\|20)[\\d]{2}-(0[1-9]\|1[012])-(0[1-9]\|[12][0-9]\|3[01])$"	날짜에 대한 정규식 => 19xx 20xx년도에 대해서 추가함 -- 강력하게 유효성 검증
"([0-2][0-9]{3})\\/([0-1][0-9])\\/([0-3][0-9]) ([0-5][0-9]):([0-5][0-9]):([0-5][0-9])(([\\-\\+]([0-1][0-9])\\:00))?";	날짜에 대한 정규식 - YYYY/MM/DD hh:mi:ss
"^([1-9]\|[01][0-9]\|2[0-3]):([0-5][0-9])$"	시간에 대한 타입1에 대한 정규식 => ex) 13:47(HH24:mm)

/**
 * [정규식 모음-5] 날짜에 대한 정규식
 */
// [Soft] 날짜에 대한 타입1에 대한 정규식 => ex) 2022-08-03 (YYYY-MM-DD)
public static final String REGEXP_DATE_TYPE1 = "^[\\d]{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$";

// [Soft] 날짜에 대한 타입2에 대한 정규식 => ex) 2022/08/03 (YYYY/MM/DD)
public static final String REGEXP_DATE_TYPE2 = "^[\\d]{4}]\\/(0[1-9]|1[012])\\/(0[1-9]|[12][0-9]|3[01])$";

// [Soft] 날짜에 대한 타입에 대한 정규식 => ex) 2022.08.03 (YYYY.MM.DD)
public static final String REGEXP_DATE_TYPE3 = "^[\\d]{4}\\.(0[1-9]|1[012])\\.(0[1-9]|[12][0-9]|3[01])$";

// [Hard] 날짜에 대한 정규식 => 19xx 20xx년도에 대해서 추가함 -- 강력하게 유효성 검증
public static final String REGEXP_DATE_TYPE4 = "^(19|20)[\\d]{2}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$";

// 날짜에 대한 정규식 - YYYY/MM/DD hh:mi:ss
public static final String REGEXP_DATE_TYPE5 =
        "([0-2][0-9]{3})\\/([0-1][0-9])\\/([0-3][0-9]) ([0-5][0-9]):([0-5][0-9]):([0-5][0-9])(([\\-\\+]([0-1][0-9])\\:00))?";

/**
 * [정규식 모음-6] 시간에 대한 정규식
 */
// 시간에 대한 타입1에 대한 정규식 => ex) 13:47(HH24:mm)
public static final String REGEXP_TIME_TYPE1 = "^([1-9]|[01][0-9]|2[0-3]):([0-5][0-9])$";

5) 최종 공유 - 정규식에 사용되는 RegExpConstants.java

💡 위에서 정리한 내용의 종합 내용입니다.

정규식 패턴	설명
*"^[\\w]$"**	문자열만 허용하는 정규식 - 공백 미 허용
*"^[\\W]$"**	문자열만 허용하는 정규식 - 공백 허용
*"^[\\d]$"**	숫자만 허용하는 정규식
*"^[\\D]$"**	숫자가 아닌 경우 허용하는 정규식
*"^[\\s]$"**	공백, 탭을 허용하는 정규식
*"^[\\S]$"**	공백, 탭이 아닌 경우를 허용하는 정규식
*"^[a-z\|A-Z]$"**	대소구분 없는 영문만 허용하는 정규식
*"^[a-z]$"**	소문자만 허용하는 정규식
*"^[A-Z]$"**	대문자만 허용하는 정규식
*"^[ㄱ-ㅎ\|가-힣]$"**	한글만 허용하는 정규식
*"^[a-z\|A-Z\|ㄱ-ㅎ\|가-힣]$"**	대소구분 없는 영문과 한글만 허용하는 정규식
*"^[a-z\|A-Z\|ㄱ-ㅎ\|가-힣\| ]$"**	대소구분 없는 영문과 한글만 허용하는 정규식 (스페이스바 포함)
*"^[0-9a-zA-Zㄱ-ㅎ가-힣]$";**	대소구분 없는 영문과 한글만 허용하는 정규식
*"^[0-9a-zA-Zㄱ-ㅎ가-힣 ]$";**	대소구분 없는 영문과 한글, 숫자를 허용하는 정규식(스페이스바 포함)
"^[a-zA-Z0-9]+@[0-9a-zA-Z]+\\.[a-z]+$"	사용자 이메일에 대한 정규식
*"^[0-9a-zA-Z]([-_\\.]?[0-9a-zA-Z])@[0-9a-zA-Z]([-_\\.]?[0-9a-zA-Z])\\.[a-zA-Z]{2,3}$"*	사용자 이메일에 대한 정규식 - 언더바(_), 하이픈(-) 포함 및 길이 지정
"^[a-z]{1}[a-z0-9]{5,10}$"	사용자 아이디에 대한 정규식 - 영문 숫자 조합 6~10자리
*"^(?=.[a-zA-Z])((?=.\\d)\|(?=.\\W)).{10,128}$";**	사용자 패스워드에 대한 정규식 - 대소문자 + 숫자 + 특수문자 조합으로 10 ~ 128자리로 정의 한다.
"^[\\d]{11}$";	핸드폰 번호 타입1에 대한 정규식 => ex) 01012345678
"^01([0\|1\|6\|7\|8\|9])-([0-9]{3,4})-([0-9]{4})$"	핸드폰 번호 타입2에 대한 정규식-1 => ex) 010-1234-5678
"^[\\d]{2,3}-[\\d]{3,4}-[\\d]{4}$"	핸드폰 번호 타입2에 대한 정규식-2 => ex) 010-1234-5678
"^\\+82-01([0\|1\|6\|7\|8\|9])-([\\d]{3,4})-([\\d]{4})$"	핸드폰 번호 타입3에 대한 정규식 => ex) +82-010-1234-5678
"^\\+82-10-([\\d]{3,4})-([\\d]{4})$"	핸드폰 번호 타입4에 대한 정규식 => ex) +82-10-1234-5678
"^[\\d]{6}-[1-4][\\d]{6}$"	주민등록번호 타입에 대한 정규식
"^[\\d]{3}-[\\d]{2}$"	우편 번호에 대한 정규식
"^[\\d]{4}-(0[1-9]\|1[012])-(0[1-9]\|[12][0-9]\|3[01])$"	날짜에 대한 타입1에 대한 정규식 => ex) 2022-08-03 (YYYY-MM-DD)
"^[\\d]{4}]\\/(0[1-9]\|1[012])\\/(0[1-9]\|[12][0-9]\|3[01])$"	날짜에 대한 타입2에 대한 정규식 => ex) 2022/08/03 (YYYY/MM/DD)
"^[\\d]{4}\\.(0[1-9]\|1[012])\\.(0[1-9]\|[12][0-9]\|3[01])$"	날짜에 대한 타입에 대한 정규식 => ex) 2022.08.03 (YYYY.MM.DD)
"^(19\|20)[\\d]{2}-(0[1-9]\|1[012])-(0[1-9]\|[12][0-9]\|3[01])$"	날짜에 대한 정규식 => 19xx 20xx년도에 대해서 추가함 -- 강력하게 유효성 검증
"([0-2][0-9]{3})\\/([0-1][0-9])\\/([0-3][0-9]) ([0-5][0-9]):([0-5][0-9]):([0-5][0-9])(([\\-\\+]([0-1][0-9])\\:00))?";	날짜에 대한 정규식 - YYYY/MM/DD hh:mi:ss
"^([1-9]\|[01][0-9]\|2[0-3]):([0-5][0-9])$"	시간에 대한 타입1에 대한 정규식 => ex) 13:47(HH24:mm)

package com.adjh.multiflexapi.common.codes.constans;

/**
 * 정규식 모음을 관리하는 상수 페이지 입니다.
 *
 * @author : jonghoon
 * @fileName : RegExpConstants
 * @since : 2023/01/16
 */
public class RegExpConstants {

    /**
     * [정규식 모음-1] 패턴을 이용한 정규식
     */
    // 1. 문자열만 허용하는 정규식 - 공백 미 허용
    public static final String REGEXP_PATTERN_CHAR = "^[\\w]*$";

    // 2. 문자열만 허용하는 정규식 - 공백 허용
    public static final String REGEXP_PATTERN_NO_CHAR = "^[\\W]*$";

    // 3. 숫자만 허용하는 정규식
    public static final String REGEXP_PATTERN_NUMBER = "^[\\d]*$";

    // 4. 숫자가 아닌 경우 허용하는 정규식
    public static final String REGEXP_PATTERN_NO_NUMBER = "^[\\D]*$";

    // 5. 공백, 탭을 허용하는 정규식
    public static final String REGEXP_PATTERN_SPACE_CHAR = "^[\\s]*$";

    // 6. 공백, 탭이 아닌 경우를 허용하는 정규식
    public static final String REGEXP_PATTERN_SPACE_NO_CHAR = "^[\\S]*$";


    /**
     * [정규식 모음-2] '문자열'에 대한 정규식
     */
    // 1. 대소구분 없는 영문만 허용하는 정규식
    public static final String REGEXP_EN = "^[a-z|A-Z]*$";

    // 2. 소문자만 허용하는 정규식
    public static final String REGEXP_LOWER_CASE = "^[a-z]*$";

    // 3. 대문자만 허용하는 정규식
    public static final String REGEXP_UPPER_CASE = "^[A-Z]*$";

    // 4. 한글만 허용하는 정규식
    public static final String REGEXP_KR = "^[ㄱ-ㅎ|가-힣]*$";

    // 5. 대소구분 없는 영문과 한글만 허용하는 정규식
    public static final String REGEXP_ONLY_CHAR = "^[a-z|A-Z|ㄱ-ㅎ|가-힣]*$";
    public static final String REGEXP_ONLY_SPACE_CHAR = "^[a-z|A-Z|ㄱ-ㅎ|가-힣| ]*$";

    // 6. 대소구분 없는 영문과 한글, 숫자를 허용하는 정규식
    public static final String REGEXP_CHAR_NUM = "^[0-9a-zA-Zㄱ-ㅎ가-힣]*$";
    public static final String REGEXP_CHAR_SPACE_NUM = "^[0-9a-zA-Zㄱ-ㅎ가-힣 ]*$";


    // 7. 특수문자 제외에 대한 정규식
    public static final String REGEXP_NOT_SPECIAL_CHAR_TYPE1 = "^[^A-Za-z0-9]*$";
    public static final String REGEXP_NOT_SPECIAL_CHAR_TYPE2 = "[\\{\\}\\[\\]\\/?.,;:|\\)*~`!^\\-_+<>@\\#$%&\\=\\('\"]*$";

    /**
     * [정규식 모음-3] 숫자에 대한 정규식
     */
    // 숫자만 이용하는 정규식
    public static final String REGEXP_NUMBER = "^[0-9]*$";

    // 숫자가 아닌것에 대한 정규식
    public static final String REGEXP_NO_NUMBER = "^[^0-9]*$";

    /**
     * [정규식 모음-4] 사용자 정보 관련 정규식
     */
    // 1. 사용자 이메일에 대한 정규식
    public static final String REGEXP_LIGHT_USER_EMAIL = "^[a-zA-Z0-9]+@[0-9a-zA-Z]+\\.[a-z]+$";  // 언더바(_), 하이픈(-) 제외
    public static final String REGEXP_TIGHT_USER_EMAIL = "^[0-9a-zA-Z]([-_\\.]?[0-9a-zA-Z])*@[0-9a-zA-Z]([-_\\.]?[0-9a-zA-Z])*\\.[a-zA-Z]{2,3}$"; // 언더바(_), 하이픈(-) 포함 및 길이 지정

    // 2. 사용자 아이디에 대한 정규식 - 영문 숫자 조합 6~10자리
    public static final String REGEXP_USER_ID = "^[a-z]{1}[a-z0-9]{5,10}$";

    // 3. 사용자 패스워드에 대한 정규식 - 대소문자 + 숫자 + 특수문자 조합으로 10 ~ 128자리로 정의 한다.
    public static final String REGEXP_USER_PW_TYPE1 = "^(?=.*[a-zA-Z])((?=.*\\d)|(?=.*\\W)).{10,128}$";

    // 4. 핸드폰 번호 타입1에 대한 정규식 => ex) 01012345678
    public static final String REGEXP_PHONE_TYPE1 = "^[\\d]{11}$";

    // 5. 핸드폰 번호 타입2에 대한 정규식 => ex) 010-1234-5678
    public static final String REGEXP_PHONE_TYPE2_1 = "^01([0|1|6|7|8|9])-([0-9]{3,4})-([0-9]{4})$";
    public static final String REGEXP_PHONE_TYPE2_2 = "^[\\d]{2,3}-[\\d]{3,4}-[\\d]{4}$";

    // 6. 핸드폰 번호 타입3에 대한 정규식 => ex) +82-010-1234-5678
    public static final String REGEXP_PHONE_TYPE3 = "^\\+82-01([0|1|6|7|8|9])-([\\d]{3,4})-([\\d]{4})$";

    // 7. 핸드폰 번호 타입4에 대한 정규식 => ex) +82-10-1234-5678
    public static final String REGEXP_PHONE_TYPE4 = "^\\+82-10-([\\d]{3,4})-([\\d]{4})$";

    // 8. 주민등록번호 타입에 대한 정규식
    public static final String REGEXP_REGISTRATION_NUM = "^[\\d]{6}-[1-4][\\d]{6}$";

    // 9. 우편 번호에 대한 정규식
    public static final String REGEXP_POSTAL_CODE = "^[\\d]{3}-[\\d]{2}$";


    /**
     * [정규식 모음-5] 날짜에 대한 정규식
     */
    // [Soft] 날짜에 대한 타입1에 대한 정규식 => ex) 2022-08-03 (YYYY-MM-DD)
    public static final String REGEXP_DATE_TYPE1 = "^[\\d]{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$";

    // [Soft] 날짜에 대한 타입2에 대한 정규식 => ex) 2022/08/03 (YYYY/MM/DD)
    public static final String REGEXP_DATE_TYPE2 = "^[\\d]{4}]\\/(0[1-9]|1[012])\\/(0[1-9]|[12][0-9]|3[01])$";

    // [Soft] 날짜에 대한 타입에 대한 정규식 => ex) 2022.08.03 (YYYY.MM.DD)
    public static final String REGEXP_DATE_TYPE3 = "^[\\d]{4}\\.(0[1-9]|1[012])\\.(0[1-9]|[12][0-9]|3[01])$";

    // [Hard] 날짜에 대한 정규식 => 19xx 20xx년도에 대해서 추가함 -- 강력하게 유효성 검증
    public static final String REGEXP_DATE_TYPE4 = "^(19|20)[\\d]{2}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$";

    // 날짜에 대한 정규식 - YYYY/MM/DD hh:mi:ss
    public static final String REGEXP_DATE_TYPE5 =
            "([0-2][0-9]{3})\\/([0-1][0-9])\\/([0-3][0-9]) ([0-5][0-9]):([0-5][0-9]):([0-5][0-9])(([\\-\\+]([0-1][0-9])\\:00))?";

    /**
     * [정규식 모음-6] 시간에 대한 정규식
     */
    // 시간에 대한 타입1에 대한 정규식 => ex) 13:47(HH24:mm)
    public static final String REGEXP_TIME_TYPE1 = "^([1-9]|[01][0-9]|2[0-3]):([0-5][0-9])$";

}

5) 2024.09.04 추가사항 : 문장의 끝($, +$ 차이)

💡 2024.09.04 추가사항 : 문장의 끝($, +$ 차이)

- 문장의 끝에 $와 +$차이에 대한 수정사항이 있었습니다.

패턴	의미	예시	설명
$	문자열의 끝	abc$	문자열이 'abc'로 끝나는 경우 매칭
+$	하나 이상의 반복 후 문자열 끝	a+$	'a', 'aa', 'aaa' 등으로 끝나는 문자열 매칭
*$	0개 이상의 반복 후 문자열 끝	a*$	빈 문자열, 'a', 'aa', 'aaa' 등으로 끝나는 문자열 매칭

💡 $, +$ 기호에 대한 이해를 돕기 위한 예시입니다.

- [a-z0-9]{5, 10}$

- 5~10자리의 숫자, 문자에 대해서만 허용한다는 의미입니다.

- [a-z0-9]{5, 10}+$

- 5~10자리의 숫자, 문자에 대해서 허용하면서, 1번 이상을 반복하라는 의미로 씌어 모순적인 의미를 담고 있습니다. 즉, 이미 {5, 10}으로 이미 반복 횟수를 지정했지만, +$를 통해 반복횟수를 모순된 지시를 수행하는 경우입니다.

- [a-z0-9]+$

- 숫자와 문자에 대해서 허용하면서 반복적임을 허용하기에 숫자와 문자에 대해 제한 없는 길이를 허용합니다.

 /*
 * 1. Pattern - $, +$ 비교 : 첫째는 알파벳이오고, 이후는 문자와 숫자를 허용하는 사용자 아이디를 지정하는 정규식입니다.
 */
String REGEXP_USER_ID_1 = "^[a-z]{1}[a-z0-9]{5,10}$";
boolean isValidUserId1_1 = Pattern.matches(REGEXP_USER_ID_1, "adjh54");                                 // true
boolean isValidUserId1_2 = Pattern.matches(REGEXP_USER_ID_1, "adjh54o38947509834593485039485340958");   // false
boolean isValidUserId1_3 = Pattern.matches(REGEXP_USER_ID_1, "adjh54             ");                    // false
System.out.println("isValidUserId1_1 [" + isValidUserId1_1 + "] isValidUserId1_2 [" + isValidUserId1_2 + "]  isValidUserId1_3 [" + isValidUserId1_3 + "]");


String REGEXP_USER_ID_2 = "^[a-z]{1}[a-z0-9]{5,10}+$";
boolean isValidUserId2_1 = Pattern.matches(REGEXP_USER_ID_2, "adjh54");                                 // true
boolean isValidUserId2_2 = Pattern.matches(REGEXP_USER_ID_2, "adjh54o38947509834593485039485340958");   // false
boolean isValidUserId2_3 = Pattern.matches(REGEXP_USER_ID_2, "adjh54             ");                    // false
System.out.println("isValidUserId2_1 [" + isValidUserId2_1 + "] isValidUserId2_2 [" + isValidUserId2_2 + "]  isValidUserId2_3 [" + isValidUserId2_3 + "]");

String REGEXP_USER_ID_3 = "^[a-z]{1}[a-z0-9]+$";
boolean isValidUserId3_1 = Pattern.matches(REGEXP_USER_ID_3, "adjh54");                                 // true
boolean isValidUserId3_2 = Pattern.matches(REGEXP_USER_ID_3, "adjh54o38947509834593485039485340958");   // true
boolean isValidUserId3_3 = Pattern.matches(REGEXP_USER_ID_3, "adjh54             ");                    // false
System.out.println("isValidUserId3_1 [" + isValidUserId3_1 + "] isValidUserId2_2 [" + isValidUserId3_2 + "]  isValidUserId2_3 [" + isValidUserId3_3 + "]");

💡 [참고] IPv4, IPv6 정규표현식 구성 방법

[Java/Short] IPv4, IPv6 정규 표현식(RegExp: Regular Expression)

해당 글에서는 IPv4, IPv6에 대한 정규식을 수행하는 방법에 대해 알아봅니다. 1) IPv4 💡 IPv4 - 인터넷 프로토콜 버전 4로 컴퓨터와 같은 디바이스가 인터넷을 통해 서로 통신하기 위해 사용하는 주

adjh54.tistory.com

오늘도 감사합니다. 😀

그리드형