문자열 — String, StringBuilder, 그리고 String Pool

String name = "hello";
name = name + " world"; // "hello"가 바뀌는 게 아니라 "hello world"라는 새 객체가 생성됨

// String 클래스의 내부 (간략화)
public final class String {
    private final byte[] value; // 한번 할당되면 변경 불가
    private int hash;           // 해시코드 캐시
}

// 리터럴 방식 — String Pool에 저장
String a = "hello";
String b = "hello";

// new 방식 — 힙(Heap)에 새 객체 생성
String c = new String("hello");
String d = new String("hello");

System.out.println(a == b); // true  — 같은 Pool 객체 참조
System.out.println(a == c); // false — Pool과 힙은 다른 영역
System.out.println(c == d); // false — 각각 다른 힙 객체

┌─────────────────────────────────────┐
│              Heap 영역               │
│                                     │
│   ┌───────────────────────┐         │
│   │    String Pool        │         │
│   │  ┌─────────────┐     │         │
│   │  │   "hello"   │ ◄── a, b      │
│   │  └─────────────┘     │         │
│   └───────────────────────┘         │
│                                     │
│   ┌─────────────┐                   │
│   │ String 객체  │ ◄── c            │
│   │ ("hello")   │                   │
│   └─────────────┘                   │
│   ┌─────────────┐                   │
│   │ String 객체  │ ◄── d            │
│   │ ("hello")   │                   │
│   └─────────────┘                   │
└─────────────────────────────────────┘

String x = new String("world"); // 힙에 생성
String y = x.intern();          // Pool에 "world"가 있으면 그 참조 반환
String z = "world";             // Pool의 "world" 참조

System.out.println(x == z); // false — x는 힙 객체
System.out.println(y == z); // true  — y는 Pool 참조

// 비효율적인 문자열 연결
String result = "";
for (int i = 0; i < 10000; i++) {
    result += i; // 매 반복마다 새 String 객체 생성!
}

// 효율적인 문자열 연결
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i); // 같은 객체 내부에서 추가
}
String result = sb.toString(); // 최종 결과만 String으로 변환

// StringBuilder — 동기화 없음, 단일 스레드에서 사용
StringBuilder sb = new StringBuilder("hello");
sb.append(" world");

// StringBuffer — 동기화 있음, 멀티스레드에서 안전
StringBuffer sbf = new StringBuffer("hello");
sbf.append(" world"); // synchronized 메서드

StringBuilder sb = new StringBuilder("Hello");

sb.append(" World");       // 뒤에 추가 → "Hello World"
sb.insert(5, ",");         // 특정 위치에 삽입 → "Hello, World"
sb.delete(5, 6);           // 범위 삭제 → "Hello World"
sb.replace(6, 11, "Java"); // 범위 치환 → "Hello Java"
sb.reverse();              // 뒤집기 → "avaJ olleH"

int len = sb.length();     // 길이
char ch = sb.charAt(0);    // 특정 위치 문자

String a = "hello";
String b = "hello";
String c = new String("hello");

// == 는 참조(주소)를 비교한다
System.out.println(a == b); // true  — 같은 Pool 객체
System.out.println(a == c); // false — Pool vs 힙, 다른 객체

// equals()는 내용(값)을 비교한다
System.out.println(a.equals(b)); // true
System.out.println(a.equals(c)); // true — 값이 같으니까

String email1 = "User@Email.com";
String email2 = "user@email.com";

System.out.println(email1.equals(email2));           // false
System.out.println(email1.equalsIgnoreCase(email2)); // true

String a = "apple";
String b = "banana";
String c = "apple";

System.out.println(a.compareTo(b)); // 음수 — a가 b보다 앞
System.out.println(b.compareTo(a)); // 양수 — b가 a보다 뒤
System.out.println(a.compareTo(c)); // 0    — 같은 문자열

String input = null;

// input.equals("hello"); // NullPointerException 발생!
"hello".equals(input);    // false — 안전하게 비교

