java中的String

   

Java中的String类是一种复合数据类型，比较String类的是否相等也有2种办法。"=="和equals（）两种。

String是一个系统定义的类----不是基本数据类型，有关字符串处理的方法非常多，有时候两个“一样”的字符串做相等的比较运算时会得到true的结果，可是有的时候得到的结果却是false，这是为什么呢？

   要彻底的弄清这两个字符串的相等比较，还得从系统的内存分配着手。

1 栈和堆的区别

栈和堆都是java 在ram中的数据存储区，java自动管理栈和堆，程序员不能直接设置栈和堆。

    1.1栈

   栈的存取速度仅次于位于cpu中的寄存器，比堆的存取速度快，栈中数据项的插入和删除，只能在栈顶的一端完成，栈的操作特性后进先出。栈中存放一些基本类型的变量和对象句柄，栈中的数据可以共享，缺点：：存放在栈中的数据大小与生存期必须是确定的，缺乏灵活性，比如有如下例子：

int a = 3； int b = 3;

编译器先处理int a =3,首先它会在栈中创建一个整形变量为a的引用，然后在栈中查找有没有值为3的存储单元，如果没有就开辟一个存放值为3的存储单元，然后将a指向这个值为3的地址，接着处理intb = 3,在创建完变量b的引用后，由于栈中已经有了值为3的地址，这样就出现了a和b同时指向3的情况。

假如再有a= 4,在编译器内部它会重新搜索栈中是否有值为4的存储单元，如果没有，重新开辟地吃存放4的存储单元；如果有则直接将a指向这个地址。因此a值的改变不会影响到b的值。

1.2堆

   堆是一个运行时数据区，类的对象从中分配空间，通过如new等指令建立。堆的优点是可以动态的分配内存大小。生存期也不必事先告诉编译器，java的垃圾收集器会自动回收不再使用的数据。但缺点是，由于要在运行时动态非配内存，存取速度比较慢。

 

2 字符串 “==”的比较

        String是一个特殊的包装类数据。当测试两个包装类的引用是否指向同一个对象时，用“==”。

        String 类的对象有两种形式创建：

        形式1：String   str = “abc”;

        形式 2：String  str = new String(“abc”) ;

        

        2.1 两者都为第一种形式创建的对象的比较

        String  str1 = “abc”;

        String  str2 = “abc”;

        用语句String  str1 =“abc”;创建对象java内部将此语句转换为以下几个步骤：

（1）      先定义一个名为str1 的对String类的对象引用变量。

（2）      在栈中查找有没有存放值为“abc”的存储单元，接着创建一个新的Sting类的对象0，并将对象0指向这个存储单元，而且在栈中记下这个引用的对象0.如果已经有了值为“abc”的地址则查找对象0，并返回对象0的地址。

（3）      将str1指向对象0的地址。Str1指向存在栈中的数据的引用。

String  str2=”abc”;在栈中创建了一个对象引用str2.因为栈中已经有一个值为“abc”的对象0，因此jvm创建了两个引用str1和str2,但只创建了一个对象，而且这两个引用都指向了这个对象，所以这里str1== str2.

 

2.2 同为第二种形式创建的两个对象的比较

        如：String  str1 = new String(“abc”);

                  String  str2 = new String(“abc”);

                  System.out.println(str1 ==str2);

        系统在栈内存中分别创建了两个对象引用变量str1和str2,同时在堆内存中创建了两个对象。两个引用变量分别表示两个不同的对象，如图所示，

无论堆内存中是否有相同的数据存在，也不会像栈中的数据共享。因此str1 != str2.

 

2.3两种不同形式创建对象的比较

String  str1 = new String(“abc”);

String  str2 = “abc”;

System.out.println(str1 ==str2);   //false

 

Str1和str2是栈中创建的两个引用，str1指向了堆中的一个对象，而str2则指向了栈中的一个对象，即两个引用分别指向不同的两个对象，所以str1 !=  str2.

 

3 字符串值的比较

        如果要比较两个字符串的值就用equals（）方法。如：str1.equals(str2)只要str1和str2的字面值相等结果就为true.

4  结论

（1）      String  str =“abc”;指向String类的引用被创建了。至于这个引用是否指向了一个新的对象，根据上下文来考虑。

（2）     String str = newString(“abc”);在栈中创建了一个对象的引用srt,str指向在堆中创建的新对象。该对象值为“abc”的String类。

（3）     当比较包装类里面的数值是否相等时，用equals方法，当测试两个包装类的引用是否指向一个对象的时候，用“==”。

 

package com.nba;

