[Java] 문자열 관련 함수 1

✅ 문자열 인덱싱 / 슬라이싱

• charAt(i): i 범위 체크 필요 (IndexOutOfBoundsException 예외 발생 가능)
• 복잡도:
  • charAt == O(1)
  • substring == O(k) (k=잘라낸 길이; Java 9+는 새 배열 복사)
    • substring이 잘라낸 부분을 새 char 배열로 복사하기 때문에 원본과는 독립적인 문자열이 되나 잘라낼 때마다 새 배열이 만들어져 복사 비용 O(k)이 필요!

String s = "Hello";
char c = s.charAt(1);          // 'e'  (0-based)
String sub = s.substring(1, 4); // "ell"  (start 인덱스는 포함, end 인덱스 제외)

 

 

✅ 특정 문자가 있는지 확인

• contains는 부분문자열 검색, 문자 검색은 indexOf(char)가 간단
  • contains("str")는 내부적으로 결국 indexOf("str") >= 0 로직을 호출.
  • 부분문자열: contains가 더 읽기에 직관적.
  • 단일 문자: indexOf(char)가 매개변수 변환 없이 바로 쓸 수 있어 간단하다는 뜻.
• 복잡도: 평균 O(n) (부분문자열 길이에 따라 달라짐)

boolean has = s.contains("ell"); // true

// 한 문자면:
boolean hasChar = s.indexOf('e') >= 0;

 

 

✅ 문자열이 같은지 비교

• 절대 == 로 비교하지 않기. 항상 equals 사용.
  • **== 는 레퍼런스(주소)를** 비교.
  • "ABC" 리터럴은 풀(pool)에 올라가서 동일할 수 있지만, new String("ABC")로 만들면 다른 객체가 됨
  • equals: 내용(문자열 값) 비교. 문자열이 같으면 true.
• 복잡도: 최악인 경우 O(n)
  • equals는 두 문자열을 앞에서부터 차례로 비교하다가 다르면 바로 중단.
  • 두 문자열이 끝까지 똑같거나 마지막에만 다를 경우 전부 비교해야 하므로 최악 O(n)이 됨.

String a = "ABC", b = new String("ABC");

boolean eq = a.equals(b);               // true (값 비교)
boolean eqIgnore = a.equalsIgnoreCase("abc"); // true

 

 

✅ 문자열 길이 반환

• UTF-16 코드 유닛 수를 길이로 반환
• 이모지 등의 코드포인트 길이는 s.codePointCount(0, s.length())
• 복잡도: O(1)

int len = s.length();

 

 

✅ 특정 문자의 인덱스 값 찾기

• 문자를 찾지 못하면 -1 반환.
• 복잡도: O(n)

int i1 = s.indexOf('l');        // 첫 번째 'l' → 2
int i2 = s.indexOf("lo");       // "lo" 시작 인덱스 → 3
int i3 = s.lastIndexOf('l');    // 마지막 'l' → 3

 

 

✅ 문자열을 구분자 기준으로 나누고 합치기

• split은 정규식 기반으로 나눔
  • 메타문자(예: . | ? *등) 쓰면 이스케이프 필요: "\.", "\|"
  • 단순 구분이면 StringTokenizer나 수동 파싱, 또는 Pattern 재사용으로 비용 절감 가능
    • StringTokenizer: "a,b,c" 같은 문자열을 구분자 단위로 잘라 순차적으로 꺼내는 기능 제공. (Java의 옛날 클래스)
    • split(",") 같은 정규식은 호출 때마다 정규식 패턴을 새로 컴파일해 비용이 발생함.
      자주 쓰는 패턴은 미리 Pattern.compile(",") 해두고 재사용하면 더 효율적.
• String.join(delimiter, parts)는 NullPointerException에 주의해야 함 (배열 요소가 null이면 예외).
• 복잡도: O(n)

String csv = "a,b,c";

String[] parts = csv.split(",");              // ["a","b","c"]  (정규식!)
String joined = String.join("-", parts);      // "a-b-c"

 

 

✅ 문자열 대소문자 변환

• 지역화 이슈가 있으면 toUpperCase(Locale.ROOT) 권장.
  • Locale.ROOT = 언어/지역에 영향을 받지 않는 중립적 로케일.
• 복잡도: O(n).

String up = s.toUpperCase();   // "HELLO"
String low = s.toLowerCase();  // "hello"

 

 

✅ 기존 값을 다른 값으로 치환

