24-7-31 String类详解

24-7-31 String类详解

String

String的结构

String对象用于保存字符串，也就是一组字符序列。

String字符串的字符使用Unicode的字符编码，一个字符无论是中文还是汉字都占两个字节。

String有许多重载的构造器，因此可以接收多种数据类型并创建对象，比如说下面的：

String s1 = new String();

String s2 = new String(String original);

String s3 = new String(char[] a);

String s4 = new String(char[] a,int startindex,int count);

String s5 = new String(byte[] b)…

String我们大多不陌生，观察它的继承结构也可以发现它主要是实现了三个接口。

其中,实现Serializable接口表示串行化，可在网络传输，Compareable表示可以比较大小。

String是final类，因此不能被其他类继承。

String有属性private final char value[],用于放置字符串内容，前面加了final表示不可以修改，不过不可以修改指的是地址不可以修改，不是数组里面的值不能修改，比如下面的

在这里，我们可以发现value数组中的值是可以修改的，但倘若我们想要让final类型的数组指向其他地址，编译器就会报错。

String的方法

String对象的两种创建方法

String对象有两种创建方法。

//方式一
String s = "hx";
//方式二
String s2 = new String("hx");

方式一首先看看常量池里面有没有”hx“，如果有，直接指向，如果没有，创建一个再指向，总之最后指向的是常量池的空间地址。

方式二现在堆中创建空间，里面维护value空间，指向常量池的hx空间，如果常量池没有hx，创建一个，如果有，直接指向，总之最后指向的是堆中的对象。

下面是两种方式的内存分布图：

String的其他方法

public class StringMethod02 {
    public static void main(String[] args) {
        String s1 = "heLLo java";
        System.out.println(s1.toUpperCase());//全部转大写
        System.out.println(s1.toLowerCase());//全部转小写
        
        String s2 ="hx";
        s2 = s2.concat("yyds").concat("jiayou");//拼接字符串
        System.out.println(s2);
        
        String s3 ="很喜欢喜欢喜欢";
        s3 = s3.replace("喜欢","讨厌");
        System.out.println(s3);//替换字符串
        
        String poem ="锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦";
        String[] poems = poem.split("，");
        for(String s : poems) {
            System.out.println(s);
        }//将字符串分割并装入字符串数组
        
        String address ="E:\\aaa\\bbb";
        String[] addresss =address.split("\\\\");
        for(String s:addresss) {
            System.out.println(s);
        }//分割标记是/的话要多加一个/
        
        char[] ch =s1.toCharArray();
        for(char c:ch) {
            System.out.println(c);
        }//将字符串放入字符数组
        
        String s4 ="hello";
        String s5 ="hel";
        System.out.println(s4.compareTo(s5));//字符串比较

        String name ="黄暄";
        int age =19;
        char gender = '男';
        String school = "江苏师范大学";
        String info = "我的名字是" + name +"，年龄是" + age +
                "，性别是"+gender+"，就读于"+ school;
        System.out.println(info);

        String formatStr ="我的名字是%s，年龄是%d,性别是%c，" +
                "就读于%s";
        String s6 = String.format(formatStr,name,age,gender,school);
        System.out.println(s6);//字符串拼接的两种方法

    }
}

输出为

HELLO JAVA
hello java
hxyydsjiayou
很讨厌讨厌讨厌
锄禾日当午
汗滴禾下土
谁知盘中餐
粒粒皆辛苦
E:
aaa
bbb
h
e
L
L
o

j
a
v
a
2
我的名字是黄暄，年龄是19，性别是男，就读于江苏师范大学
我的名字是黄暄，年龄是19,性别是男，就读于江苏师范大学

String练习

StringExercise01

public class StringExercise01 {
    public static void main(String[] args) {
        String a = "abc";
        String b = "abc";
        System.out.println(a.equals(b));
        System.out.println(a==b);
    }
}

我在上一篇博客曾经说过，equals比较的是值相等不相等，==比较的是地址相等不相等，在这里，第一个输出的肯定是true，因为都是abc，然后由于在a创建的时候常量池里面创建了一个abc，所以当创建b的时候会直接指向那个abc，也就是它们指向的地址相等，所以输出的也是true。

StringExercise02

public class StringExercise03 {
    public static void main(String[] args) {
        String a = "hx";
        String b = new String("hx");
        System.out.println(a.equals(b));
        System.out.println(a==b);
        System.out.println(a==b.intern());
        System.out.println(b==b.intern());
    }
}

