JavaSE 第二次学习随笔(String的坑 + ==)

String 类是一个final类, 其内部是使用的 private final char value[]; 来存储内容, 其既可以当作一个基本类型来使用也可以当作一个类来使用;
final 类(String): 被final修饰的类将不能被继承
final char value[]: 不能修改String类型的对象的内容, 但是我可以修改他的引用指向啊~

"==" 作用 : 判断引用是否指向堆内存的同一块地址

equals()的作用: 比较是否值相等(先比较两个String的地址然后用instanceof比较类型, 然后遍历两个String的value[] 挨个值比较)

hashcode()的作用: 根据String中的value[]计算出的散列值, 和它的地址一丁点毛关系都没有-_-|

equals();

/**
     * Compares this string to the specified object.  The result is {@code
     * true} if and only if the argument is not {@code null} and is a {@code
     * String} object that represents the same sequence of characters as this
     * object.
     *
     * @param  anObject
     *         The object to compare this {@code String} against
     *
     * @return  {@code true} if the given object represents a {@code String}
     *          equivalent to this string, {@code false} otherwise
     *
     * @see  #compareTo(String)
     * @see  #equalsIgnoreCase(String)
     */
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

　

hashCode();

/**
     * Returns a hash code for this string. The hash code for a
     * {@code String} object is computed as
     * <blockquote><pre>
     * s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
     * </pre></blockquote>
     * using {@code int} arithmetic, where {@code s[i]} is the
     * <i>i</i>th character of the string, {@code n} is the length of
     * the string, and {@code ^} indicates exponentiation.
     * (The hash value of the empty string is zero.)
     *
     * @return  a hash code value for this object.
     */
    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

　　

针对String作为一个基本类型来使用：

 

1。如果String作为一个基本类型来使用，那么我们视此String对象是String缓冲池所拥有的。

2。如果String作为一个基本类型来使用，并且此时String缓冲池内不存在与其指定值相同的String对象，那么此时虚拟机将为此创建新的String对象，并存放在String缓冲池内。

3。如果String作为一个基本类型来使用，并且此时String缓冲池内存在与其指定值相同的String对象，那么此时虚拟机将不为此创建新的String对象，而直接返回已存在的String对象的引用。

 

针对String作为一个对象来使用：

 

1。如果String作为一个对象来使用，那么虚拟机将为此创建一个新的String对象，即为此对象分配一块新的内存堆，并且它并不是String缓冲池所拥有的，即它是独立的。

关于String的各种==判定相等问题:

new 的对象一定是两块内存() 

final String s1 = "123";这时 s1 已经可以当作一个常量(等同于 ["123"] ) 使用jvm对String的常量优化对它起作用(后边有例子)

* 对于Integer来说, 数字范围在在一个字节范围内　　
* 后边再定义它,直接使用前边的　　　　　　　　(Integer i = new Integer(100); Integer j = new Integer(100); i==j;-->>true )
* 超过一个字节其会新建对象　　　　　　　　　 (Integer i = new Integer(129); Integer j = new Integer(129); i==j;-->>true )

Character ch1 = '1';			
Character ch2 = '1';
System.out.println("'1' == '1' " + (ch1 == ch2) );				//true
ch1 = new Character('1');
System.out.println( "new Character('1') == '1' " + (ch1 == ch2));		//false
System.out.println("new Character('1').equals('1') " + ch1.equals(ch2));　　　　 //true
		
Character ch3 = '我';
Character ch4 = '我';
System.out.println("'我' == '我' " + (ch3 == ch4));				//true
ch3 = new Character('我');
System.out.println("new Character('我') == '我' " + (ch3 == ch4));		//true
System.out.println("new Character('我').equals('我') "+ch3.equals(ch4));	　　　　 //true

//这里由于Character是char的包装类, char是整数类型表示的所以在128前的 '1' 在常量池里 ch1 ch2 指向一个(常量池里的)对象, 而 '我' 则不在常量池里, ch3 ch4分别指向不同的对象
//关于常量池, 下面有详细的解释

String s1 = “abc”; 
final String s2 = “a”; 
final String s3 = “bc”; 
String s4 = s2 + s3; 
System.out.println(s1 == s4); 
输出true，因为final变量在编译后会直接替换成对应的值，所以实际上等于s4=”a”+”bc”，而这种情况下，编译器会直接合并为s4=”abc”，所以最终s1==s4。

