java 经常使用类-String-1

1、字符串相关的类

1.1 String 的特性

1. String类：表明字符串。Java 程序中的全部字符串字面值（如 "abc" ）都做为此类的实例实现。
2. String是一个final类，表明不可变的字符序列。
   • final修饰的类不能被继承
3. 字符串是常量，用双引号引发来表示。它们的值在建立以后不能更改。
4. String对象的字符内容是存储在一个字符数组value[]中的。
   • 数据存储结构中，有链式存储结构和顺序存储结构两种。显然String底层选择了char型数组类型的顺序存储结构。

1.2 String部分源码

Windows电脑,idea中。双击shift，输入String，便可出来。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;
    ....
}

从这部分源码中，咱们就能够很好的理解“1.1 String 的特性”中的内容了！！！字符串，字符串，就是字符构建起来的串。

1.3 String再次理解

1.3.1 上代码

public class StringTest {
    @Test
    public void test1() {
        // String name = "abc"; 字面量的定义方式
        String name = "abc";
        String des = "abc";
        name = "hell world";
        System.out.println("name:"+name);// hello world
        System.out.println("des:"+des);// abc
    }

    @Test
    public void test2() {
        final int a = 2;
        a = 3; // 编译不经过
    }
}

1. 第一个问题：为何name = "hell world",编译成功，并能运行，不是说“它们的值在建立以后不能更改”吗？;而test2()中却编译失败？

   • 首先，String属性引用类型，而int是基本类型。

   • 引用类型变量存储地址值，而a是一个指向int类型的引用，指向2这个字面值。所以final int 修饰的变量就变为常量了，常量是不能修改其值的，因此test2()编译失败。

   • 那么怎么理解String 底层存储使用final修饰的char型数组,更改其值为何编译成功，并能运行？简单的JVM走一波。图一：

     从图中咱们能够看出：

     • 常量池当中，是不会存储两个相同的字符串的。
     • name、des存储的是地址值。name和des都指向0x8888这个地址

     图二：

     从图中咱们能够看出：

     • 这就很好解释了为何输出结果是name为hello world 而des依然为abc。
     • 同时也解释了“它们的值在建立以后不能更改”，原始的值“abc”的确没有被修改，而是在字符串常量池中从新建立了一份。
     • 这也能够看出频繁的对字符串进行增删改操做的话，很耗费内存资源。

1.3.2 初步总结

1. String:字符串，使用一对""引发来表示。
2. String声明为final的，不可被继承。
3. String实现了Serializable接口：表示字符串是支持序列化的。
   • 实现了Comparable接口：表示String能够比较大小
4. String内部定义了final char[] value用于存储字符串数据
5. String:表明不可变的字符序列。简称：不可变性。
   • 当对字符串从新赋值时，须要重写指定内存区域赋值，不能使用原有的value进行赋值。
   • 当对现有的字符串进行链接操做时，也须要从新指定内存区域赋值，不能使用原有的value进行赋值。
   • 当调用String的replace()方法修改指定字符或字符串时，也须要从新指定内存区域赋值，不能使用原有的value进行赋值。
6. 经过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
7. 字符串常量池中是不会存储相同内容的字符串的。

1.4 判断对错

@Test
    public void test3() {
        String s1="javaWeb";
        String s2="javaWeb";

        String s3 = new String("javaWeb");
        String s4 = new String("javaWeb");

        System.out.println(s1==s2);
        System.out.println(s1==s3);
        System.out.println(s1==s4);
        System.out.println(s3==s4);
    }

直观判断：

1. s1==s2。在字符串常量池中相同的字符串只会存储一份，s1和s2存储相同的地址。因此为true
2. s1==s3。他们分别指向不一样地方，因此为false
3. s1==s4。他们分别指向不一样地方，因此为false
4. s3==s4。只要是new便会在堆空间中开辟一份空间，JVM才不会管你new的内容是否和前面的相同。因此为false

集合JVM判断：

结合JVM图形就能够很清楚的明白到底为何错，为何对了。

1.5 判断对象的属性

public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

}

@Test
    public void test4() {
        Person p1 = new Person("Tom", 12);
        Person p2 = new Person("Tom", 12);
        System.out.println(p1.name==p2.name);// true?false?
    }

显然为true，Tom存储在字符串常量池中,有且仅有一份。故p1.name==p2.name必然为true

再来：

@Test
    public void test4() {
        Person p1 = new Person("Tom", 12);
        Person p2 = new Person("Tom", 12);
        System.out.println(p1.name==p2.name);

        p2.name="cxk";
        System.out.println(p1.name==p2.name);// true?false
    }

确定是false， p2.name="cxk";会先在字符串常量池中查找，没有就在常量池中建一个， p2.name地址指向它便可。【字符串的不可变性】

