Everybody knows String Class is immutable ,String Class is final Modified class .final understand

Immutable object ： After an object is created , You can't change its state , Then this object is immutable .

------------------------- The inability to change its state means that the member variables in the object cannot be changed , Include values of basic data types , Reference type variables cannot point to other objects .

Here's an example. Let's take a look at ：

String cx ="abc";
System.out.println(cx);
cx = "nice";
System.out.println(cx);

Output results ：

abc

nice

We all know that it is also very simple , But how exactly does it work ？

First create a String The object of , Put the value into the string constant pool . We first make cx Yes abc value , And then it points to nice value , From the print results , What we call immutable objects has changed ... Here is a big misunderstanding ：cx It's a String References to objects （ Reference data type ）, Not the object itself . The reason why it has changed It's changing cx The direction of , It has always been used to point to the word .

------------------------------- Access the contents of an object by pointing to its address .

When we point to nice He will check whether there is this value in our string constant pool , If so, return the address of this object directly , If not, create a new object and return the address .

So the change is cx The direction of , instead of String Object itself ！.

Let's see 1.7JAVA Of String Class source code ：

public final class String   
    implements java.io.Serializable, Comparable<String>, CharSequence {   
    /** The value is used for character storage. */   
    private final char value[];   
 
    /** Cache the hash code for the string */   
    private int hash; // Default to 0 

Here we can see that in fact String Class is the encapsulation of a character array . But this value He is also a quote , It points to a data object .

cx-------char value[]------ Array [a,b,c][n,i,c,e]

because value It is private, so it cannot be modified externally . And it's still final Of , That is to say, once String It's initialized , Then it can't be changed .

Let's take another example :

String cx ="cx";
System.out.println(cx);
cx = cx.replace("c", "C");
System.out.println(cx);

Output results :

cx

Cx

Here we see cx The value of has changed , But it's String The object has not changed . principle ：

When we call replace Method time , Its interior finally returns a new String The object gave it to us , So in the beginning cx The point is String The object has not changed , Just returned a new changed object to us , We just got the output .

If we look at this example, it will be clear in an instant ：

String cx ="cx";
System.out.println(cx);
cx.replace("c", "C");
System.out.println(cx);

Output results ;

cx

cx

The result is unchanged , That's why when we use replace、subString、toLowerCase When waiting for the method, it returns us a String Object's .

So let's see replace Source code :

 public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = count;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */
            int off = offset;   /* avoid getfield opcode */
     
            while (++i < len) {
                if (val[off + i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                char buf[] = new char[len];
                for (int j = 0 ; j < i ; j++) {
                    buf[j] = val[off+j];
                }
                while (i < len) {
                    char c = val[off + i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                <span style="color:#ff0000;">return new String(0, len, buf);</span>
            }
        }
        return this;
    }

After reading it, everyone has an epiphany .

But what? , Through reflection, we can still be right String To change the contents of the class . This is the concept of reflection , I won't mention . We don't usually do this .

We just need to understand String Class is immutable ！