String json = """
    {
      "name": "Java",
      "ver": 21
    }
    """;
// 출력: {\n  "name": "Java",\n  "ver": 21\n}\n
// 닫는 """의 위치가 공통 들여쓰기 기준. 마지막 줄바꿈이 포함된다(닫는 """가 다음 줄에 있으면).

Matcher m = Pattern.compile("\\d").matcher("a1b2");
StringBuilder sb = new StringBuilder();
while (m.find()) m.appendReplacement(sb, "<" + m.group() + ">");
m.appendTail(sb);
// 출력: a<1>b<2>

// 플래그(대소문자 무시)
boolean ci = Pattern.compile("java", Pattern.CASE_INSENSITIVE)
    .matcher("JAVA").matches(); // true

// 모든 일치를 Stream으로 수집(JDK 9+)
List<String> nums = Pattern.compile("\\d+")
    .matcher("a1b22c333")
    .results().map(MatchResult::group).toList();
// [1, 22, 333]

// 이름 있는 그룹을 ${name}으로 치환
String d = "2024-05-17".replaceAll(
    "(?<y>\\d{4})-(?<m>\\d{2})-(?<d>\\d{2})",
    "${d}.${m}.${y}"); // "17.05.2024"

// 함수로 치환: 숫자를 2배로(JDK 9+)
String r = Pattern.compile("\\d+").matcher("a1b22")
    .replaceAll(mr ->
        String.valueOf(Integer.parseInt(mr.group()) * 2));
// "a2b44"

// 부분 일치 Predicate로 필터링
List<String> has = Stream.of("a1", "bb", "c2")
    .filter(Pattern.compile("\\d").asPredicate())
    .toList(); // [a1, c2]

static String maskName(String name) {
    if (name == null || name.length() < 2) return name;
    if (name.length() == 2) return name.charAt(0) + "*";
    return name.charAt(0) + "*".repeat(name.length() - 2) + name.charAt(name.length() - 1);
}
static String maskPhone(String phone) {
    return phone.replaceAll("(\\d{3})-?(\\d{3,4})-?(\\d{4})", "$1-****-$3");
}
static String maskCard(String card) {
    return card.replaceAll("(\\d{4})-(\\d{4})-(\\d{4})-(\\d{4})", "$1-****-****-$4");
}
static String maskEmail(String email) {
    return email.replaceAll("(?<=.{2}).(?=[^@]*@)", "*");
}

maskName("홍길동");  maskName("김철");  maskName("남궁민수");
// 출력: 홍*동  김*  남**수
maskPhone("010-1234-5678");  maskPhone("01012345678");
// 출력: 010-****-5678  010-****-5678
maskCard("1234-5678-9012-3456");
// 출력: 1234-****-****-3456
maskEmail("hong.gildong@example.com");
// 출력: ho**********@example.com

static List<String> parseCsvLine(String line) {
    List<String> out = new ArrayList<>();
    StringBuilder cur = new StringBuilder();
    boolean inQuotes = false;
    for (int i = 0; i < line.length(); i++) {
        char c = line.charAt(i);
        if (inQuotes) {
            if (c == '"') {
                if (i + 1 < line.length() && line.charAt(i + 1) == '"') { cur.append('"'); i++; }
                else inQuotes = false;
            } else cur.append(c);
        } else {
            if (c == '"') inQuotes = true;
            else if (c == ',') { out.add(cur.toString()); cur.setLength(0); }
            else cur.append(c);
        }
    }
    out.add(cur.toString());
    return out;
}

parseCsvLine("1,\"Kim, Chul\",\"say \"\"hi\"\"\",,30");
// 출력: [1, Kim, Chul, say "hi", , 30]

static String camelToSnake(String s) {
    return s.replaceAll("([a-z0-9])([A-Z])", "$1_$2")
            .replaceAll("([A-Z])([A-Z][a-z])", "$1_$2")
            .toLowerCase();
}
static String snakeToCamel(String s) {
    StringBuilder sb = new StringBuilder();
    boolean upper = false;
    for (char c : s.toLowerCase().toCharArray()) {
        if (c == '_') { upper = true; continue; }
        sb.append(upper ? Character.toUpperCase(c) : c);
        upper = false;
    }
    return sb.toString();
}

camelToSnake("userFirstName");  camelToSnake("HTTPServerURL");  camelToSnake("id");
// 출력: user_first_name  http_server_url  id
snakeToCamel("user_first_name");  snakeToCamel("ID");
// 출력: userFirstName  id

String status = null;

"ACTIVE".equals(status);                 // 출력: false (NPE 없음)
Objects.equals(status, "ACTIVE");        // 출력: false
Objects.equals(null, null);              // 출력: true
Objects.toString(status, "-");           // 출력: -
Objects.requireNonNullElse(status, "N/A"); // 출력: N/A
Optional.ofNullable(status).map(String::strip).filter(s -> !s.isEmpty()).orElse("(empty)");
// 출력: (empty)

// 널 안전 isBlank
static boolean isBlank(String s) { return s == null || s.isBlank(); }

