[JAVA] 문자열의 메소드들

String

문자열은 불변! immutable

문자열 스스로를 변경하는 메소드는 없다.

• 새 문자열 또는 다른 값 반환
• 문자열 변수에 다른 값을 넣을 수 없다는 뜻은 아님

---

1. 문자열 길이 반환 length

 int int3 = "Hello".length();
 int int4 = "김수한무 거북이와 두루미".length();

---

2. 트리밍 trim

String str3 = "\t 에 네 르 기 파!! \n";
 //  💡 trim : 앞뒤의 공백(white space) 제거
String str4 = str3.trim();
//str4 = "에네르기파!!"

---

3. 문자 반환 charAt
   : ~번째 문자 반환

 char ch1 = str1.charAt(0);
 char ch2 = str1.charAt(4);

 //  ⭐️ 마지막 문자 얻기
 char ch3 = str1.charAt(str1.length() - 1);

---

4. 문자(열)의 위치 반환 indexOf/lastIndexOf
   💡 : 일치하는 첫/마지막 문자열의 위치

String str2 = "얄리 얄리 얄라셩 얄라리 얄라";
//  두 번째 인자 : ~번째 이후/이전부터 셈
int int1 = str2.indexOf('얄');
int int2 = str2.indexOf('얄', 4);

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

---

5. 값 동일여부 확인 equals, equalsIgnoreCase

	//  💡 equals : 대소문자 구분하여 비교
        String str_a1 = "Hello World";
        String str_a2 = new String("Hello World");
        String str_a3 = "HELLO WORLD";

				boolean bool_a0 = str_a1 == str_a2;  // ⚠️ 문자열은 이렇게 비교하지 말 것!

        boolean bool_a1 = str_a1.equals(str_a2);
        boolean bool_a2 = str_a1.equals(str_a3);

        //  💡 equalsIgnoreCase : 대소문자 구분하지 않고 비교
        boolean bool_a3 = str_a1.equalsIgnoreCase(str_a3);
        boolean bool_a4 = str_a2.equalsIgnoreCase(str_a3);

---

6. 포함 여부 확인 comtains, startWith, endWith

String str_b1 = "옛날에 호랑이가 한 마리 살았어요.";

        //  💡 contains : 포함 여부
        boolean bool_b1 = str_b1.contains("호랑이"); //true
        boolean bool_b2 = str_b1.contains("나무꾼"); //false

        //  💡 startsWith : (주어진 위치에서) 해당 문자열로 시작 여부
        boolean bool_b3 = str_b1.startsWith("옛날에"); //true
        boolean bool_b4 = str_b1.startsWith("호랑이"); //false
        boolean bool_b5 = str_b1.startsWith("호랑이", 4); //true

        //  💡 endsWith : 해당 문자열로 끝남 여부
        boolean bool_b6 = str_b1.endsWith("살았어요."); //true
        boolean bool_b7 = str_b1.endsWith("호랑이"); //false

---

7. 정규표현식 일치 여부 확인 matches

정규표현식

문자열의 패턴을 정의하여 특정 형식에 맞는 문자열을 찾거나 검증할 수 있도록 만들어주는 강력한 도구

아래 예시에서 나오는 정규표현식
^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$

1. ^와 $^: 문자열의 시작을 의미합니다. 즉, 이 정규표현식은 문자열의 첫 번째 문자부터 검사합니다.$: 문자열의 끝을 의미합니다. 이 정규표현식은 문자열 전체가 조건에 부합하는지 확인합니다.
2. [\w-\.]
   \w: 알파벳 대소문자, 숫자, 밑줄()에 해당하는 문자와 일치합니다. 이는 [a-zA-Z0-9]와 동일합니다.
   -: 하이픈(-)을 허용합니다. 이메일의 사용자 이름에서 종종 사용됩니다.
   \.: 마침표(.)를 허용하지만, 마침표는 정규표현식에서 특별한 의미(모든 문자를 의미함)를 가지므로 \로 이스케이프 처리해야 합니다.
   결과적으로, 이 부분은 이메일 주소의 사용자 이름 부분에 알파벳, 숫자, 밑줄, 하이픈, 마침표가 올 수 있음을 의미합니다.