public class StringCompare {
  public static void A() {
    String str1 = "java";
    String str2 = "java";
    System.out.println(str1 == str2);  //true
  }
  public static void B() {
    String str1 = new String("java");
    String str2 = new String("java");
    System.out.println(str1 == str2);  //false
  }
  public static void C() {
    String str1 = "java";
    String str2 = "blog";
    String s = str1 + str2;
    System.out.println(s == "javablog");  //false
  }
  public static void C2() {
    String str1 = "javablog";
    String str2 = "java"+"blog";    //在编译时被优化成String str2 = "javablog";
    System.out.println(str1 == str2);  //true
  }
  public static void D() {
    String s1 = "java";
    String s2 = new String("java");
    System.out.println(s1.intern() == s2.intern());  //true
  }

  public static void E() {
    String str1 = "java";
    String str2 = new String("java");
    System.out.println(str1.equals(str2));  //true
  }
  
  public static void main(String[] args){
    A();
    B();
    C();
    C2();
    D();
    E();
  }
}

输出============

true
false
false
true
true
true

字符串对象是一种特殊的对象.String类是一个不可变的类..也就说,String对象一旦创建就不允许修改

String类有一个对应的String池,也就是 String pool.每一个内容相同的字符串对象都对应于一个pool里的对象.

1 看下面一段代码.

String s = new String("abc");
  String s1 = "abc";
  String s2 = new String("abc");
  
  System.out.println(s == s1);
  System.out.println(s == s2);
  System.out.println(s1 == s2);

请问 前面三条语句分别创建了几个对象,分别是什么.后面的输出分别是什么

(1)String s = new String("abc"); 这句,创建了两个对象..其内容都是"abc".注意,s不是对象,只是引用.只有new生成的才是对象.

创建的流程是,首先括号里的"abc"先到String pool里看有没"abc"这个对象,没有则在pool里创建这个对象..所以这里就在pool创建了一个"abc"对象.然后 通过new语句又创建了一个"abc"对象..而这个对象是放在内存的堆里. .这里的s指向堆里的对象.

(2) String s1 = "abc"; 这条语句,s1当然还是引用.没啥可说的.后面的"abc".其实就是上面括号里的"abc".执行的是相同的操作.即 在pool里查找有没"abc"这个对象.没有则创建一个...很显然,第一条语句在pool里已经创建了一个"abc".所以这条语句没有创建对象,s1指向的是pool中的"abc"

(3)String s2 = new String("abc"); 这条语句,其实和第一条是一样的。因为第一条已经在pool中创建了"abc"这个对象,所以这条语句由于在pool中先找到了"abc",所以不用在pool中再次创建"abc"了，而只是在堆里创建了一个新的"abc"对象.s2指向的是堆里的"abc".注意,虽然内容都是"abc",s与s2表示的是不同的对象

(4)接下来就很好说了.下面的三个==判断.(注意,==永远是判断内存地址是否相等) s与s1,一个指向堆里的对象,一个指向pool里的.很明显是不同的对象.s与s2.上面说了,虽然都是指向堆里的对象,内容也是"abc",但是也不是相同的对象.s1与s2.一个指向pool,一个指向堆.也不是相同的对象.所以三个都返回false.

2 第二个问题

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());

求最后输出是什么

解答.最后的答案是 false false true

intern()方法.按照jdk的帮助文档来说,是返回字符串对象的规范化表示形式。通俗一点说,就是返回对应这个字符串内容的那个pool里的对象.这样说也许还看不太明白,那可以拿具体例子来说

s1.intern().他的执行流程是,在pool里去查找s1对应的内容(也就是"abc").如果找到,则返回pool里的对象.如果没有(老实说,我没想到有哪种情况是没有的),则在Pool创建这个对象,并返回...

这样就很容易理解了.s1.intern返回的是pool里的"abc"对象.与s这个堆里的对象肯定不同,返回false.同理,s与s2.intern()也肯定不同,返回false.第三个,s1与s2.intern().其中s2.intern()返回的是pool中的"abc"对象,而s1也是指向pool中的"abc"对象.所以返回的是true:

3第三个问题

String hello = "hello";
  String hel = "hel";
  String lo = "lo";
  
  System.out.println(hello == "hel" + "lo");
  System.out.println(hello == "hel" + lo);

求输出的结果

解答 true false

首先,上面已经说明了,hello hel lo这三个都是指向pool中的对象..

现在我们考虑"hel" + "lo" 按照内容来说,两个相加也就是"hello".这个时候,这个会返回pool中的"hello"对象.所以,hello == "hel" + "lo" 返回的是true .

而"hel" + lo 虽然内容也是"hello",但是它将在堆里面生成一个"hello"对象,并返回这个对象...所以这里的结果是false

总结一下就是,如果加号两边的是字面值(字面值就是直接在""里写的值,比如上面的"hel"与"lo"),那么将在pool里查找有没对应内容的对象(这里的内容就是"hello"),并返回pool里的对象.这和hello是一样的....

如果加号两边不满足上面的条件(比如,两边的值是引用值或者堆里的字符串对象).那么将不会再pool里查找"hello",而是直接在堆里生成一个新的对象...