常用类-String的不可变性

/**
 * 1.String声明为final的，不可被继承
 * 2.String实现了Serializable接口：表示字符串是支持序列化的
 *         实现了 Comparable接口：表示String可以比较大小
 * 3.String内部定义了final char[] value用于存储字符串数据
 * 4.String：代表不可变的字符串序列，简称不可变性
 *      体现：1）当对字符串重新赋值时，需要重写指定内存区域的，不能使用原有的value进行赋值。
 *           2）当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
 *           3）当调用String的replay()修改指定的字符或字符串时，也需要重写指定内存区域的，不能使用原有的value进行赋值。
 * 5.通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在方法区中的字符串常量池中。
 * 6.字符串常量池中是不会存储相同内容的字符串的
 *
 * 面试题： String s3 = new String("abc");方式创建对象，在内存中创建了几个对象？
 *              答：两个，一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"
 *
 * 7.String不同拼接操作的对比：
 *      1)常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量
 *      2)只要其中有一个是变量，结果就在堆中
 *      3)如果拼接的结果调用intern(),返回值就在常量池中
 *
 *
 * @author fu jingchao
 * @creat 2021/10/29-16:33
 */

 1 package com.atfu.java01;
 2 
 3 /**
 4  * @author fu jingchao
 5  * @creat 2021/10/29-16:33
 6  */
 7 public class StringTest {
 8     public static void main(String[] args) {
 9         String s1 = "abc";//通过字面量的方式给一个字符串赋值，此时的字符串值声明在方法区中的字符串常量池中。
10         String s2 = "abc";
11         String s3 = new String("abc");
12         String s4 = new String("abc");//通过创建对象的方式给字符串赋值，此时的s2保存的地址值，是数据在堆
13                                             // 空间中开辟空间以后对应的地址值。
14         System.out.println(s1 == s2);//true
15         System.out.println(s1 == s3);//false
16         System.out.println(s1 == s4);//false
17         System.out.println(s3 == s4);//false
18 
19         System.out.println("=================================");
20         Person p1 = new Person("Tom", 12);
21         Person p2 = new Person("Tom", 12);
22         System.out.println(p1.name.equals(p2.name));//true
23         System.out.println(p1.name == p2.name);//true
24         p1.name = "jack";
25         System.out.println(p2.name);//Tom
26 
27         System.out.println("******************************");
28         //String不同拼接操作的对比
29         String s5 = "javaEE";
30         String s6 = "hadoop";
31 
32         String s7 = "javaEEhadoop";//一个字面量
33         String s8 = "javaEE" +"hadoop";//两个字面量的拼接，结果还是在常量池中，且由于内容和s7一样，所以共用一个。
34         String s9 = s5+"hadoop";//只要其中有一个是变量，结果就在堆中
35         String s10 = "javaEE"+s6;
36         String s11 = s5+s6;
37 
38         System.out.println(s7 ==s8 );//true
39         System.out.println(s7 ==s9 );//false
40         System.out.println(s7 ==s10 );//false
41         System.out.println(s7 ==s11 );//false
42         System.out.println(s9 ==s10 );//false
43         System.out.println(s9 ==s11 );//false
44 
45         //如果拼接的结果调用intern(),返回值就在常量池中
46         String s12 = s9.intern();//返回得到的s12使用的是常量池中已经存在的 "javaEEhadoop"
47         System.out.println(s7 == s12);//true
48 
49 
50     }
51 
52 }
53 
54 class Person{
55      String name;
56      int age;
57 
58     public Person(String name, int age) {
59         this.name = name;
60         this.age = age;
61     }
62 
63     public Person() {
64     }
65 
66 }

标签：常用,String,System,name,字符串,println,可变性,out
来源： https://www.cnblogs.com/fu-sir/p/15485101.html