• 정규식이 필요 없으면 replace 사용(빠르고 안전).
• replaceAll/First는 정규식을 인자로 받음.
• 복잡도: O(n)~O(n*k) (패턴 복잡도에 좌우).
  • 정규식 엔진이 패턴을 해석하는 과정이 필요함.
  • 단순 치환: "abc".replace("a","b") → 문자 그대로 치환이라 빠름.
  • 정규식 치환: "abc".replaceAll(".","b") → 정규식 해석 + 매칭 과정이 추가돼 더 느릴 수 있음

String r1 = s.replace('l', 'L');          // 문자 치환 (비정규식)
String r2 = s.replace("ll", "LL");        // 문자열 치환 (비정규식)
String r3 = s.replaceFirst("\\d+", "#");  // 정규식 첫 매치만
String r4 = s.replaceAll("\\s+", " ");    // 정규식 전체 매치

 

 

✅ 양쪽 끝에서 특정 문자(혹은 공백) 제거

• trim(): 옛날 메서드. 0~32 범위의 ASCII 제어문자 + 공백만 제거. (예: \u0020 스페이스)
• strip(): Java 11 도입. 모든 유니코드 공백 제거. (예: \u2003 EM SPACE 같은 것도 제거됨)
  • EM SPACE (U+2003) = 유니코드에서 정의된 특수 공백 문자.
    보통 대문자 "M"의 폭만큼 넓은 빈칸을 의미 (일반 스페이스보다 훨씬 큼)
• 👉 국제화 환경(한글, 일본어, 특수 공백 포함)에서는 strip을 권장.
• 복잡도: O(n)

String t1 = "  hi  ".trim();           // 앞뒤 공백 제거 (ASCII 공백 중심)
String t2 = "  hi  ".strip();          // 앞뒤 유니코드 공백 제거 (Java 11+)
String t3 = "---hi---".replaceAll("^-+|-+$", ""); // 특정문자('-') 제거(정규식)

 

 

✅ 아스키코드로 변환 혹은 대소 비교

• 문자열 정렬/우선순위는 compareTo 기준(사전순).
• 로케일 민감도 필요하면 Collator.
• 복잡도: 평균 O(k) (k=비교 중 앞부분이 같은 길이).

char ch = 'A';
int code = (int) ch;          // 65 (UTF-16 코드 유닛 값, ASCII 호환 구간 동일)

int cmp1 = "Apple".compareTo("Banana");       // 음수(사전순 앞)
int cmp2 = "a".compareToIgnoreCase("A");      // 0
int cmp3 = Character.compare('a', 'b');       // -1

 

 

✅ 문자열 성능 안전 가이드

1. 문자열 반복 연결은 StringBuilder 사용

StringBuilder sb = new StringBuilder();
for (String p : parts) sb.append(p);
String out = sb.toString();

 

2. 빈번한 정규식은 Pattern을 캐싱

• split, replaceAll, matches 같은 메서드는 내부적으로 정규식을 문자열로 받아서 → Pattern.compile()을 실행.
• Pattern은 정규식을 미리 컴파일해놓은 객체.
• 문자열로 split(","), replaceAll("\s+"," ")를 호출할 때마다 정규식이 매번 컴파일됨!
• Pattern.compile()을 한 번 해두고 재사용하면 성능 최적화에 유리.

// 1) Pattern 객체 생성 (정규식 컴파일)
Pattern pattern = Pattern.compile("\\s+"); // 하나 이상의 공백을 찾는 패턴

// 2) Matcher 생성
Matcher matcher = pattern.matcher("Hello   World   Java");

// 3) replaceAll 사용
String result = matcher.replaceAll(" ");
System.out.println(result); // "Hello World Java"


// 자주 쓰는 메서드
// Pattern.compile(String regex) : 정규식 패턴을 객체로 컴파일
// matcher(CharSequence input) : 입력 문자열에 대해 Matcher 생성
// split(CharSequence input) : 입력 문자열을 정규식 기준으로 분리
// Pattern.matches(regex, input) : 정규식이 입력 전체와 일치하는지 확인 (정적 메서드)


// "String.split()과 Pattern.split()의 차이는?" 
// → 전자는 매번 패턴 컴파일, 후자는 미리 컴파일된 패턴 재사용.

 

3. 문자열 내용 비교 시 ** == 사용 금지**, 항상 equals / equalsIgnoreCase 사용.

 

4. 유니코드 이슈(이모지, 결합 문자)엔 codePoints()나 Normalizer 고려.