第一个，两个String对象都是hx，所以equals输出true；

第二个，a指向的是常量池中的hx，b指向的是堆中的value，value指向常量池，所以输出false；

第三个，在做这题之前，我们应该先搞明白intern方法，我们来看定义

简单来说，就是如果在调用这个方法的时候，常量池中有和调用这个方法的String类对象相同的字符串，就返回常量池中这个字符串的地址，如果没有都话，就加一个这样的字符串。

所以当b调用intern方法时候，因为常量池中有hx，所以会返回hx的在常量池的地址，这个地址当然与a相等，所以返回的是true；

第四句，因为intern返回的是hx在常量池的地址，而b是指向堆的，所以不是相同的地址，输出flase；

StringExercise03

public class StringExercise04 {
    public static void main(String[] args) {
        String s1 = "hx";
        String s2 = "java";
        String s4 = "java";
        String s3 = new String("java");
        System.out.println(s2==s3);//F
        System.out.println(s2==s4);//T
        System.out.println(s2.equals(s3));//T
        System.out.println(s1==s2);//F
    }

还是之前讲的那一套，不多说。

StringExercise04

public class StringExercise05 {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "hx";
        Person p2 = new Person();
        p2.name = "hx";
        System.out.println(p1.name.equals(p2.name));//T
        System.out.println(p1.name == p2.name);//T
        System.out.println(p1.name == "hx");//T
        String s1 = new String("hx");
        String s2 = new String("hx");
        System.out.println(s1 == s2);//F
    }
}

这里需要注意，虽然开辟了两个对象，但是这两个对象都先后指向常量池的hx，所以如果只比较字符串的话，会输出true，但是要是比较字符串的话，因为指向堆的不同地址，所以还是输出false；

StringExercise05

public class StringExercise06 {
    public static void main(String[] args) {
        String s1 = "hello";
        s1 = "haha";
        //上面两行创建了两个对象
    }
}

上面两句话的意思其实是在创建字符串s1的时候先看看字符串有没有hello，如果有，直接指向，如果没有，直接创建，再指向，然后再在常量池里面创建一个haha的常量，再让s1指向haha，所以根本上是创建了两个对象。

StringExercise06

public class StringExercise07 {
    public static void main(String[] args) {
        String a = "hello" + "abc";//底层优化为helloabc
        System.out.println(a);
        //只创建了一个string对象
    }
}

为什么这里只创建了一个对象，因为编译器很聪明，它在底层会自动把这两个字符串拼接在以前，也就是“helloabc”，所以只需要创建一个对象。

StringExercise07

public class StringExercise008 {
    public static void main(String[] args) {
        String a = "hx";
        String b ="yyds";
        String c = a + b;
        //创建了三个string对象
        String d = "hxyyds";
        System.out.println(c == d);
        String e ="hx" +"yyds";
        System.out.println(e == d);
    }
}

输出

false
true

与上一题那种写法不一样，通过调试，我们可以知道，直接将字符串相加在底层的运行其实是，先创建一个StringBuilder的对象，然后执行它的append方法分别将hx与yyds拼接最后通过toString方法返回一个String对象给String c，所以c其实是指向堆的，然后堆中的value指向池中的hxyyds。

StringExercise08

public class StringExercise09 {
    public static void main(String[] args) {
        String s1 ="hx";
        String s2 = "java";
        String s5 ="hxjava";
        String s6 = (s1+s2).intern();
        System.out.println(s5 == s6);//T
        System.out.println(s5.equals(s6));//T
    }
}

前面讲过这个道理，因为在intern方法调用之前，池里已经有hxjava了，所以会直接指向现成的地址，因此返回true，当然内容也肯定相等。

StringExercise09

public class StringExercise10 {
    String str = new String("hx");
    final char[] ch = {'j','a','v','a'};
    public void change(String str,char[] ch) {
    str = "java";
    ch[0] = 'h';

    }

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

hxand
hava

接下来要讲的特别想C语言里面的值传递与地址传递，我的理解如下：在主栈中ex指向堆中的对象，然后调用change方法的时候因为要在栈中新开一个栈，原先这个栈中的str是指向堆中的value的，但是现在通过赋值语句，它指向了常量池中的java，ch它原先指向的是java，现在通过赋值语句把堆中的这个数组修改成了hava，在调用语句执行完毕以后，这个新栈就销毁了，此时ex指向的str没有改变，但是ex指向的char数组是发生改变了的。