(摘自 https://blog.csdn.net/soonfly/article/details/70147205 后面多点理解String.intern()是摘抄于此)

String s1 = new String("1234");
String s2 = new String("1234");
System.out.println(s1 == s2);　　//false

String s3 = "1234";
String s4 = "1234";
System.out.println(s3 == s4); //true

String s1 = new String("1234");
String s2 = new String("12345");
s1+="5";
System.out.println(s1 == s2);//false

String s1 = "12345";
String s2 = "1234" + "5";
String s3 = "1234";
s3+=5;
System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false

String s1 = new String("12345");
String s2 = new String("1234") + "5";
System.out.println(s1 == s2);//false

String s2 = "1234" ;
String s3 = s2 + "5";
System.out.println(s1 == s3);//false

String.intern();作用: (jdk1.7后)

　　一、new String都是在堆上创建字符串对象。当调用 intern() 方法时，编译器会将字符串添加到常量池中（stringTable维护），并返回指向该常量的引用。

　　二、通过字面量赋值创建字符串（如：String str=”twm”）时，会先在常量池中查找是否存在相同的字符串，若存在，则将栈中的引用直接指向该字符串；若不存在，则在常量池中生成一个字符串，再将栈中的引用指向该字符串

　　三、常量字符串的“+”操作，编译阶段直接会合成为一个字符串。如string str=”JA”+”VA”，在编译阶段会直接合并成语句String str=”JAVA”，于是会去常量池中查找是否存在”JAVA”,从而进行创建或引用

　　四、对于final字段，编译期直接进行了常量替换（而对于非final字段则是在运行期进行赋值处理的）

　　五、常量字符串和变量拼接时（如：String str3=baseStr + “01”;）会调用stringBuilder.append()在堆上创建新的对象

　　六、JDK 1.7后，intern方法还是会先去查询常量池中是否有已经存在，如果存在，则返回常量池中的引用，这一点与之前没有区别，区别在于，如果在常量池找不到对应的字符串，则不会再将字符串拷贝到常量池，而只是在常量池中生成一个对原字符串的引用。简单的说，就是往常量池放的东西变了：原来在常量池中找不到时，复制一个副本放到常量池，1.7后则是将在堆上的地址引用复制到常量池.  ( https://blog.csdn.net/soonfly/article/details/70147205 )

　　为了加深我自己的印象(万一大佬找上门来, 怂的不行ing), 大佬的图我就不复制了 下边是我自己画哒, 画图真累...

举例说明(不错这是大佬写的, 人家写的非常好我就复制过来了还是上边那个地址)

String str2 = new String("str")+new String("01");
str2.intern();
String str1 = "str01";
System.out.println(str2==str1);

在JDK 1.7下，当执行str2.intern();时，因为常量池中没有“str01”这个字符串，所以会在常量池中生成一个对堆中的“str01”的引用(注意这里是引用 ，就是这个区别于JDK 1.6的地方。在JDK1.6下是生成原字符串的拷贝)，而在进行String str1 = “str01”;字面量赋值的时候，常量池中已经存在一个引用，所以直接返回了该引用，因此str1和str2都指向堆中的同一个字符串，返回true。

String str2 = new String("str")+new String("01");
String str1 = "str01";
str2.intern();
System.out.println(str2==str1);

　　将中间两行调换位置以后，因为在进行字面量赋值（String str1 = “str01″）的时候，常量池中不存在，所以str1指向的常量池中的位置，而str2指向的是堆中的对象，再进行intern方法时，对str1和str2已经没有影响了，所以返回false。

有了对以上的知识的了解，我们现在再来看常见的面试或笔试题就很简单了： 
Q：下列程序的输出结果： 
String s1 = “abc”; 
String s2 = “abc”; 
System.out.println(s1 == s2); 
A：true，均指向常量池中对象。

Q：下列程序的输出结果： 
String s1 = new String(“abc”); 
String s2 = new String(“abc”); 
System.out.println(s1 == s2); 
A：false，两个引用指向堆中的不同对象。

Q：下列程序的输出结果： 
String s1 = “abc”; 
String s2 = “a”; 
String s3 = “bc”; 
String s4 = s2 + s3; 
System.out.println(s1 == s4); 
A：false，因为s2+s3实际上是使用StringBuilder.append来完成，会生成不同的对象。

Q：下列程序的输出结果： 
String s1 = “abc”; 
final String s2 = “a”; 
final String s3 = “bc”; 
String s4 = s2 + s3; 
System.out.println(s1 == s4); 
A：true，因为final变量在编译后会直接替换成对应的值，所以实际上等于s4=”a”+”bc”，而这种情况下，编译器会直接合并为s4=”abc”，所以最终s1==s4。

Q：下列程序的输出结果： 
String s = new String(“abc”); 
String s1 = “abc”; 
String s2 = new String(“abc”); 
System.out.println(s == s1.intern()); 
System.out.println(s == s2.intern()); 
System.out.println(s1 == s2.intern()); 
A：false，false，true。

　　

　

　

由于它其实是由char[] 实现的所以我们来看看它的构造方法以便了解它的char[] 到底指向了哪里

这是其中的三个构造方法,

1. 我们可以看到 当输入的是一个String类型的时候, 他的value和hashcode 是直接赋值过来的 所以毫无疑问这时 两个new String("123") 的char[]是一个对象,
2. 我们还看到单纯的new String()就是个"",
3. 当new String(char[]); 时,String类会new 一个char[] 然后把你的char[] 复制过来(Arrays.copyOf(value, value.length)会返回一个new char[]),所以这里应该是两个char[] 对象 那么两个String对象肯定不同了.
4.String 类对于它内部的char[]的一个原则就是坚决不让你得到它的引用, 任何你能接触到的关于它的char方法返回的要么是一个copy的char[] 要么就是一个char;这么做主要是为了保证String 的 final性 以保证它在多线程情况下程序的稳定(我猜的, 嘿嘿).

/**
     * Initializes a newly created {@code String} object so that it represents
     * an empty character sequence.  Note that use of this constructor is
     * unnecessary since Strings are immutable.
     */
    public String() {
        this.value = "".value;
    }

    /**
     * Initializes a newly created {@code String} object so that it represents
     * the same sequence of characters as the argument; in other words, the
     * newly created string is a copy of the argument string. Unless an
     * explicit copy of {@code original} is needed, use of this constructor is
     * unnecessary since Strings are immutable.
     *
     * @param  original
     *         A {@code String}
     */
    public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

    /**
     * Allocates a new {@code String} so that it represents the sequence of
     * characters currently contained in the character array argument. The
     * contents of the character array are copied; subsequent modification of
     * the character array does not affect the newly created string.
     *
     * @param  value
     *         The initial value of the string
     */
    public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }