[JAVA] 문자열 메서드

1. length()

length는 문자열의 길이를 측정하는 메서드입니다.

int i1 = "".length(); // 0
int i2 = "헬로".length(); //2
int i3 = "Hello".length(); //5
int i4 = "안녕하세요".length(); //5

 

2. isEmpty(), isBlank()

이 두개의 메서드는 문자열이 비어있는지 확인하는 메서드입니다. 두 메서드의 차이는 isEmpty는 공백도 문자열로 인정한다는 것이며 isBlank는 공백을 문자열로 인정하지 않는다는 것입니다.

 //문자열이 비어있는지 여부
String str1 = "";
String str2 = " \t\n";
int i5 = str1.length(); //0
int i6 = str2.length(); //3 -> 공백도 문자열로 반환함

//  isEmpty : 문자열의 길이가 0인지 여부
boolean b1 = str1.isEmpty(); //true
boolean b2 = str2.isEmpty(); //false

//  isBlank : 공백(white space)을 제외한 문자열의 길이가 0인지 여부
boolean b3 = str1.isBlank(); //true
boolean b4 = str2.isBlank(); //true -> 공백을 인정하지 않기 때문에 비어있다고 나타남

3.trim()

이 메서드는 앞뒤 공백을 자르는 메서드입니다.

String str3 = "\t 안 녕 하 세 요 \n";
System.out.println("|"+str3+"|");
//출력: |	 안 녕 하 세 요
//     |

// trim : 앞뒤의 공백(white space) 제거
String str4 = str3.trim();
System.out.println("|"+str4+"|");
//출력: |안 녕 하 세 요| -> 양 끝의 공백이 사라짐, 줄바꿈도 공백으로 인식하기 때문에 사라짐
str3 = str3.trim();
System.out.println("|"+str3+"|"); //출력: |안 녕 하 세 요|

4.charAt()

이 메서드는 문자 하나를 반환하는 메서드입니다. 따라서 문자타입으로 형변환을 할때도 사용합니다.

String str5 = "안녕하세요 자바를 공부하는 분들";

// charAt : ~번째 문자 반환
char ch1 = str5.charAt(0); // '안'
char ch2 = str5.charAt(4); // '요'

//  마지막 문자 얻기
char ch3 = str5.charAt(str5.length() - 1); // '들'

5. indexOf()

이 메서드는 문자열의 위치, 즉 인덱스를 반환하는 메서드입니다. 결과는 int로 반환됩니다.

String str6 = "아희 아희 아희야 내 말좀 들어라";

// '아'라는 문자가 포함된 첫번째 인덱스
int int1 = str6.indexOf('아'); // 0

//인덱스4 이후 '아'라는 문자가 포함된 첫번째 인덱스
int int2 = str6.indexOf('아', 4); //6

//"아희"라는 문자열이 있는 첫번째 인덱스
int  int3 = str6.indexOf("아희"); //0

//"아희"라는 글자가 있는 마지막 인덱스
int  int4 = str6.lastIndexOf("아희"); //6

//인덱스 4 이전에 "아희"라는 글자가 있는 마지막 인덱스
int  int5 = str6.lastIndexOf("아희", 4); //3

//  포함되지 않은 문자는 -1 반환
int int6 = str6.indexOf('쵸'); //-1

6.contains(), startsWith(),endsWith()

contains 메서드는 특정 문자열이 포함되는지 여부를 확인하는 메서드이며, startWith 메서드는 특정 문자열로 시작하는지 확인하는 메서드이고, endsWith는 특정문자열로 끝나는지 확인하는 메서드입니다.

 

String str6 = "아희 아희 아희야 내 말좀 들어라";
// contains : 포함 여부
boolean bool1 = str6.contains("아희"); //true
boolean bool2 = str6.contains("시연"); //false

// startsWith : (주어진 위치에서) 해당 문자열로 시작 여부
boolean bool3 = str6.startsWith("아희"); //true
boolean bool4 = str6.startsWith("내"); //false
//두번째 매개변수는 인덱스 4에서 첫번째 매개변수의 문자열로 시작하는지 확인
boolean bool5 = str6.startsWith("아희", 4); //false
boolean bool6 = str6.startsWith("희 ",4); //true

// endsWith : 해당 문자열로 끝남 여부
boolean bool7 = str6.endsWith("들어라"); //true
boolean bool8 = str6.endsWith("야"); //false

7. matches()

이 메서드는 정규표현식과 비교하는 메서드입니다.

 

정규표현식에 대한 내용은 아래에서 확인하실 수 있습니다.

정규 표현식 - 나무위키 (namu.wiki)

 

정규표현식을 시각화해주는 사이트도 있습니다.

Regexper

 

예제는 아래와 같습니다.

String emailRegex = "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$";

String str1 = "zero-week@naver.com";
String str2 = "zero-week.naver.com";
String str3 = "zero-week@naver@com";