1.6 拓展：

1. String s = new String("abc")；方式建立对象，在内存中建立了几个对象？

   答：2个。一个是堆空间中new结构，另外一个是char[ ]对应的常量池中的数据：”abc“;

2. 来，搞一下这个。

   public void test3(){
           String s1 = "javaEE";
           String s2 = "hadoop";
   
           String s3 = "javaEEhadoop";
           String s4 = "javaEE" + "hadoop";
           String s5 = s1 + "hadoop";
           String s6 = "javaEE" + s2;
           String s7 = s1 + s2;
   
           System.out.println(s3 == s4);
           System.out.println(s3 == s5);
           System.out.println(s3 == s6);
           System.out.println(s3 == s7);
           System.out.println(s5 == s6);
           System.out.println(s5 == s7);
           System.out.println(s6 == s7);
       
           String s8 = s6.intern();
           System.out.println(s3 == s8);
       }

   • s3 == s4为true。字面量或者字面量之间的链接，指向同一个对象，在常量池中声明。
   • s五、s六、s7都是字面量拼接变量或者变量拼接变量，他们不是在常量池中声明而是在堆中声明。能够把它想象为new，从而尽管内容相同，可是地址值倒是是不相同的。

   结论：

   • 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。  只要其中有一个是变量，结果就在堆中
   • 若是拼接的结果调用intern()方法，返回值就在常量池中

1.7 面试题

代码一：

public class StringTest2 {
    String str = new String("good");
    char[] ch = {'t', 'e', 's', 't'};

    public void change(String str, char ch[]) {
        str = "test ok";
        System.out.println("======"+str);
        ch[0] = 'b';
    }

    public static void main(String[] args) {
        StringTest2 ex = new StringTest2();
        ex.change(ex.str, ex.ch);
        System.out.print(ex.str + " and ");
        System.out.println(ex.ch);
    }
}

输出结果是多少？

解析：作这道题必须明白几个知识点

1. java中方法参数的传递机制——值传递。
   • 值传递。即将实际参数的副本（复制品）传入到方法内，而参数自己不受影响。
     • 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参【原始值不受影响】
     • 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参【由于传递副本为地址值，因此某些原始值会受影响，某些不会，如String类型具备不可变性】
2. String类型具备不可变性。

分析：

代码二：

public class StringTest2 {
    String str = new String("good");
    char[] ch = {'t', 'e', 's', 't'};

    public void change(String str, char ch[]) {
        // 第二步：
//对于方法中的str，因为第一步的赋值操做，它的地址值和“String str = new String("good");”中的str同样，内容都为good。
//接下来方法中对它进行赋值操做“test ok”。
//因为String类型的不可变性（看源码类为final修饰，数据存储结构为也为final修饰的char型数组）,不可修改。
//所以JVM执行'str ="test ok";'时会在字符串常量池中新建一个“test ok”而且更新方法中str的地址值。 
//至此两个str的地址值不一样了，指向的内容也不一样了。 能够看“代码三”中的对比结果。
        str = "test ok";
       
        // 第二步；
//对于方法中的ch，因为第一步的赋值操做，它的地址值和“char[] ch = {'t', 'e', 's', 't'};”中的ch同样，内容都为test。
//接下来，在方法中执行"ch[0] = 'b';" 数组中的第一个元素被赋值为b。因为是引用类型，此时类中成员变量char[] ch = {'t', 'e', 's', 't'};值也变为best。
        ch[0] = 'b';
    }

    public static void main(String[] args) {
        StringTest2 ex = new StringTest2();
        // 第一步
 // 传递的两个实参，参数一，其实是把StringTest2类中成员变量str的地址值复制一份给StringTest2类中change方法中的形参变量str
//  同理，StringTest2类中成员变量ch（数组：也是引用类型）的地址值复制一份给StringTest2类中change方法中的形参变量ch[]
        ex.change(ex.str, ex.ch);
        System.out.print(ex.str + " and ");
        System.out.println(ex.ch);
    }
}

代码三：

public class StringTest2 {
    String str = new String("good");
    char[] ch = {'t', 'e', 's', 't'};

    public void change(String str, char ch[]) {
        System.out.print("赋值以前两个str的地址值比较为：");
        System.out.println(this.str==str);
        str = "test ok";
        System.out.print("赋值以后两个str的地址值比较为：");
        System.out.println(this.str==str);
        System.out.println("====================分割线========================");
        ch[0] = 'b';
    }

    public static void main(String[] args) {
        StringTest2 ex = new StringTest2();
        ex.change(ex.str, ex.ch);
        System.out.print(ex.str + " and ");
        System.out.println(ex.ch);
    }
}

结果：