[Java] String 클래스가 불변 객체 라고?

String 클래스

 

자바에서 문자를 다루는 대표적인 타입에는 char, String이 있습니다.

public class CharArrayMain {

    public static void main(String[] args) {

        char[] charArr = new char[]{'h', 'e', 'l', 'l', 'o'};
        System.out.println(charArr);

        String str = "hello";
        System.out.println("str = " + str);
    }
}

• 기본형인 char는 문자 하나를 다룰 때 사용한다.
• char를 이용해서 여러 문자를 나열하려면 char[ ] 을 사용해야 한다.
• char[ ]을 다루는 방법은 매우 불편하기 때문에 문자열을 편하게 다룰 수 있는 String 클래스를 제공한다.

 

String 클래스를 통해 문자열을 생성하는 2가지 방법

public class StringBasicMain {

    public static void main(String[] args) {

        String str1 = "hello";
        String str2 = new String("hello");

        System.out.println("str1 = " + str1);
        System.out.println("str2 = " + str2);
    }
}

• 쌍따옴표 사용: "hello"
• 객체 생성: new String("hello")

String str1 = "hello" // 기존
String str1 = new String("hello") // 변경

• String은 클래스이다.
• int, boolean 같은 기본형이 아니라 참조형이다.
• 따라서 str1 변수에는 String 인스턴스의 참조값만 들어갈 수 있다.
• 하지만 문자열은 매우 자주 사용되기 때문에 쌍따옴표로 문자열을 감싸면 자바 언어에서 new String("hello") 와 같이 변경해준다.

 

String 클래스 구조

public final class String {
    
    //문자열 보관
    private final char[] value; // 자바9 이전
    private final byte[] value; // 자바9 이후
    
    //여러 메서드
    public String concat(String str) {...}
    public int length() {...}
    ...

}

클래스이기 때문에 속성과 기능을 가지고 있습니다.

 

속성(필드)

private final char[] value; // 자바9 이전

• 여기에는 String의 실제 문자열 값이 보관된다.
• 문자 데이터 자체는 char[ ]에 보관된다.
• String 클래스를 사용하는 개발자가 편리하게 문자열을 다룰 수 있도록 다양한 기능을 제공한다.
• 메서드 제공을 넘어서 자바 언어 차원에서도 여러 편의 문법을 제공한다.

 

기능(메서드)

• String클래스는 문자열로 처리할 수 있는 다양한 기능을 제공한다.
• 기능이 방대하므로 필요한 기능이 있으면 검색하거나 API 문서를 참고하면 된다.

 

주요 메서드

• length( ) : 문자열의 길이를 반환한다.
• charAt (int index) : 특정 인덱스의 문자를 반환한다.
• substring (int beginIndex, int endIndex) : 문자열의 부분 문자열을 반환한다.
• indexOf (String str) : 특정 문자열이 시작되는 인덱스를 반환한다.
• toLowerCase( ), toUpperCase( ) : 문자열을 소문자 또는 대문자로 변환한다.
• trim( ) : 문자열 양 끝의 공백을 제거한다.
• concat(String str) : 문자열을 더한다.

 

String 클래스와 참조형

• String은 클래스 입니다. 따라서 기본형이 아니라 참조형이다.
• 참조형은 변수에 계산할 수 있는 값이 들어있는 것이 아니라 x001 과 같이 계산할 수 없는 참조값이 들어있다.
• 따라서 원칙적으로는 + 같은 연산을 사용할 수 없다.

public class StringConcatMain {

    public static void main(String[] args) {

        String a = "hello";
        String b = "java";

        String result1 = a.concat(b);
        String result2 = a + b;
        System.out.println("result1 = " + result1);
        System.out.println("result2 = " + result2);
    }
}

result1 = hellojava
result2 = hellojava

• 자바에서 문자열을 더할 때는 String이 제공하는 concat( )과 같은 메서드를 사용해야 한다.
• 하지만 문자열은 너무 자주 다루어지기 때문에 자바 언어에서 편의상 + 연산을 제공한다.

 

String 클래스 비교

String 클래스를 비교할 때는 == 비교가 아니라 항상 equals( ) 비교를 해야합니다.

• 동일성(Identity) : == 연산자를 사용해서 두 객체의 참조가 동일한 객체를 가리키고 있는지 확인
• 동등성(Equality) : equals( ) 메서드를 사용해서 두 객체가 논리적으로 같은지 확인

public class StringEqualsMain1 {

    public static void main(String[] args) {

        String str1 = new String("hello");
        String str2 = new String("hello");
        System.out.println("new String() == 비교: " + (str1 == str2));
        System.out.println("new String() equals 바교: " + (str1.equals(str2)));

        String str3 = "hello";
        String str4 = "hello";
        System.out.println("리터럴 == 비교: " + (str3 == str4));
        System.out.println("리터럴 equals 비교: " + (str3.equals(str4)));
    }
}

new String() == 비교: false
new String() equals 바교: true
리터럴 == 비교: true
리터럴 equals 비교: true

 

new String( ) 비교

• str1과 str2는 new String( )을 사용해서 각각의 인스턴스를 생성했다. 서로 다른 인스턴스 이므로 동일성(==) 비교에 실패한다.
• 둘은 내부에 같은 "hello" 값을 가지고 있기 때문에 논리적으로 같다. 따라서 동등성(equals( )) 비교에 성공한다. 참고로 String 클래스는 내부 문자열 값을 비교하도록 equals( ) 메서드를 재정의 해두었다.

 