boolean bool1 = str1.matches(emailRegex); //true
boolean bool2 = str2.matches(emailRegex); //false
boolean bool3 = str3.matches(emailRegex); //false

8. compareTo()

이 메서드는 문자열을 비교하는 메서드입니다. 이 메서드는 두 문자열을 비교하여 정수값을 반환합니다.

String str1 = "ABCG";
String str2 = "ABCDE";
String str3 = "ABCDEFGHI";

// compareTo : 사전순 비교에 따라 양수 또는 음수 반환

//  같은 문자열이면 0 반환
int int1 = str1.compareTo(str1);

//  시작하는 부분이 같을 때는 글자 길이의 차이 반환
int int2 = str1.compareTo(str2); // "ABC"가 동일 -> D와 G의 아스키 코드값의 차이를 반환 -> 3을 반환
int int3 = str1.compareTo(str3); // 위와 동일 -> 3
int int4 = str3.compareTo(str1); //위 값과 반대 -> -3

// 하나의 문자열이 다른 문자열에 완전히 포함될 경우에는 문자열의 남은 길이를 반환
int int5 = str2.compareTo(str3); //"ABCDE"가 동일 -> 남은 문자열은 "FGHI" -> str2 - str3 = -4

String str4 = "HIJKLMN";

//  시작하는 부분이 다를 때는 첫 글자의 정수값 차이 반환
int int6 = str1.compareTo(str4); //시작부분부터 다르므로 H와 A의 아스키 코드값의 차이를 반환 -> -7
int int7 = str4.compareTo(str3); // 위와 반대 -> 7
int c1 = 'H' - 'A'; // 7

String str5 = "abc";
String str6 = "ABC";

int int8 = str5.compareTo(str6); //32
int c2 = 'a' - 'A'; //32

// compareToIgnoreCase : 대소문자 구분 없이 비교
int int9 = str5.compareToIgnoreCase(str6); // 0

9. 대소문자 변환 메서드

String str1 = "Hello, World!";

// toUpperCase / toLowerCase : 모두 대문자/소문자로 변환
String str2 = str1.toUpperCase();
System.out.println(str2); //출력: HELLO, WORLD!
String str3 = str1.toLowerCase();
System.out.println(str3); //출력: hello, world!

String str4 = "Hi! How are you? I'm fine. Thank you!";
String str5 = "how";

boolean bool1 = str4.contains(str5); //false -> 대소문자를 구분하지 못하기 때문

//  영문 텍스트에서 대소문자 무관 특정 텍스트 포함 여부 확인시
boolean bool2 = str4
        .toUpperCase()
        .contains(str5.toUpperCase()); //true -> str4,str5를 모두 대문자로 바꾸고 비교

boolean bool3 = str4
        .toLowerCase()
        .contains(str5.toLowerCase()); //true -> str4,str5를 모두 소문자로 바꾸고 비교

10.concat()

이 메서드는 문자열을 더하는 메서드입니다. 문자열의 덧셈 연산도 문자열을 합할 수 있지만 일부 차이가 있습니다.

1) 사용방법

String str1 = "안녕~";
String str2 = "친구들~!";
String str3 = "빡빡이 아저씨야.!";

String str4 = str1 + str2 + str3;
System.out.println(str4); //출력: 안녕~친구들~!빡빡이 아저씨야.!

String str5 = str1.concat(str2);
System.out.println(str5); // 출력: 안녕~친구들~!

//  메서드 체이닝
String str6 = str1
        .concat(str2)
        .concat(str3)
        .concat(str4)
        .concat(str5);

System.out.println(str6); // 안녕~친구들~!빡빡이 아저씨야.!안녕~친구들~!빡빡이 아저씨야.!안녕~친구들~!

2) + 연산자와의 차이

String str1 = "ABC";

//  1. concat에는 문자열만 이어붙일 수 있음
String str2 = str1 + true + 1 + 2.34 + '가';
String str3 = str1
        //  .concat(true)
        //  .concat(1)
        //  .concat(2.34)
        //  .concat('가')
        ;

//  2. concat은 필요시에만 새 인스턴스 생성 (큰 의미 없음)
String str4 = str1 + "";
String str5 = str1.concat("");

int str1Hash = System.identityHashCode(str1);
System.out.println(str1Hash); //출력: 495053715
int str4Hash = System.identityHashCode(str4);
System.out.println(str4Hash); //출력: 1922154895
int str5Hash = System.identityHashCode(str5);
System.out.println(str5Hash); //출력: 495053715

//  3. null이 포함될 경우

String strNull = null;

//  + 연산자는 null과 이어붙이기 가능
String str6 = strNull + null + "ABC";

//  concat은 NullPointerException 발생
//String str_c4 = strNull.concat("ABC");
//String str_c5 = "ABC".concat(strNull);

//  4. 다중 연산시 생성되는 문자열 인스턴스의 수가 다름

String str7 = "a" + "b" + "c" + "d";

