불변 개체는 내부 필드 (또는 외부 동작에 영향을 미치는 모든 내부 필드)를 변경할 수없는 개체입니다.

변경 불가능한 문자열에는 많은 장점이 있습니다.

성능 : 다음 작업을 수행하십시오.

String substring = fullstring.substring(x,y);

substring () 메소드의 기본 C는 다음과 같습니다.

// Assume string is stored like this:
struct String { char* characters; unsigned int length; };

// Passing pointers because Java is pass-by-reference
struct String* substring(struct String* in, unsigned int begin, unsigned int end)
{
    struct String* out = malloc(sizeof(struct String));
    out->characters = in->characters + begin;
    out->length = end - begin;
    return out;
}

유의하십시오 문자 것도 복사 할 필요가! String 객체가 변경 가능하면 (문자가 나중에 변경 될 수 있음) 모든 문자를 복사해야합니다. 그렇지 않으면 하위 문자열의 문자 변경 사항이 나중에 다른 문자열에 반영됩니다.

동시성 : 불변 개체의 내부 구조가 유효한 경우 항상 유효합니다. 다른 스레드가 해당 개체 내에서 유효하지 않은 상태를 만들 가능성은 없습니다. 따라서 불변의 객체는 Thread Safe 입니다.

가비지 수집 : 가비지 수집기가 불변 개체에 대한 논리적 결정을 내리는 것이 훨씬 쉽습니다.

그러나 불변성에 대한 단점도 있습니다.

성능 : 잠깐, 성능이 불변성의 단점이라고 생각했습니다! 글쎄, 때로는 그렇지는 않지만 항상 그런 것은 아닙니다. 다음 코드를 사용하십시오.

foo = foo.substring(0,4) + "a" + foo.substring(5);  // foo is a String
bar.replace(4,5,"a"); // bar is a StringBuilder

두 줄 모두 네 번째 문자를 문자 “a”로 바꿉니다. 두 번째 코드는 더 읽기 쉽고 빠를뿐입니다. foo에 대한 기본 코드를 어떻게 수행해야하는지 살펴보십시오. 부분 문자열은 쉽지만, 이제 5 번째 공간에 문자가 있고 foo를 참조하는 다른 문자가 있기 때문에 변경할 수는 없습니다. 전체 문자열을 복사해야합니다 (물론이 기능 중 일부는 실제 기본 C의 함수로 추상화되었지만 여기서 요점은 한 곳에서 모두 실행되는 코드를 표시하는 것입니다).

struct String* concatenate(struct String* first, struct String* second)
{
    struct String* new = malloc(sizeof(struct String));
    new->length = first->length + second->length;

    new->characters = malloc(new->length);

    int i;

    for(i = 0; i < first->length; i++)
        new->characters[i] = first->characters[i];

    for(; i - first->length < second->length; i++)
        new->characters[i] = second->characters[i - first->length];

    return new;
}

// The code that executes
struct String* astring;
char a = 'a';
astring->characters = &a;
astring->length = 1;
foo = concatenate(concatenate(slice(foo,0,4),astring),slice(foo,5,foo->length));

연결은 두 번 호출 되므로 전체 문자열을 반복해야합니다. bar작업을 위해 이것을 C 코드와 비교하십시오 .

bar->characters[4] = 'a';

변경 가능한 문자열 작업이 훨씬 빠릅니다.

결론 : 대부분의 경우 변경 불가능한 문자열을 원합니다. 그러나 문자열에 많은 추가 및 삽입 작업이 필요한 경우 속도에 대한 변경 가능성이 필요합니다. 동시성 안전 및 가비지 콜렉션 이점을 원하는 경우 변경 가능한 오브젝트를 메소드의 로컬에 유지하는 것이 중요합니다.

// This will have awful performance if you don't use mutable strings
String join(String[] strings, String separator)
{
    StringBuilder mutable;
    boolean first = true;

    for(int i = 0; i < strings.length; i++)
    {
        if(!first) first = false;
        else mutable.append(separator);

        mutable.append(strings[i]);
    }

    return mutable.toString();
}

때문에 mutable객체가 로컬 참조이며, 당신은 동시성의 안전에 대해 걱정할 필요가 없습니다 (하나의 스레드는 이제까지 그것을 접촉). 그리고 다른 곳에서는 참조되지 않기 때문에 스택에만 할당되므로 함수 호출이 완료되는 즉시 할당이 해제됩니다 (가비지 수집에 대해 걱정할 필요가 없습니다). 또한 가변성과 불변성의 성능 이점을 모두 얻을 수 있습니다.

답변

public class ColoredString {

    private String color;
    private String string;

    public ColoredString(String color, String string) {
        this.color  = color;
        this.string = string;
    }

    public String getColor()  { return this.color;  }
    public String getString() { return this.string; }

    public void setColor(String newColor) {
        this.color = newColor;
    }

}

new ColoredString("Blue", "This is a blue string!");

blueString.setColor("Red");

//s1 variable, refers to string in memory
        reference                 |     MEMORY       |
        variables                 |                  |

           [s1]   --------------->|   "Old String"   |

//s2 refers to same string as s1
                                  |                  |
           [s1]   --------------->|   "Old String"   |
           [s2]   ------------------------^

//s1 deletes reference to old string and points to the newly created one
           [s1]   -----|--------->|   "New String"   |
                       |          |                  |
                       |~~~~~~~~~X|   "Old String"   |
           [s2]   ------------------------^

String foo = "Hello";
foo.substring(3);
<-- foo here still has the same value "Hello"

LocalDate date = LocalDate.of(2014, 3, 18);
date.plusYears(2);
System.out.println(date);

LocalDate date = LocalDate.of(2014, 3, 18);
LocalDate dateAfterTwoYears = date.plusYears(2);