Java中String类学习总结

Posted 2020-09-21

java中String类的使用频率非常高，本人在学习此模块时，认为下列几点知识值得注意：

一、String是不可变对象

      java.lang.String类使用了final修饰，不能被继承。Java程序中的所有字面值，即双引号括起的字符串，如"abc"，都是作为String类的实例实现的。String是常量，其对象一旦构造就不能再被改变。换句话说，String对象是不可变的，每一个看起来会修改String值的方法，实际上都是创造了一个全新的String对象，以包含修改后的字符串内容。而最初的String对象则丝毫未动。String对象具有只读特性，指向它的任何引用都不可能改变它的值，因此，也不会对其他的引用有什么影响。但是字符串引用可以重新赋值。java字符串在内存中采用unicode编码方式，任何一个字符对应两个字节的定长编码，即任何一个字符（无论中文还是英文）都算一个字符长度，占用两个字节。

例1：

public class Immutable {
      public static String upcase(String s) {
           return s.toUpperCase();
      }
      public static void main(String[ ] args) {
           String str1= "Hello World";
           System.out.println(str1);  //Hello World
           String str2 = upcase(str1);
           System.out.println(str2);  //HELLO WORLD
           System.out.println(str1);  //Hello World
     }
}

   当把str1传递给upcase()方法时，实际传递的是引用的一个拷贝。其实，每当把String对象作为方法的参数时，都会复制一份引用，而该引用所指的对象其实一直待在单一的物理位置上，从未动过。

二、String常量池

     常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。Java为了提高性能，静态字符串（字面量/常量/常量连接的结果）在常量池中创建，并尽量使用同一个对象，重用静态字符串。对于重复出现的字符串直接量，JVM会首先在常量池中查找，如果常量池中存在即返回该对象。

例2：

public class test1 {
    public static void main(String[] args){
        String str1 = "Hello";
        //不会创建新的String对象，而是使用常量池中已有的"Hello"，
        String str2 = "Hello";
        System.out.println(str1 == str2); //true
        //使用new关键字会创建新的String对象
        String str3 = new String("Hello");
        System.out.println(str1 == str3); //false 
    }
}

 

三、String、StringBuffer和StringBuilder的区别

1.对象的可变与不可变

　　String类中使用字符数组来保存数据，因为有“final”修饰符，所以string对象是不可变的。如下：

　　　　private final char value[];

　　StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存数据，这两种对象都是可变的。如下：

　　　　char[] value;

2.是否是线程安全

　　String中的对象是不可变的，也就可以理解为常量，所以是线程安全。

　　AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。

　　StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。看如下源码：

1  public synchronized StringBuffer reverse() {
2      super.reverse();
3      return this;
4  }
5
6  public int indexOf(String str) {
7      return indexOf(str, 0);        //存在 public synchronized int indexOf(String str, int fromIndex) 方法
8  }

　　StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。

 3.StringBuilder与StringBuffer共同点

　　StringBuilder与StringBuffer有公共的抽象父类AbstractStringBuilder。

　　抽象类与接口的一个区别是：抽象类中可以定义一些子类的公共方法，子类只需要增加新的功能，不需要重复写已经存在的方法；而接口中只是对方法的申明和常量的定义。

　　StringBuilder、StringBuffer的方法都会调用AbstractStringBuilder中的公共方法，如super.append(...)。只是StringBuffer会在方法上加synchronized关键字，进行同步。

如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer。

四、创建了几个对象的问题

1 String str1 = "abc";
2 String str2 = new String("abc");

      对于1中的 String str1 = "abc"，首先会检查字符串常量池中是否含有字符串abc，如果有则直接指向，如果没有则在字符串常量池中添加abc字符串并指向它.所以这种方法最多创建一个对象，有可能不创建对象。

      对于2中的String str2 = new String（"abc"）,首先会在堆内存中申请一块内存存储字符串abc,str2指向其内存块对象。同时还会检查字符串常量池中是否含有abc字符串,若没有则添加abc到字符串常量池中。所以 new String()可能会创建两个对象。

      所以如果以上两行代码在同一个程序中，则1中创建了1个对象，2中创建了1个对象。如果将这两行代码的顺序调换一下，则1 String str2 = new String("abc")创建了两个对象，而2 String str1 = "abc"没有创建对象。

看看下面的代码创建了多少个对象：

1     String temp="apple";  
2     for(int i=0;i<1000;i++) {  
3           temp=temp+i;  
4     }  

答案：1001个对象。

下面的代码创建了多少个对象：

1     String temp=new String("apple")  
2     for(int i=0;i<1000;i++) {  
3            temp=temp+i;  
4     }  

答案：1002个对象。

五、String的匹配相等问题

      使用String类经常需要对两个字符串进行对比，看是否相等。有==和equals两种选择,这两者方法区别很大：

             比对象的内容是否相等使用equals(),比较两个引用是否指向同一个对象时用==；equals()是看内容是否相等，比较好理解。而==是看是否属于同一个对象。

首先还要明白这个概念：常量池在java用于保存在编译期已确定的，已编译的class文件中的一份数据。主要看编译期字符串能否确定。

看看下面几个例子：

test1：

1 String ok="ok";  
2 String ok1=new String("ok");  
3 System.out.println(ok==ok1);//fasle 

ok指向字符串常量池，ok1指向new出来的堆内存块，new的字符串在编译期是无法确定的。所以输出false。

test2：

1 String ok="apple1";  
2 String ok1="apple"+1;  
3 System.out.println(ok==ok1);//true 

编译期ok和ok1都是确定的，字符串都为apple1，所以ok和ok1都指向字符串常量池里的字符串apple1。指向同一个对象，所以为true。

test3：

1 String ok="apple1";  
2 int temp=1;  
3 String ok1="apple"+temp;  
4 System.out.println(ok==ok1);//false

主要看ok和ok1能否在编译期确定，ok是确定的，放进并指向常量池，而ok1含有变量导致不确定，所以不是同一个对象.输出false。

test4：

1 String ok="apple1";  
2 final int temp=1;  
3 String ok1="apple"+temp;  
4 System.out.println(ok==ok1);//true 

ok确定，加上final后使得ok1也在编译期能确定，所以输出true。

test5：

 1 public static void main(String[] args) {    
 2     String ok="apple1";  
 3     final int temp=getTemp();  
 4     String ok1="apple"+temp;  
 5     System.out.println(ok==ok1);//false       
 6 }  
 7   
 8 public static int getTemp(){  
 9     return 1;  
10 }  

ok一样是确定的。而ok1不能确定，需要运行代码获得temp,所以不是同一个对象，输出false。

String的intern()方法

当调用 intern()方法时，如果常量池中已经包含一个等于此 String 对象的字符串（该对象由 equals(Object) 方法确定），则返回常量池中的字符串；否则，将此 String 对象添加到常量池中，并且返回此 String 对象的引用。

看以下几个例子：

test6:

public class test6 {

    private static String a = "ab";
    public static void main(String[] args){
        String s1 = "a";
        String s2 = "b";
        String s = s1 + s2;//+的用法
        System.out.println(s == a); //flase
        System.out.println(s.intern() == a);// true (intern的含义)
    }

}

test7:

 1 public class test6 {
 2     private static String a = new String("ab");
 3     public static void main(String[] args){
 4         String s1 = "a";
 5         String s2 = "b";
 6         String s = s1 + s2;
 7         System.out.println(s == a); //flase
 8         System.out.println(s.intern() == a);//false
 9         System.out.println(s.intern() == a.intern()); //true
10     } 
11 }