[Java] String 클래스

서론

c언어 같은 경우 문자열을 char형의 배열로 다루었지만 자바에서는 문자열을 위한 클래스를 제공합니다. 그것이 바로 String 클래스인데, String 클래스는 문자열을 저장하고 이를 다루는데 필요한 수많은 메서드들을 함께 제공합니다. 이번 게시글에서는 이러한 String 클래스의 구성과 메서드들에 대해 한번 정리해 보겠습니다.

목차

1. 변경 불가능한(immutable) 클래스
2. 문자열의 비교(리터럴 vs 인스턴스, == vs equals)
3. 문자열 리터럴
4. String 클래스의 생성자와 메서드 

 

1) 변경 불가능한(immutable) 클래스

한번 생성된 String 인스턴스가 갖고 있는 문자열은 읽어 올 수만 있고, 변경할 수는 없습니다. 예를 들어 아래의 코드와 같이 '+'연산자를 이용해서 문자열을 결합하는 경우 인스턴스 내의 문자열이 바뀌는 것이 아니라 새로운 문자열("ab")이 담긴 String 인스턴스가 생성되는 것입니다.

    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        a = a + b;
    }

새로운 인스턴스 생성

이처럼 덧셈 연산자 '+'를 사용해서 문자열을 결합하는 것은 매 연산 시마다 새로운 문자열을 가진 String 인스턴스가 생성되어 메모리 공간을 차지하게 되므로 가능한 결합 횟수를 줄이는 것이 좋습니다.

문자열간의 결합이나 추출 등 문자열을 다루는 작업이 많이 필요한 경우에는 String 클래스 대신 StringBuffer 클래스를 사용하는 것이 좋습니다. StringBuffer 인스턴스에 저장된 문자열은 변경이 가능하므로 하나의 StringBuffer 인스턴스만으로도 문자열을 다루는 것이 가능합니다.

 

2-1) 문자열의 비교(리터럴 vs 인스턴스)

문자열을 만들 때에는 두 가지 방법이 있습니다.

1. 문자열 리터럴을 지정하는 방법 (String s = "abc");
2. String 클래스의 생성자를 사용해서 만드는 방법(String s = new String("abc"));

    public static void main(String[] args) {
        String str1 = "abc";    // 문자열 리터럴 "abc"의 주소가 str1에 저장됨
        String str2 = "abc";    // 문자열 리터럴 "abc"의 주소가 str2에 저장됨
        String str3 = new String("abc");    // 새로운 String 인스턴스를 생성
        String str4 = new String("abc");    // 새로운 String 인스턴스를 생성
    }

String 클래스의 생성자를 이용한 경우에는 new 연산자에 의해서 메모리 할당이 이루어지기 때문에 항상 새로운 String 인스턴스가 생성됩니다. 그러나 문자열 리터럴은 이미 존재하는 것을 재사용합니다. (문자열 리터럴은 클래스가 메모리에 로드될 때 자동적으로 미리 생성됩니다.)

따라서 위 코드가 실행되었을 때 상황을 이미지로 나타내면 아래와 같습니다.

좌) 문자열 리터럴 지정, 우) String클래스 생성자

 

2-2) 문자열의 비교('==' vs 'equals')

자바에서 == 연산은 주소 값이 같은지 아닌지 비교하지만, equals() 연산은 내부적으로 주소 값을 비교하지만 String 클래스에서 equals()를 오버라이딩하여 주소 값이 아닌 값을 비교하도록 재정의 되어 있습니다. 아래 코드를 한번 살펴봅시다.

    public static void main(String[] args) {
    
        String str1 = "abc";    // 문자열 리터럴 "abc"의 주소가 str1에 저장됨
        String str2 = "abc";    // 문자열 리터럴 "abc"의 주소가 str2에 저장됨
        String str3 = new String("abc");    // 새로운 String 인스턴스를 생성
        String str4 = new String("abc");    // 새로운 String 인스턴스를 생성
        
        if (str1 == str2) System.out.println("true");
        else System.out.println("false");   
        if (str3 == str4) System.out.println("true");
        else System.out.println("false");
        
        System.out.println("str1.equals(str2)= " + str1.equals(str2));      
        System.out.println("str3.equals(str4)= " + str3.equals(str4));
    }

실행 결과

equals()를 사용했을 때는 두 문자열의 내용("abc")을 비교하기 때문에 전부 true를 결과로 얻습니다. 하지만, 각 String 인스턴스의 주소를 등가비교연산자 '=='로 비교했을 때는 결과가 다르게 나옵니다.

 

