๐ผ ์ ๊ทํํ์ ์์ฑ ๋ฐฉ๋ฒ ๐ผ
์ ๊ท ํํ์(Regular Expression) ์ด๋ ํน์ ํ ๊ท์น์ ๊ฐ์ง ๋ฌธ์์ด์ ์งํฉ์ ํํํ๊ธฐ ์ํด ์ฐ์ด๋ ํ์์ธ์ด ์ ๋๋ค.
์๋ฐ API java.util.regex ํจํค์ง๋ฅผ ์ฌ์ฉํด์ ์์ฑํ ์ ์์ต๋๋ค.

โจPattern ํด๋์ค
์ ๊ท ํํ์์ ๋์ ๋ฌธ์์ด์ ๊ฒ์ฆํ๋ ๊ธฐ๋ฅ์ java.util.regex.Pattern ํด๋์ค์ matches() ๋ฉ์๋๋ฅผ ํ์ฉํ์ฌ ๊ฒ์ฆํ ์ ์์ต๋๋ค. matches() ๋ฉ์๋์ ์ฒซ๋ฒ์งธ ๋งค๊ฐ๊ฐ์ ์ ๊ทํํ์์ด๊ณ ๋๋ฒ์งธ ๋งค๊ฐ๊ฐ์ ๊ฒ์ฆ ๋์ ๋ฌธ์์ด์ ๋๋ค.
๊ฒ์ฆ ํ ๋์๋ฌธ์์ด์ด ์ ๊ทํํ์๊ณผ ์ผ์นํ๋ฉด true, ๊ทธ๋ ์ง ์๋ค๋ฉด false๊ฐ์ ๋ฆฌํดํฉ๋๋ค.
import java.util.regex.Pattern;
public class RegexExample {
public static void main(String[] args) {
String pattern = "^[0-9]*$"; //์ซ์๋ง
String val = "123456789"; //๋์๋ฌธ์์ด
boolean regex = Pattern.matches(pattern, val);
System.out.println(regex);
}
}
Pattern ํด๋์ค ์ฃผ์ ๋ฉ์๋
compile(String regex) : ์ฃผ์ด์ง ์ ๊ทํํ์์ผ๋ก๋ถํฐ ํจํด์ ๋ง๋ญ๋๋ค.
matcher(CharSequence input) : ๋์ ๋ฌธ์์ด์ด ํจํด๊ณผ ์ผ์นํ ๊ฒฝ์ฐ true๋ฅผ ๋ฐํํฉ๋๋ค.
asPredicate() : ๋ฌธ์์ด์ ์ผ์น์ํค๋ ๋ฐ ์ฌ์ฉํ ์์๋ ์ ์ด๋ฅผ ์์ฑํฉ๋๋ค.
pattern() : ์ปดํ์ผ๋ ์ ๊ทํํ์์ String ํํ๋ก ๋ฐํํฉ๋๋ค.
split(CharSequence input) : ๋ฌธ์์ด์ ์ฃผ์ด์ง ์ธ์๊ฐ CharSequence ํจํด์ ๋ฐ๋ผ ๋ถ๋ฆฌํฉ๋๋ค.
Parttern ํ๋๊ทธ ๊ฐ ์ฌ์ฉ(์์)
Pattern.CANON_EQ : Noneํ์คํ๋ ๋งค์นญ ๋ชจ๋๋ฅผ ํ์ฑํํฉ๋๋ค.
Pattern.CASE_INSENSITIVE : ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ์ง ์์ต๋๋ค.
Pattern.COMMENTS : ๊ณต๋ฐฑ๊ณผ #์ผ๋ก ์์ํ๋ ์ฃผ์์ด ๋ฌด์๋ฉ๋๋ค. (๋ผ์ธ์ ๋๊น์ง).
Pattern.MULTILINE : ์์ โ^โ ๋ ๋ผ์ธ์ ์์๊ณผ, โ$โ ๋ ๋ผ์ธ์ ๋๊ณผ match ๋ฉ๋๋ค.
Pattern.DOTALL : ์์ โ.โ๊ณผ ๋ชจ๋ ๋ฌธ์์ match ๋๊ณ โ\nโ ๋ match ์ ํฌํจ๋ฉ๋๋ค.
Pattern.UNICODE_CASE : ์ ๋์ฝ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ๋์๋ฌธ์ ๊ตฌ๋ถ ์์ด match ์ํต๋๋ค.
Pattert.UNIX_LINES : ์์ โ.โ ๊ณผ โ^โ ๋ฐ โ$โ์ match์์ ํ ๋ผ์ธ์ ๋์ ์๋ฏธํ๋ โ\nโ๋ง ์ธ์๋ฉ๋๋ค.
โจMatcher ํด๋์ค
Matcher ํด๋์ค๋ ๋์ ๋ฌธ์์ด์ ํจํด์ ํด์ํ๊ณ ์ฃผ์ด์ง ํจํด๊ณผ ์ผ์นํ๋์ง ํ๋ณํ ๋ ์ฃผ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
Matcher ํด๋์ค์ ์ ๋ ฅ๊ฐ์ผ๋ก๋ CharSequence๋ผ๋ ์๋ก์ด ์ธํฐํ์ด์ค๊ฐ ์ฌ์ฉ๋๋๋ฐ ์ด๋ฅผ ํตํด ๋ค์ํ ํํ์ ์ ๋ ฅ ๋ฐ์ดํฐ๋ก๋ถํฐ ๋ฌธ์ ๋จ์์ ๋งค์นญ ๊ธฐ๋ฅ์ ์ง์ ๋ฐ์ ์ ์์ต๋๋ค.
Matcher๊ฐ์ฒด๋ Pattern๊ฐ์ฒด์ matcher() ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ๋ฐ์์ฌ ์ ์์ต๋๋ค.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexExample {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("^[a-zA-Z]*$"); //์๋ฌธ์๋ง
String val = "abcdef"; //๋์๋ฌธ์์ด
Matcher matcher = pattern.matcher(val);
System.out.println(matcher.find());
}
}
Matcher ํด๋์ค ์ฃผ์ ๋ฉ์๋
matches() : ๋์ ๋ฌธ์์ด๊ณผ ํจํด์ด ์ผ์นํ ๊ฒฝ์ฐ true ๋ฐํํฉ๋๋ค.
find() : ๋์ ๋ฌธ์์ด๊ณผ ํจํด์ด ์ผ์นํ๋ ๊ฒฝ์ฐ true๋ฅผ ๋ฐํํ๊ณ , ๊ทธ ์์น๋ก ์ด๋ํฉ๋๋ค.
find(int start) : start์์น ์ดํ๋ถํฐ ๋งค์นญ๊ฒ์์ ์ํํฉ๋๋ค.
start() : ๋งค์นญ๋๋ ๋ฌธ์์ด ์์์์น ๋ฐํํฉ๋๋ค.
start(int group) : ์ง์ ๋ ๊ทธ๋ฃน์ด ๋งค์นญ๋๋ ์์์์น ๋ฐํํฉ๋๋ค.
end() : ๋งค์นญ๋๋ ๋ฌธ์์ด ๋ ๋ค์ ๋ฌธ์์์น ๋ฐํํฉ๋๋ค.
end(int group) : ์ง์ ๋ ๊ทธ๋ฃน์ด ๋งค์นญ๋๋ ๋ ๋ค์ ๋ฌธ์์์น ๋ฐํํฉ๋๋ค.
group() : ๋งค์นญ๋ ๋ถ๋ถ์ ๋ฐํํฉ๋๋ค.
group(int group) : ๋งค์นญ๋ ๋ถ๋ถ์ค group๋ฒ ๊ทธ๋ฃนํ ๋งค์นญ๋ถ๋ถ ๋ฐํํฉ๋๋ค.
groupCount() : ํจํด๋ด ๊ทธ๋ฃนํํ(๊ดํธ์ง์ ) ์ ์ฒด ๊ฐฏ์๋ฅผ ๋ฐํํฉ๋๋ค.
โจ์ ํจ์ฑ ๊ฒ์ฌ
์ ๊ท ํํ์์ ์ ํจ์ฑ ๊ฒ์ฌ ์ฝ๋ ์์ฑ ์ ๊ฐ์ฅ ํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ ๋๋ค.
import java.util.regex.Pattern;
public class RegexExample {
public static void main(String[] args) {
String name = "ํ๊ธธ๋";
String tel = "010-1234-5678";
String email = "test@naver.com";
//์ ํจ์ฑ ๊ฒ์ฌ
boolean name_check = Pattern.matches("^[๊ฐ-ํฃ]*$", name);
boolean tel_check = Pattern.matches("^01(?:0|1|[6-9])-(?:\\d{3}|\\d{4})-\\d{4}$", tel);
boolean email_check = Pattern.matches("\\w+@\\w+\\.\\w+(\\.\\w+)?", email);
//์ถ๋ ฅ
System.out.println("์ด๋ฆ : " + name_check);
System.out.println("์ ํ๋ฒํธ : " + tel_check);
System.out.println("์ด๋ฉ์ผ : " + email_check);
}
}
์ถ์ฒ : ๋งํฌ
'๊ฐ๋ฐ์ธ์ด > JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] Stack ํด๋์ค ์ค๋ช ๋ฐ ์์ (1) | 2022.04.23 |
---|---|
[Java] HashMap (key ๊ฐ ๊ฐ์ ธ์ค๊ธฐ) (0) | 2022.04.22 |
[Java] ์๋ฐ ์ ๊ทํํ์ ๋ชจ์ (0) | 2022.04.18 |
[Java] ๋ ๋ ์ง ์ฌ์ด์ ๋ ์ง์ถ๋ ฅ (0) | 2022.04.12 |
[Java] SimpleDateFormat ํจํด/์ฌ์ฉ๋ฒ (0) | 2022.04.12 |