import java.util.Objects;

Objects.equals(input, "hello"); // false — null 안전

String s = "  Hello, Java World!  ";

// 공백 제거
s.trim();          // "Hello, Java World!" — 앞뒤 공백 제거
s.strip();         // "Hello, Java World!" — Java 11+, 유니코드 공백도 처리

// 대소문자 변환
s.trim().toUpperCase(); // "HELLO, JAVA WORLD!"
s.trim().toLowerCase(); // "hello, java world!"

// 길이와 빈 문자열 체크
s.length();        // 22 (공백 포함)
"".isEmpty();      // true  — 길이가 0
"  ".isBlank();    // true  — Java 11+, 공백만 있으면 true

String str = "Hello, World!";

str.substring(7);       // "World!" — 7번 인덱스부터 끝까지
str.substring(0, 5);    // "Hello" — 0번부터 5번 전까지 (5 미포함)

String csv = "apple,banana,cherry";
String[] fruits = csv.split(","); // ["apple", "banana", "cherry"]

// 정규식 특수문자는 이스케이프 필요
String path = "C:\\Users\\dev\\file.txt";
String[] parts = path.split("\\\\"); // ["C:", "Users", "dev", "file.txt"]

// 분리 개수 제한
String data = "a:b:c:d:e";
String[] limited = data.split(":", 3); // ["a", "b", "c:d:e"] — 최대 3개로 분리

// 구분자로 합치기
String joined = String.join(", ", "apple", "banana", "cherry");
// "apple, banana, cherry"

// 배열도 가능
String[] arr = {"one", "two", "three"};
String result = String.join(" - ", arr);
// "one - two - three"

// String.format() — C의 printf 스타일
String msg = String.format("%s님, %d개의 메시지가 있습니다.", "홍길동", 5);
// "홍길동님, 5개의 메시지가 있습니다."

// formatted() — Java 15+, 인스턴스 메서드 버전
String msg2 = "%s님, %d개의 메시지가 있습니다.".formatted("홍길동", 5);
// 같은 결과

String s = "Hello, World!";

// 포함 여부
s.contains("World");   // true
s.startsWith("Hello"); // true
s.endsWith("!");        // true

// 검색
s.indexOf("World");     // 7  — 처음 등장하는 위치
s.lastIndexOf("l");     // 10 — 마지막으로 등장하는 위치
s.indexOf("xyz");       // -1 — 못 찾으면 -1

// 치환
s.replace("World", "Java"); // "Hello, Java!"
s.replaceAll("\\w+", "*");  // "*, *!" — 정규식 사용

// 문자 → 문자열 변환
String.valueOf(42);     // "42"
String.valueOf(true);   // "true"
String.valueOf('A');    // "A"

import java.util.regex.Pattern;
import java.util.regex.Matcher;

// 이메일 형식 검증 (간단 버전)
String email = "user@example.com";
String regex = "^[\\w.-]+@[\\w.-]+\\.\\w{2,}$";

// 방법 1: String의 matches()
boolean isValid = email.matches(regex); // true

// 방법 2: Pattern + Matcher (반복 사용 시 성능 유리)
Pattern pattern = Pattern.compile(regex); // 패턴 컴파일 (한 번만)
Matcher matcher = pattern.matcher(email);
boolean isValid2 = matcher.matches();     // true

// 날짜에서 년, 월, 일 추출하기
String date = "2026-03-19";
Pattern p = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
Matcher m = p.matcher(date);

if (m.matches()) {
    String year = m.group(1);  // "2026"
    String month = m.group(2); // "03"
    String day = m.group(3);   // "19"
    System.out.println(year + "년 " + month + "월 " + day + "일");
}

// HTML 태그 제거
String html = "<p>Hello <b>World</b></p>";
String text = html.replaceAll("<[^>]+>", ""); // "Hello World"

// 연속 공백을 하나로
String messy = "hello    world   java";
String clean = messy.replaceAll("\\s+", " "); // "hello world java"

