Java基础二十九（String类）_定义类文件stringpractice-优快云博客

本文深入探讨 Java 中 String 类的特点与使用方法，包括其不可变性、内存分配、字符串拼接行为及与其它数据类型的转换技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

String：字符串，使用一对“”引起来表示

1.String声明为final的，不可被继承
2.String实现了Serializable接口：表示字符串支持序列化
实现了Comparable接口：表示String可以比较大小
3.String内部定义了final char[] value用于存储字符串数据
4.String：代表不可变的字符序列（不可变性）。
体现：
1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
2.当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
3.当调用String的replace（）方法进行修改执行字符或字符串时，也需要重新指定内存区域。
5.通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串声明在字符串常量池中。
6.字符串常量池不会存放相同内容的字符串

@Test
   public void test1(){
       String s1 = "abc";//字面量的定义方式
       String s2 = "abc";
//        s1 = "hello";

       System.out.println(s1 == s2);//比较s1和s2的地址//true

       System.out.println(s1);//hello
       System.out.println(s2);//abc

       System.out.println("**********************");

       String s3 = "abc";
       s3 += "def";
       System.out.println(s3);//abcdef
       System.out.println(s2);//abc

       System.out.println("**********************");

       String s4 = "abc";
       String s5 = s4.replace('a', 'm');
       System.out.println(s4);//abc
       System.out.println(s5);//mbc

   }

String的实例化方式：

方式一：通过字面量定义的方式
方式二：通过new + 构造器的方式
面试题：String s = new String(“abc”);方式创建了对象，在内存中创建了几个对象
两个：一个是堆空间中的new结构，另一个是char[]对应的常量池中的数据：“abc”

    @Test
    public void test2(){
        //通过字面量的定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中
        String s1 = "javaEE";
        String s2 = "javaEE";

        //通过new + 构造器的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应区域
        String s3 = new String("javaEE");
        String s4 = new String("javaEE");

        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s3 == s4);//false

        System.out.println("**********************");
        Person p1 = new Person("Tom", 12);
        Person p2 = new Person("Tom", 12);

        System.out.println(p1.name.equals(p2.name));//true(String 重写了方法，变为判断内容是否相等)
        System.out.println(p1.name == p2.name);//true  对象在堆里不一样，但是属性值是以字面量形式存在常量池中

        p1.name = "Jerry";
        System.out.println(p2.name);//Tom
    }

public class Person {
    String name;
    int age;

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

结论：

1.常量与常量的拼接结果在常量池中。且常量池中不会存在相同内容的常量。
2.只要其中有一个是变量，结果就在堆空间中
3.如果拼接的结果调用intern()方法，放回值就在常量池中

    @Test
    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);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s3 == s7);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false

        String s8 = s5.intern();//返回值得到的s8使用的常量值已经存在的“javaEEhadoop”
        System.out.println(s3 == s8);//true

    }

练习题：

public class StringPractice {

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

    public void change(String str, char ch[]){
        str = "test ok";
//        this.str = "test ok";
        ch[0] = 'b';
    }

    public static void main(String[] args) {
        StringPractice sp = new StringPractice();
        sp.change(sp.str, sp.ch);
        System.out.println(sp.str);//good
        System.out.println(sp.ch);//best
    }
}

涉及到String类与其他结构之间的转换

String 与基本数据类型、包装类之间的转换
String --> 基本数据类型、包装类：调用包装类的静态方法：parseXXX(str)
基本数据类型、包装类 --> String：调用String 重载的valueOf(xxx)

@Test
    public void test1(){
        String str1 = "123";
//        int num = (int)str1;
        int num = Integer.parseInt(str1);
        System.out.println(num);//123

        String str2 = String.valueOf(num);
        System.out.println(str2);//"123"

        String str3 = num + "";
        System.out.println(str3);//"123",在堆里
        System.out.println(str1 == str3);//false

    }

String 与 char[]之间的转换
String --> char[]:调用String的toCharArray()
char[] --> String:调用String的构造器

@Test
    public void test2(){
        String str1 = "abc123";

        char[] charArray = str1.toCharArray();
        System.out.println(charArray);
        for(int i = 0; i < charArray.length; i ++){
            System.out.println(charArray[i]);
        }

        char[] arr = new char[]{'h', 'e', 'l', 'l', 'o'};
        String str2 = new String(arr);
        System.out.println(str2);//hello
    }

String 与 byte[]之间的转换
String --> byte[]:调用String的getBytes()
编码：字符串 --> 字节（看的懂的 --> 二进制数据）
解码：编码的逆过程

@Test
    public void test3() throws UnsupportedEncodingException {
        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes();//使用默认的字符集进行转换,utf-8，一个汉字占三个字节
        System.out.println(Arrays.toString(bytes));//[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]


        byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码
        System.out.println(Arrays.toString(gbks));//[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]


        String str2 = new String(bytes);//使用默认的字符集，进行解码
        System.out.println(str2);//abc123中国

        String str3 = new String(gbks);//使用默认的字符集，进行解码，编码集和解码集不一致，出现乱码
        System.out.println(str3);//abc123�й�

        String str4 = new String(gbks, "gbk");
        System.out.println(str4);//abc123中国
    }
    
    @Test
    public void test4(){
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false

        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true

    }