3. @
   @: @는 이메일 주소에서 꼭 필요한 구분자이므로, 패턴에서도 정확히 해당 기호가 있어야 합니다.
4. ([\w-]+\.)
   \w-: 앞에서 설명한 대로 알파벳, 숫자, 밑줄, 하이픈을 포함합니다.
   +: 이 부분은 하나 이상의 연속된 문자가 있어야 한다는 뜻입니다. 따라서 이메일 주소의 도메인 부분은 최소 하나 이상의 문자가 올 수 있습니다.
   \.: 도메인 이름 뒤에 올 .을 의미합니다.
   이 부분은 이메일의 도메인(예: yalco.kr에서 yalco.)을 나타냅니다.
5. [\w-]{2,4}
   {2,4}: 이 구문은 2자리에서 4자리 사이의 길이를 의미합니다. 즉, 도메인 확장자 부분(예: .com, .kr)이 2~4자의 길이를 가져야 함을 나타냅니다.

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

        String str_c1 = "yalco@yalco.kr";
        String str_c2 = "yalco.yalco.kr";
        String str_c3 = "yalco@yalco@kr";

        boolean bool_c1 = str_c1.matches(emailRegex); //true
        boolean bool_c2 = str_c2.matches(emailRegex); //false
        boolean bool_c3 = str_c3.matches(emailRegex); //false

---

8. 문자열 비교 compareTo, compareToIgnoreCase
   : 사전순 비교에 따라 양수 또는 음수 반환

• 같은 문자열이면 0
• 시작하는 부분이 같을 땐 글자 길이의 차이 반환
• 시작하는 부분이 다를 땐 첫 글자의 정수값 차이 반환

				String str_a1 = "ABC";
        String str_a2 = "ABCDE";
        String str_a3 = "ABCDEFG";

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

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

        //  시작하는 부분이 같을 때는 글자 길이의 차이 반환
        int int_a2 = str_a1.compareTo(str_a2);
        int int_a3 = str_a1.compareTo(str_a3);
        int int_a4 = str_a2.compareTo(str_a3);
        int int_a5 = str_a3.compareTo(str_a1);

        String str_a4 = "HIJKLMN";

        //  시작하는 부분이 다를 때는 첫 글자의 정수값 차이 반환
        int int_a6 = str_a1.compareTo(str_a4);
        int int_a7 = str_a4.compareTo(str_a3);

		String str_b1 = "abc";
        String str_b2 = "DEF";

        int int_b1 = str_b1.compareTo(str_b2);

        //  💡 compareToIgnoreCase : 대소문자 구분 없이 비교
        int int_b2 = str_b1.compareToIgnoreCase(str_b2);

---

9. 대소문자 변환 toUpperCase / toLowerCase

				String str_a1 = "Hello, World!";

        // 💡 toUpperCase / toLowerCase : 모두 대문자/소문자로 변환
        String str_a2 = str_a1.toUpperCase();
        String str_a3 = str_a1.toLowerCase();

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

        boolean bool_b1 = str_b1.contains(str_b2);

        //  ⭐️ 영문 텍스트에서 대소문자 무관 특정 텍스트 포함 여부 확인시
        boolean bool_b2 = str_b1
                .toUpperCase()
                .contains(str_b2.toUpperCase());

        boolean bool_b3 = str_b1
                .toLowerCase()
                .contains(str_b2.toLowerCase());

---

10. 이어붙이기 concat