static String padLeft(String s, int width, char pad) {
    return s.length() >= width ? s : String.valueOf(pad).repeat(width - s.length()) + s;
}
static String padRight(String s, int width, char pad) {
    return s.length() >= width ? s : s + String.valueOf(pad).repeat(width - s.length());
}
static String fixed(String s, int width) {           // 넘치면 자르고, 모자라면 공백 채움
    if (s.length() > width) return s.substring(0, width);
    return String.format("%-" + width + "s", s);
}

padLeft("42", 6, '0');      // 출력: 000042
padRight("ab", 5, '.');     // 출력: ab...
padLeft("toolong", 3, ' '); // 출력: toolong (자르지 않음)
fixed("한글", 6);           // 출력: [한글    ]
fixed("abcdefgh", 6);       // 출력: [abcdef]
String.format("%05d", 42);  // 출력: 00042

static boolean isNumeric(String s) { return s != null && s.matches("-?\\d+(\\.\\d+)?"); }
static String capitalize(String s) { return s.isEmpty() ? s : Character.toUpperCase(s.charAt(0)) + s.substring(1); }
static String reverseWords(String s) {
    List<String> w = Arrays.asList(s.split(" "));
    Collections.reverse(w);
    return String.join(" ", w);
}
static int countOccur(String s, String sub) {
    int count = 0, idx = 0;
    while ((idx = s.indexOf(sub, idx)) != -1) { count++; idx += sub.length(); }
    return count;
}

isNumeric("123"); isNumeric("12.3"); isNumeric("-5"); isNumeric(""); isNumeric("1e3");
// 출력: true true true false false
capitalize("hello");                        // 출력: Hello
reverseWords("hello big world");            // 출력: world big hello
countOccur("banana", "an");                 // 출력: 2
"010-1234-5678".replaceAll("[^0-9]", "");   // 출력: 01012345678
new StringBuilder("abc").reverse();         // 출력: cba

private static final Pattern PHONE = Pattern.compile("^01[016789]-?\\d{3,4}-?\\d{4}$");
private static final Pattern EMAIL = Pattern.compile("^[\\w.+-]+@[\\w-]+(\\.[\\w-]+)+$");
private static final Pattern KOREAN_NAME = Pattern.compile("^[가-힣]{2,5}$");

PHONE.matcher("010-1234-5678").matches();     // 출력: true
EMAIL.matcher("[email protected]").matches(); // 출력: true
KOREAN_NAME.matcher("홍gil").matches();        // 출력: false

// 텍스트에서 모든 전화번호 추출
Pattern.compile("01[016789]-\\d{3,4}-\\d{4}").matcher("A 010-1111-2222, B 011-333-4444")
       .results().map(MatchResult::group).toList();
// 출력: [010-1111-2222, 011-333-4444]

String h = "hel";
("hel" + "lo") == "hello";   // true  — 컴파일 타임 상수라 Pool 공유
(h + "lo") == "hello";       // false — 런타임 결합은 새 객체
(h + "lo").equals("hello");  // true  ← 항상 이렇게

"a.b.c".replaceAll(".", "-");   // "-----"  (.은 모든 문자)
"a.b.c".replace(".", "-");      // "a-b-c"  (리터럴)
"a.b.c".split(".");             // []       (빈 배열!)
"a.b.c".split("\\.");           // [a, b, c]
"a|b".split("|");               // [a, |, b]
"a|b".split("\\|");             // [a, b]

"a,b,,".split(",").length;       // 2  — 뒤의 빈 칸 2개가 사라짐
"a,b,,".split(",", -1).length;   // 4  — CSV 컬럼 수를 유지하려면 limit -1

String s = "";
for (int i = 0; i < 100_000; i++) s += i;       // 매번 새 String 생성, O(n²)

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100_000; i++) sb.append(i);  // O(n)
String s = sb.toString();

'a' + 'b'            // 195      (int 덧셈)
"" + 'a' + 'b'       // "ab"
1 + 2 + "3" + 4 + 5  // "3345"   (왼쪽부터: 3 → "33" → "334" → "3345")
"a" + null           // "anull"  (NPE 아님)

new StringBuilder("a").equals(new StringBuilder("a"));   // false (참조 비교)
new StringBuilder("a").toString().equals("a");           // true
"a".contentEquals(new StringBuilder("a"));               // true

byte[] b = "한글".getBytes();            // 환경 의존 (JDK 18+ 기본 UTF-8이지만 명시 권장)
byte[] b = "한글".getBytes(StandardCharsets.UTF_8);   // 항상 6바이트
new String(b, StandardCharsets.UTF_8);                // "한글"
new String("한글".getBytes("EUC-KR"), StandardCharsets.UTF_8);  // "�ѱ�" 깨짐

"abc1".matches("[a-z]+");                              // false (전체 일치)
Pattern.compile("[a-z]+").matcher("abc1").find();       // true  (부분 일치)
Pattern.compile("[a-z]+").matcher("abc1").lookingAt();  // true  (앞부분 일치)