国产av日韩一区二区三区精品,成人性爱视频在线观看,国产,欧美,日韩,一区,www.成色av久久成人,2222eeee成人天堂

    String s1 = new String("aaa");
    String s2 = "aaa";
    System.out.println(s1 == s2); //false
    System.out.println(s1.intern() == s2); //true

When a String instance calls the intern() method, it will check whether there is the same string constant in the constant pool. If so, its reference will be returned. If not, a string equal to str will be added to the constant pool and Return its reference. Since s2 is already in the constant pool, s1.intern() will not create it again, but directly reference the same "aaa".

If this isn’t obvious enough, let’s experiment,

public class Cons {
    public static void main(String[] args) throws InterruptedException {
        String s1 = new String("vv");
    }
}

Then command line

Note that the constant pool has VV

Question 1:

String a = "aaa" will create an object in the constant pool. If the same object exists in the constant pool, then a will directly point to the object. And String a = new String("aaa"), if it exists in the constant pool, it will not be created in the constant pool, but only in the heap.

String a = new String("aaa");
String b = new String("aaa");
System.out.println(a == b);//比較兩者堆中的引用返回false
System.out.println(a.intern() == b.intern());//比較兩者常量池中的引用，返回true

Question 2:

Find the answer from the source code. String s3 = "aa".concat("a"); is actually equivalent to String s3 = new String("aaa"), which will create an object in the heap.

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

String doesn’t create a new String object instance every time it is assigned a value? That's why there is StringBuilder.

According to object-oriented thinking, String itself may know best whether to create objects in the constant pool at the same time. Well, it has an intern() method.

The answers from the previous few are already very good. Let me add that what we often say "putting the string into the constant pool" refers to putting the reference of the string into the string constant pool (String Pool, which is essentially a hash table), the string itself is still placed on the heap.

//    new一次就是在堆中創(chuàng)建一個新的對象。不new的話aaa直接在字符串常量中取值;
//    String s2 = "aaa"; 先在內(nèi)存中尋找aaa，如果有，則將aaa的內(nèi)存首地址指向了s1，
      如果沒有則在堆中中創(chuàng)建一個新的對象。

//    String s1 = new String("aaa");//  
//    不管"aaa"在內(nèi)存中是否存在，都會在堆中開辟新空間，將字符串"aaa"的內(nèi)存首地址指向s1。


String a = "aaa";//   aaa在常量池中創(chuàng)建一個對象，將內(nèi)存首地址指向了a
String b = "aaa";//    直接aaa已經(jīng)存在的內(nèi)存首地址指向b。
String c = new String("aaa");// 不管存在與否，在堆中創(chuàng)建1個空間，內(nèi)存首地址與常量池中的地址完全不同
System.out.println(a==b);// true
System.out.println(a==c);// false