3) 문자열 리터럴

자바 소스파일에 포함된 모든 문자열 리터럴은 컴파일 시에 클래스 파일에 저장됩니다. 이 때 같은 내용의 문자열 리터럴은 한 번만 저장됩니다. 문자열 리터럴도 String 인스턴스이고, 한번 생성하면 내용을 변경할 수 없으니 하나의 인스턴스를 공유하면 되기 때문입니다.

public class Test {
    public static void main(String[] args) {
        String s1 = "AAA";
        String s2 = "AAA";
        String s3 = "AAA";
        String s4 = "AAA";
    }
}

위 코드를 실행하면 "AAA"를 담고 있는 String 인스턴스가 하나 생성된 후, 참조변수 s1, s2, s3는 모두 이 같은 String 인스턴스를 참조하게 됩니다.

클래스 파일에는 소스파일에 포함된 모든 리터럴의 목록이 있습니다. 해당 클래스 파일이 클래스 로더에 의해 메모리에 올라갈 때, 이 리터럴의 목록에 있는 리터럴들이 JVM내에 있는 '상수 저장소(constant pool)'에 저장됩니다. 이때, 이곳에 "AAA"와 같은 문자열 리터럴이 자동적으로 생성되어 저장되는 것입니다.

클래스 로더가 메모리에 올라가는 과정과 JVM의 구성요소 같은 경우 제가 이전에 정리한 게시글이 있으니 참고하실 때 도움이 될 것 같습니다.

[Java] JVM의 메모리 구성요소와 영역에 관한 고찰

 

4) String 클래스의 생성자와 메서드

1. String(String s)

 /*
    주어진 문자열(s)을 갖는 String 인스턴스를 생성한다.
 */
 
String s = new String ("Hello");
System.out.println(s);

// 출력결과: Hello

 

2. String[char[] value)

 /*
    주어진 문자열(value)을 갖는 String 인스턴스를 생성한다.
 */
 
char[] c = {'H', 'e', 'l', 'l', 'o'};
String s = new String(c);
System.out.println(s);

// 출력결과: Hello

 

3. String(StringBuffer buf)

 /*
    StringBuffe 인스턴스가 갖고 있는 문자열과 같은 내용의 String 인스턴스를 생성한다.
 */
 
StringBuffer sb = new StringBuffer("Hello");
String s = new String(sb);
System.out.println(sb);

// 출력결과: Hello

 

4. charAt(index)

 /*
    지정된 위치(index)에 있는 문자를 알려준다.(index는 0부터 시작)
 */
 
String s = "Hello";
System.out.println(s.charAt(1));

// 출력결과: e

 

4. int compareTo(String str)

 /*
    문자열(str)과 사전순서로 비교한다.
    같으면 0, 사전순으로 이전이면 음수, 이후면 양수를 반환한다.
 */
 
int i = "aaa".compareTo("aaa");
int i2 = "aaa".compareTo("bbb");
int i3 = "bbb".compareTo("aaa");

System.out.println(i);
System.out.println(i2);
System.out.println(i3);

// 출력결과: 0, 1, 3

 

5. String concat(String str)

 /*
    문자열(str)을 뒤에 덧붙인다.
 */
 
String s = "Hello";
String s2 = s.concat(" World");
System.out.println(s2);

// 출력결과: Hello World

 

6. boolean endsWith(String suffix)

 /*
    지정된 문자열(suffix)로 끝나는지 검사한다.
 */
 
String s = "Hello.txt";
boolean b = s.endsWith("txt");
System.out.println(b);

// 출력결과: true

 

7. boolean contains(CharSequence s)

 /*
    지정된 문자열(s)이 포함되어있는지 검사한다.
 */
 
String s = "abcedfg";
boolean b = s.contains("bc");
System.out.println(b);

// 출력결과: true

 

8. boolean equalsIgnoreCase(String str)

 /*
    문자열과 String 인스턴스의 문자열을 대소문자 구분없이 비교한다.
 */
 
String s = "Hello";
boolean b = s.equalsIgnoreCase("hello");
System.out.println(b);

// 출력결과: true

 

9. int indexOf(int ch)

 /*
    주어진 문자(ch)가 문자열에 존재하는지 확인하여 위치(index)를 알려준다. 
    못 찾으면 -1을 반환한다.(index는 0부터 시작)
 */
 
String s = "Hello";
int idx1 = s.indexOf('o');
int idx2 = s.indexOf('k');

System.out.println(idx1);
System.out.println(idx2);

// 출력결과: 4, -1

 