• concat에는 문자열만 이어붙일 수 있음
• concat은 필요시에만 새 인스턴스 생성
• 연산자는 null과 이어붙이기 가능
• ⚠️ concat은 NullPointerException 발생
• concat은 매 번 문자열을 반환

				//  💡 concat : 문자열을 뒤로 이어붙임
        String str_a1 = "슉-";
        String str_a2 = "슈슉-";
        String str_a3 = "슈슈슉-";

        String str_a4 = str_a1 + str_a2 + str_a3;

        String str_a5 = str_a1.concat(str_a2);

        //  ⭐️ 메서드 체이닝
        String str_a6 = str_a1
                .concat(str_a2)
                .concat(str_a3)
                .concat(str_a4)
                .concat(str_a5);

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

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

        // + 연산은 내부적으로 아래와 같이 최적화됨 (이후 배움)
        String str_d2 = new StringBuilder("a")
                .append("b")
                .append("c")
                .append("d")
                .toString(); // "abcd"가 생성됨
        // "a", "b", "c", "d", "abcd"가 생성되어 메모리 차지

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

---

11. 반복하기 repeat

				String str_a1 = "덜컹";

        // 💡 repeat : 문자열을 주어진 정수만큼 반복
        String str_a2 = str_a1.repeat(2);
        String str_a3 = str_a1
                .concat(" ")
                .repeat(3)
                .trim();

---

12. 잘라오기 substring

				String str_b1 = "대한민국 다 job 구하라 그래";

        //  💡 substring : ~번째 문자부터 (~번째 문자까지) 잘라서 반환
        String str_b2 = str_b1.substring(7); //job 구하라 그래
        String str_b3 = str_b1.substring(7, 10); //job
        String str_b4 = str_b1.substring(11, 14); //구하라

        String piece1 = "다 ";
        String piece2 = "구하라";
        String str_b5 = str_b1.substring(
                str_b1.indexOf(piece1),
                str_b1.indexOf(piece2) + piece2.length()
                //str_b1.substring(6,11+3)
                //다 job 구하라
        );

---

13. 치환 replace,replaceAll,replaceFirst

				//  💡 replace : 주어진 앞의 문자(열)을 뒤의 문자(열)로 치환
        String str_c1 = "점심에 보쌈집에 가서 수육을 먹었다.";
        String str_c2 = str_c1.replace("보쌈", "중국");

        //  여럿 포함시 모두 치환
        String str_c3 = "밥 좀 먹자, 응? 야, 밥 좀 먹자고 밥 밥 밥";
        String str_c4 = str_c3.replace('밥', '빵');

        // ⭐️ 원본은 바뀌지 않는 점 확인

				String str_e1 = "02=123.4567_8900";

        //  💡 replaceAll / replaceFirst : ⭐️ 정규표현식 사용 가능
        //  전부 치환 / 첫 번째 일치부분만 치환
        String str_e2 = str_e1
                .replaceAll("[=._]", "-") //반환 결과 :"02-123-4567-8900" 
                .replaceFirst("[-@#]", ")"); //반환 결과 :"02)123-4567-8900"
                

• []는 문자클래스를 의미함

• 따라서, [=._]는 문자열에서 등호(=), 마침표(.), 밑줄(_)을 찾아서 모두 일치하는 부분을 하이픈(-)으로 바꾼다.

