看到一段代码
String s0="value";   
String s1="value";   
String s2="va" + "lue";   
System.out.println( s0==s1 );   
System.out.println( s0==s2 );  
结果为：
true
true
s0==s1，这个知道，s1==s2为true的原因？

另外一段代码：
String s0="value";   
String s1=new String("value");   
String s2="kv" + new String("lue");   
System.out.println( s0==s1 );   
System.out.println( s0==s2 );   
System.out.println( s1==s2 );  
结果为：
false
false
false
s1==s2的比较过程是什么样？

String 类一旦被定义就不可以改变!   而且
String s0="value";   
String s1="value";   
String s2="va" + "lue";   
System.out.println( s0==s1 );   
System.out.println( s0==s2 );  
结果为：
true
true
s0==s1，这个知道，s1==s2为true的原因？
原因是他们比较是地址值 找的只是栈内存的地址 所以他们比较是true

String 类适用于描述字符串事物.
         那么他就提供了多个方法对字符串进行操作.
          
          常见的操作有哪些呢?
          
         一获取:
                 1.1版本,字符串中的包含的字符数,也就是字符串的长度.
                int length():获取字符长度
                 1.2版本,根据位置获取位置上的某个字符.
                         char charAt(int index):
                 1.3版本,根据字符获取该字符在字符串中的位置
                         init indexOf(int ch):返回的是ch在字符串中第一次出现的位置
                         int indexOf(int ch, int fromIndex):从fromIndex指定的位置开始;获取ch在字符串中出现的位置
         二判断:
                 1.字符穿中是否包含某一个字符串.
                         bolean contains(str);  (contains 肯忒丝)
******                必须掌握的:特殊之处:indexOf(str):可以索引str第一次出现的位置,如果返回-1,表示str不在字符串中存在.
                                         所以,也可以用于对指定的判断是否包含.
                                         如例:
                                                 if(str.indexOf("aa") != -1)
                                                 而且该方法既可以判断,又可以获取出现的位置
                                                 如果只为判断就用contains(str)
                                                        
                 2.字符中是否有内容
                         boolean isEmpty():原理就是判断长度是否为0
                 3.字符串是否是以指定的内容开头
                         boolean startsWith(str);
                 4.字符串是否是以指定的内容结尾
                         boolean endsWith(str);
                 5.判断字符串内容是否相同,复写了Objext类中的equals方法.
                         boolean equals(str);
                 6.判断内容是否相同,并忽略大小写.
                         boolean equalsIgnore();
         
         三转换:
                 1.将字符数组转成字符串
                         构造函数:
                                   String(char[])
                                   String(char[],offset,count):将字符数组中的一部分转成字符串
                         静态方法:
                                   static String copyValueOf(char[]);
                                   static String copyvalueOf(char[] data,int offset, int count)
                                   static String valueOf(char[])
******        2.将字符串转成字符数组
                                   char[] toCharArray();
                 3.将字节数组转换成字符串
                                   String (byte[])
                                   String (byte[] ,offset ,coint):将字节数组中的一部分转成字符串
                 4.将字符串转成字节数组
                                   byte[] getBytes();
                 5.将基本数据类型转成字符串
                         static String valueOf(int)
                         static String valueOf(double)
                         如例:
                                 3+"";  == String.valueOf(3);  
                                 前面的是把基本数据类型转换成字符串  , 后面的同理是专业的写法但是很少人去用因为麻烦
                        
         
         特殊:字符串和字节数组在转换过程中,是可以指定编码表的.
         
         四替换:
                 1.String replace(oldchar老数组 , newchar新数组)
         五切割:
                 1.String[] split(regex);
         六字串:
         获取字符串的一部分.
                 String substring(begin);   //(begin 比根i)
                 String substring(begin,end)  //(end  恩的)
         
         七转换,去除空格,比较:
                 1.将字符串转成大写或者小写.
                   String toupperCase();
                   String toLowerCase();
                 2.将字符串两端的多个空格去除
                   String trim();
                 3.对两个字符串进行自然顺序的比较
                   int compareTo(string);

先回答第一段代码。

创建String对象。它先找，如果没有。就建一个。如果有，就用它。"value"已经创建了，那么能找到，就不需要重新创建了，用的都是一个对象，也就true了。

下面一段代码。

凡是new出来的，他就没有找这个动作，直接创建，就是一个新的指向。==是判断地址值的。所以就是false。

1. 
   
2. public class StingDemo {
   
3.         
   
4. 
   
5. public static  void main(String[] args){
   
6.         
   
7.    
   
8.         String s0="value";   
   
9.         String s1="value";   
   
10.         String s2="va" + "lue";   
    
11.         System.out.println(s0==s1);   
    
12.         System.out.println(s1==s2);  
    
13.                                  
    
14.                                      //s2是一个字符串引用对象，加号在这里可以看作是一个连接
    
15.                                      //符那么”va“+"lue"的地址被连接。与"value"的地址相同
    
16.                                     
    
17.         String a1="value";   
    
18.         String a2=new String("value");   
    
19.         String a3="va" + new String("lue");
    
20. 
    
21.         System.out.println(a1==a2);   
    
22.         System.out.println(a2==a3);   
    
23.         System.out.println(a1==a3);  
    
24.                                 //a2引用里new String()一个新对象的地址，地址改变
    
25.                                 //”va“地址连接一个新的地址，地址又改变了
    
26. }
    
27. }
    

复制代码

我是这样理解的。

String类型的变量名其实是对象名，而对象的调用属于引用，所以，对于第一段代码块儿，String类型变量的值都是value，在堆内存中开辟空间，地址固定，无论你声明多少变量。只要值是value，都指向这个地址，==比较的是地址，所以都是true；
第二段代码，只要new一次，堆内存中就会开辟一个新的空间，所以物理地址都不同，结果是false

s2赋值代码是不是敲错了，是“va”

“==”两个等号比较的都是地址，new出来的对象都是在堆内存里，new一个就产生一个地址，所以地址都不一样，结果就是false.至于第一段代码，“va”和"lue"的每个字符都是在静态区中，拼在一起还是地址不变，所以“==”的结果为true. 另外，你第二段的s2赋值代码是不是敲错了，是“va”吧。
String s2="kv" + new String("lue");
String s2="va" + new String("lue");