10. int indexOf(int ch, int pos)

 /*
    주어진 문자(ch)가 문자열에 존재하는지 지정된 위치(pos)부터 확인하여 위치(index)를 알려준다.
    못 찾으면 -1을 반환한다.(index 는 0부터 시작)
 */
 
String s = "Hello";
int idx1 = s.indexOf('e', 0);
int idx2 = s.indexOf('e' ,2);

System.out.println(idx1);
System.out.println(idx2);

// 출력결과: 1, -1

 

11. int indexOf(String str)

 /*
    주어진 문자열이 존재하는지 확인하여 그 위치(index)를 알려준다.
    없으면 -1을 반환한다.(index는 0부터 시작)
 */
 
String s = "ABCDEFG";
int idx = s.indexOf("CD");

System.out.println(idx);

// 출력결과: 2

 

12. String intern()

 /*
    문자열을 상수풀(constant pool)에 등록한다.
    이미 상수풀에 같은 내용의 문자열이 있을 경우 그 문자열의 주소값을 반환한다.
 */
 
String s = new String("abc");
String s2 = new String("abc");
boolean b = (s == s2);
boolean b2 = s.equals(s2);
boolean b3 = (s.intern() == s2.intern());

System.out.println(b);
System.out.println(b2);
System.out.println(b3);

// 출력결과: false, true, true

 

13. int lastIndexOf(int ch)

 /*
    지정된 문자 또는 문자코드를 문자열의 오른쪽 끝에서부터 찾아서 위치(index)를 알려준다.
    못 찾으면 -1을 반환한다.
 */
 
String s = "java.lang.Object";
int idx1 = s.lastIndexOf('.');
int idx2 = s.indexOf('.');

System.out.println(idx1);
System.out.println(idx2);

// 출력결과: 9, 4

 

14. int lastIndexOf(String str)

 /*
    지정된 문자열을 인스턴스의 문자열 끝에서부터 찾아서 위치(index)를 알려준다.
    못 찾으면 -1을 반환한다.
 */
 
String s = "java.lang.java";
int idx1 = s.lastIndexOf("java");
int idx2 = s.indexOf("java");

System.out.println(idx1);
System.out.println(idx2);

// 출력결과: 10, 0

 

15. String trim()

 /*
    문자열의 왼쪽 끝과 오른쪽 끝에 있는 공백을 없앤 결과를 반환한다.
    이 때 문자열 중간에 있는 공백은 제거되지 않는다.
 */
 
String s = "     Hello World    ";
String s1 = s.trim();

System.out.println(s1);
// 출력결과: Hello World

 

16. boolean startsWith(String prefix)

 /*
    주어진 문자열(prefix)로 시작하는지 검사한다.
 */
 
String s = "java.lang.Object";
boolean b = s.startsWith("java");
boolean b2 = s.startsWith("lang");

System.out.println(b);
System.out.println(b2);

// 출력결과: true, false

 

17. String replace(char old, char new)

 /*
    문자열 중의 문자(old)를 새로운 문자(new)로 바꾼 문자열을 반환한다.
 */
 
String s = "Hello";
String s1 = s.replace('H', 'h');

System.out.println(s1);

// 출력결과: hello

 

18. String replace(CharSequence old, CharSequence new)

 /*
    문자열 중의 문자열(old)을 새로운 문자열(new)로 모두 바꾼 문자열을 반환한다.
 */
 
String s = "Hello";
String s1 = s.replace("ll", "LL");

System.out.println(s1);

// 출력결과: HeLLo

 

19. String replaceAll(String regex, String replacement)

 /*
    문자열 중에서 지정된 문자열(regex)과 일치하는 것을 새로운 문자열(replacement)로 모두 변경한다.
 */
 
String ab = "AABBAABB";
String r = ab.replaceAll("BB", "bb");
        
System.out.println(r);

// 출력결과: AAbbAAbb

 

20. String replaceFirst(String regex, String replacement)

 /*
    문자열 중에서 지정된 문자열(regex)과 일치하는 것 중, 첫 번째 것만 새로운 문자열(replacement)로 변경한다.
 */
 
String ab = "AABBAABB";
String r = ab.replaceAll("BB", "bb");
        
System.out.println(r);

// 출력결과: AAbbAABB

 

21. Srtring [] split(String regex)

 /*
    문자열을 지정된 분리자(regex)로 나누어 문자열 배열에 담아 반환한다.
 */
 
String animals = "dog,cat,bear";
String [] arr  = animals.split(",");
        
// arr[0] = dog, arr[1] = cat, arr[2] = bear