• [-@#]는 문자열에서 하이픈(-), @, # 중 하나와 일치하는 첫 번째 부분을 찾아서 닫는 괄호 )로 바꿉니다.

---

14. 배열 반환

				String str1 = "가나다라마";
        String str2 = "010-1234-5678";
        String str3 = "하나 둘 셋 넷 다섯";

        //  💡 toCharArray : 문자열을 분할하여 문자의 배열로 반환
        char[] chAry1 = str1.toCharArray();
        char[] chAry2 = str3
                .replace(" ", "")
                .toCharArray();

        //  💡 split : 주어진 기준으로 (~개까지) 분할하여 문자열 배열로 반환
        String[] strAry1 = str1.split("");
        String[] strAry2 = str2.split("-");
        String[] strAry3 = str3.split(" ");
        String[] strAry4 = str3.split(" ", 3);

---

15. 문자열의 포매팅 formatted

				String str1 = "%s의 둘레는 반지름 X %d X %f입니다.";

        String circle = "원";
        int two = 2;
        double PI = 3.14;

        //  💡 formatted : 주어진 형식에 따라 문자열 생성
        String str2 = str1.formatted(circle, two, PI);
        //str2 = "원의 둘레는 반지름 X 2 X 3.140000입니다."

• ⭐️ %n 은 OS별로 일정하게 줄바꿈이 되도록 적절한 개행문자를 넣어줌
  • 윈도우 : \r\n , 맥&리눅스 : \n

정수

				System.out.printf("%d, %5d, %05d%n- - - - -%n%n", 123, 123, 123);

				//  💡 정수 다양하게 포매팅하기
        String[] intFormats = {
                "%d",        // 1. 기본
                "%13d",      // 2. n 자리수 확보, 오른쪽 정렬
                "%013d",     // 3. 빈 자리수 0으로 채움
                "%+13d",     // 4. 양수는 앞에 + 붙임
                "%,13d",     // 5. 쉼표 사용
                "%-13d",     // 6. 자리수 확보, 왼쪽 정렬
                "%+,013d"    // 7.
        };

        String[] intResults = new String[intFormats.length];

				// 이후의 배울 for 반복문
				// - 위의 형식들로 하나하나 출력해보는 코드
        for (var i = 0; i < intFormats.length; i++) {
            String format = (i + 1) + ". ";
            for (var j = 0; j < 4; j++) {
                format += intFormats[i] + " ";
            }
            format = format.trim() + "%n%n";  // "%d %d %d %d%n%n" ...
						//  System.out.println(format); // 🔍 주석해제하여 함께 확인

						//  🔍 이 숫자들을 스페이스로 구분해서 출력해 볼 것
            System.out.printf(format, 12, 2345, 67890, -1234567);

            //  ⭐️ formatted 메소드에서도 사용 가능
            intResults[i] = format.formatted(12, 2345, 67890, -1234567);
        }

실수

				//  💡 실수 다양하게 포매팅하기
        String[] fltFormats = {
                "%f",       // 1. 기본 (소수점 6자리, 0으로 메움)
                "%.2f",     // 2. 소수점 n자리까지
                "%13.2f",   // 3. 정수자리 확보, 소수자리 제한
                "%,f",      // 4
                "%+013.2f",  // 5
                "%-13.2f",  // 6
        };

        String[] fltResults = new String[fltFormats.length];

        for (var i = 0; i < fltFormats.length; i++) {
            String format = (i + 1) + ". ";
            for (var j = 0; j < 4; j++) {
                format += fltFormats[i] + " ";
            }
            format = format.trim() + "%n%n";

            System.out.printf(format, 1.2, 123.456, 1234.123456789, -123.4567);

            fltResults[i] = format.formatted(1.2, 123.456, 1234.123456789, -123.4567);
        }

문자열

				//  💡 문자열 다양하게 포매팅하기
        String[] strFormats = {
                "%s",    // 1. 기본
                "%9s",   // 2. 자리 확보
                "%.2s",  // 3. ~글자만
                "%9.2s", // 4.
                "%-9s",  // 5. 왼쪽 정렬
        };

        String[] strResults = new String[strFormats.length];

        for (var i = 0; i < strFormats.length; i++) {
            String format = (i + 1) + ". ";
            for (var j = 0; j < 2; j++) {
                format += strFormats[i] + " ";
            }
            format = format.trim() + "%n%n";

            System.out.printf(format, "Hello", "하이염");

            strResults[i] = format.formatted("Hello", "하이염");
        }

---

null문자열

• ⭐️ 빈 문자열과 null은 다름
• ⚠️ null은 문자열 인스턴스 메소드 사용 불가
  
• 참조 자료형의 인스턴스는 null 가능
• 원시값들도 참조 자료형의 인스턴스로는 null 가능