// + 연산은 내부적으로 아래와 같이 최적화됨
String str8 = new StringBuilder("a")
        .append("b")
        .append("c")
        .append("d")
        .toString(); // "abcd"가 생성됨


//  concat은 매 번 문자열을 반환하므로
String str9 = "a"
        .concat("b") // "ab"가 생성됨
        .concat("c") // "abc"가 생성됨
        .concat("d"); // "abcd"가 생성됨
// "a", "b", "c", "d", "ab", "abc", "abcd"가 생성되어 메모리 차지

 

일반적으로 + 연산이나 StringBuilder, StringBuffer 등을 사용하는게 더 좋지만, 유의미한 성능 차이가 발생하지는 않기 때문에 메서드 체이닝등의 편의를 위해 concat를 사용할 수도 있습니다.

11. repeat()

이 메서드는 문자열을 반복하는 메서드입니다.

String str1 = "덜컹";

// repeat : 문자열을 주어진 정수만큼 반복
String str2 = str1.repeat(2);
System.out.println(str2); //출력: 덜컹덜컹

String str3 = str1
        .concat(" ") 
        .repeat(3)
        .trim();
System.out.println("|"+str3+"|"); //출력: |덜컹 덜컹 덜컹|

12. 문자열 자르기, 문자열 대체

String str1 = "안녕 친구들~! 빡빡이 아저씨야~!";

//  substring : ~번째 문자부터 (~번째 문자까지) 잘라서 반환
String str2  = str1.substring(7);
System.out.println(str2);//출력: ! 빡빡이 아저씨야~!
String str3 = str1.substring(7, 10);
System.out.println(str3); //출력: ! 빡
String str4 = str1.substring(11, 14);
System.out.println(str4); //출력: 이 아

String piece1 = "!";
String piece2 = "야";
String str5 = str1.substring(
        str1.indexOf(piece1),
        str1.indexOf(piece2) + piece2.length()
);
System.out.println(str5); //출력: ! 빡빡이 아저씨야

// replace : 주어진 앞의 문자(열)을 뒤의 문자(열)로 변경
String str6 = "점심에 보쌈집에 가서 수육을 먹었다.";
String str7 = str6.replace("보쌈", "중국");
System.out.println(str7); //출력: 점심에 중국집에 가서 수육을 먹었다.

// 여럿 포함시 모두 변경
String str8 = "밥 좀 먹자, 응? 야, 밥 좀 먹자고 밥 밥 밥";
String str9 = str8.replace("밥", "빵");
System.out.println(str9); //출력: 빵 좀 먹자, 응? 야, 빵 좀 먹자고 빵 빵 빵

//  메서드 체이닝
String str10 = "하여튼 호의가 반복되면 권리인 줄 알아";
String str11 = str10
        .replace("하여튼", "아무튼")
        .replace("호의", "호이".repeat(2))
        .replace("권리", "아기공룡 둘리");

System.out.println(str11); //출력: 아무튼 호이호이가 반복되면 아기공룡 둘리인 줄 알아

String str12 = "02=123.4567_8900";

//  replaceAll / replaceFirst : 정규표현식 사용 가능
//  전부 변경 / 첫 번째 일치부분만 변경
String str13 = str12
        .replaceAll("[=._]", "-")
        .replaceFirst("[-@#]", ")");

System.out.println(str13); //출력: 02)123-4567-8900


String str14 = "가나다라마";
String str15 = "010-1234-5678";
String str16 = "하나 둘 셋 넷 다섯";

//  toCharArray : 문자열을 분할하여 문자의 배열로 반환
char[] chAry1 = str14.toCharArray(); //['가','나','다','라','마']
char[] chAry2 = str16
        .replace(" ", "")
        .toCharArray(); // ['하','나','둘','셋','넷','다','섯']

// split : 주어진 기준으로 (~개까지) 분할하여 문자열 배열로 반환
String[] strAry1 = str14.split(""); // ["가","나","다","라","마"]
String[] strAry2 = str15.split("-"); //["010","1234","5678"]
String[] strAry3 = str16.split(" "); //["하나","둘","셋","넷","다섯"]

String[] strAry4 = str16.split(" ", 3);
// 두번째 매개변수는 ~개까지를 의미 ->  즉 여기서는 3개까지 분할 -> ["하나","둘","셋 넷 다섯"]

13. 문자열 배열을 하나의 문자열로 바꾸기(join)

String[] strings = {"QQ", "WW", "EE", "RR"};

//  join 정적 메소드 - 문자열(정확히는 CharSequence)의 배열을 하나로 이어붙임
//  첫 번째 인자를 각 사이에 삽입
String join1 = String.join(", ", strings);
System.out.println(join1); // QQ, WW, EE, RR
String join2 = String.join("-", strings);
System.out.println(join2); // QQ-WW-EE-RR
String join3 = String.join(" 그리고 ", strings);
System.out.println(join3); // QQ 그리고 WW 그리고 EE 그리고 RR
String join4 = String.join("", strings);
System.out.println(join4); //QQWWEERR