// 전화번호 형식 변환
String phone = "01012345678";
String formatted = phone.replaceAll("(\\d{3})(\\d{4})(\\d{4})", "$1-$2-$3");
// "010-1234-5678"

// 권장: 패턴을 상수로 선언
private static final Pattern EMAIL_PATTERN =
    Pattern.compile("^[\\w.-]+@[\\w.-]+\\.\\w{2,}$");

public boolean isValidEmail(String email) {
    return EMAIL_PATTERN.matcher(email).matches();
}

// 기존 방식 — 읽기도 쓰기도 고통스럽다
String json = "{\n" +
    "  \"name\": \"홍길동\",\n" +
    "  \"age\": 25,\n" +
    "  \"email\": \"hong@example.com\"\n" +
    "}";

// 텍스트 블록 — Java 13+ (정식: Java 15)
String json = """
        {
          "name": "홍길동",
          "age": 25,
          "email": "hong@example.com"
        }
        """;

// 1. 여는 """ 뒤에 바로 내용을 쓸 수 없다 (줄바꿈 필수)
String s = """
        내용은 여기서부터
        """;

// 2. 닫는 """의 위치가 들여쓰기 기준점이 된다
String a = """
        Hello
        World
        """;
// 결과: "Hello\nWorld\n" — 닫는 """가 같은 들여쓰기

String b = """
Hello
World
""";
// 결과: "Hello\nWorld\n" — 들여쓰기 없음

// 3. formatted()와 조합 가능 (Java 15+)
String html = """
        <html>
          <body>
            <p>안녕하세요, %s님!</p>
          </body>
        </html>
        """.formatted("홍길동");

// CSV 한 줄을 파싱해서 객체 리스트로 변환
String csvData = """
        이름,나이,이메일
        홍길동,25,hong@example.com
        김영희,30,kim@example.com
        박철수,28,park@example.com
        """;

String[] lines = csvData.strip().split("\n"); // 줄 단위로 분리
String[] headers = lines[0].split(",");       // 헤더 추출

for (int i = 1; i < lines.length; i++) {
    String[] fields = lines[i].split(",");
    // 각 필드를 이름, 나이, 이메일로 매핑
    String name = fields[0];
    int age = Integer.parseInt(fields[1]);
    String email = fields[2];
    System.out.println(name + " (" + age + "세) - " + email);
}

// 로그에서 ERROR 레벨만 추출하고, 타임스탬프와 메시지를 분리
String log = """
        2026-03-19 10:00:01 [INFO] 서버 시작됨
        2026-03-19 10:00:05 [ERROR] DB 연결 실패: timeout
        2026-03-19 10:00:10 [INFO] 재시도 중...
        2026-03-19 10:00:15 [ERROR] DB 연결 실패: connection refused
        """;

Pattern logPattern = Pattern.compile(
    "(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}) \\[ERROR\\] (.+)"
);

// 각 줄에서 ERROR 패턴을 찾아 추출
for (String line : log.strip().split("\n")) {
    Matcher m = logPattern.matcher(line);
    if (m.matches()) {
        String timestamp = m.group(1); // 타임스탬프
        String message = m.group(2);   // 에러 메시지
        System.out.println("[" + timestamp + "] " + message);
    }
}
// 출력:
// [2026-03-19 10:00:05] DB 연결 실패: timeout
// [2026-03-19 10:00:15] DB 연결 실패: connection refused

// 간단한 템플릿 치환 엔진
String template = "안녕하세요, {{name}}님! {{count}}개의 새 알림이 있습니다.";

// 치환할 데이터
Map<String, String> data = Map.of(
    "name", "홍길동",
    "count", "3"
);

// {{key}}를 찾아서 값으로 치환
String result = template;
for (Map.Entry<String, String> entry : data.entrySet()) {
    result = result.replace("{{" + entry.getKey() + "}}", entry.getValue());
}
System.out.println(result);
// "안녕하세요, 홍길동님! 3개의 새 알림이 있습니다."