문자열 리터럴, 문자열 풀

• String str3 = "hello" 와 같이 문자열 리터럴을 사용하는 경우 자바는 메모리 효율성과 성능 최적화를 위해 문자열 풀을 사용한다.
• 자바가 실행되는 시점에 클래스에 문자열 리터럴이 있다면 문자열 풀에 String 인스턴스를 미리 만들어둔다. 이때 같은 문자열이 있다면 만들지 않는다.
• String str3 = "hello" 와 같이 문자열 리터럴을 사용하면 문자열 풀에서 "hello" 라는 문자를 가진 String 인스턴스를 찾는다. 그리고 찾은 인스턴스의 참조(x003)를 반환한다.
• String str4 = "hello"의 경우 "hello" 문자열 리터럴을 사용하므로 문자열 풀에서 str3 과 같은 x003 참조를 사용한다.
• 문자열 풀 덕분에 같은 문자를 사용하는 경우 메모리 사용을 줄이고 문자를 만드는 시간도 줄어들기 때문에 성능도 최적화 할 수 있다.

따라서 문자열 리터럴을 사용하는 경우 같은 참조값을 가지므로 == 비교에 성공한다.

 

참고: 풀(Pool)
자원이 모여있는 곳을 의미한다. 프로그래밍에서 풀(Pool)은 공용 자원을 모아둔 곳을 뜻한다.
여러 곳에서 함께 사용할 수 있는 객체를 필요할 떄 마다 생성하고, 제거하는 것은 비효율적이다.
대신에 이렇게 문자열 풀에 필요한 String 인스턴스를 미리 만들어두고 여러곳에서 재사용할 수 있다면 성능과
메모리를 더 최적화 할 수 있다. 참고로 문자열 풀은 힙(Heap) 영역을 사용한다. 그리고 문자열 풀에서 문자를 찾을 때는
해시 알고리즘을 사용하기 때문에 매우 빠른 속도로 원하는 String 인스턴스를 찾을 수 있다. 

 

 

"그렇다면 문자열 리터럴을 사용하면 == 비교를 하고,

new String( ) 을 직접 사용하는 경우에만 equals( ) 비교를 사용하면 되는걸까?"

public class StringEqualsMain2 {

    public static void main(String[] args) {

        String str1 = new String("hello");
        String str2 = new String("hello");
        System.out.println("메서드 호출 비교1: " + isSame(str1, str2));

        String str3 = "hello";
        String str4 = "hello";
        System.out.println("메서드 호출 비교2: " + isSame(str3, str4));
    }
    
    private static boolean isSame(String x, String y) {
        return x == y;
    }
}

메서드 호출 비교1: false
메서드 호출 비교2: true

 

main( ) 메서드를 만드는 개발자와 isSame( ) 메서드를 만드는 개발자가 서로 다르다고 가정했을 때

• isSame( )의 경우 매개변수로 넘어오는 String 인스턴스가 new String( )으로 만들어진 것인지, 문자열 리터럴로 만들어진 것인지 확인할 수 있는 방법이 없다.
• 문자열 비교는 항상 equals( )를 사용해서 동등성 비교를 해야 한다.

 

String 클래스 불변 객체

public class StringImmutable1 {

    public static void main(String[] args) {
        String str = "hello";
        str.concat("java");
        System.out.println("str = " + str);
    }
}

str = hello

• String.concat( ) 메서드를 사용하면 기존 문자열에 새로운 문자열을 연결해서 합칠 수 있다.
• 실행 결과를 보면 문자가 전혀 합쳐지지 않았다.

public class StringImmutable2 {

    public static void main(String[] args) {
        String str1 = "hello"; // x001
        String str2 = str1.concat(" java"); // x002
        System.out.println("str = " + str1);
        System.out.println("str2 = " + str2);
    }
}

• String 은 불변 객체이기 때문에 변경이 필요한 경우 기존 값을 변경하지 않고, 대신에 새로운 결과를 만들어서 반환한다.

str1 = hello
str2 = hello java

• String.cancat( )은 내부에서 새로운 String 객체를 만들어서 반환한다.
• 따라서 불변과 기존 객체의 값은 유지한다.

 

String이 불변으로 설계된 이유

 

String이 불변으로 설계된 이유는 앞서 배운 불변 객체에서 배운 내용에 추가로 다음과 같은 이유도 있습니다.

문자열 풀에 있는 String 인스턴스의 값이 중간에 변경되면 같은 문자열을 참고하는 다른 변수의 값도 함께 변경됩니다.

• String은 자바 내부에서 문자열 풀을 통해 최적화를 한다.
• 만약 String 내부의 값을 변경할 수 있다면, 기존에 문자열 풀에서 참조하는 변수의 모든 문자가 함께 변경되어 버리는 문제가 발생한다. 다음의 경우 str3이 참조하는 문자를 변경하면 str4의 문자도 함께 변경되는 사이드 이펙트 문제가 발생한다.
• String 클래스는 불변으로 설계되어 있기 때문에 이런 사이드 이펙트 문제가 생기지 않는다.