对Java中String类的解释

一、String 的常用方法

首先，在介绍 String 类的常用方法之前，我们需要明白，Java 中为何要引入这样一个元素？

我们在 C 语言中都已经接触过字符串了，但是在 C 语言中要表示字符串只能使用字符数组 或 字符指针，可以使用其标准库中提供的字符串系列函数来完成需要的操作，但是，在 Java 中，将数据和操作数据方法分离的方式不符合面向对象的思想，因而设计了 String 类。

1.字符串的构造以及字符串常量池

String 类为构造字符串提供了很多的方法结构，但是常用的通常为以下三种。

        //1.使用常量串直接构造
        String s1 = "hello s1";
        System.out.println(s1);

        //2.使用new String 对象
        String s2 = new String("hello s2");
        System.out.println(s2);

        //3.利用字符数组进行构造
        char[] array = {'h','e','l','l','o',' ','s','3'};
        String s3 = new String(array);
        System.out.println(s3);

注意：我们在建立字符串时，有时会出现类似这种语句

        String s1 = "hello";
        String s2 = "world";
        String s3 = s1;

这里我们要明确一点，String 是引用类型，并不存储元素本身，所以，这里的 s3 并不是创建了一个新的元素，而是指向了 s1 这里创建的元素，如图：

字符串常量池
在上面的字符串构造中，其中的图示，阐述了为什么 s1 和 s3 是指向同一个对象，这也就是字符串常量池的一种类似的描述。

简单解释：字符串常量池是指，将一些常用的字符串，在堆区中提前存储一份，当要使用这些字符串时，无需再开辟新的空间进行存储，直接调用即可。

2.String 类中对象的比较

1. 用"=="来比较是否引用同一个对象

   在通常的内置类型中 == 是用来比较变量中的值是否相同，但在引用类型中 == 是用来比较元素存储的地址是否相同。

例如：内置类型

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 10;
        System.out.println(a==b);
        System.out.println(a==c);
    }

引用类型

        String s1 = new String("hello");
        String s2 = new String("world");
        String s3 = new String("hello");
        String s4 = s1;

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

这里要注意，引用类型中要出现上述情况，必须是 new String() 对象实现，如果进行字符串直接构造结果就会出现差异。

如：

        String s1 = "hello";
        String s2 = "world";
        String s3 = "hello";
        String s4 = s1;

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

2. boolean equals(Object anObject) 方法：按照字典序比较

s1.equals(s2)

String 类重写了父类 Object 中的 equals 方法，在 Object 中 equals 默认按照的是 == 进行比较，而在 String 中重写后按照以下的方式进行比较。

• （1）传入元素后检测传入元素 Object 和 anObject 是否为同一对象比较
• （2）检测是否为 String 类型的元素，如果是就继续比较。
• （3）检测两个字符串的长度是否相同，如果是就继续比较。
• （4）按找字典序，从前往后依次对两个字符串进行比较。

比较方法代码示例：

        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("Hello");

        System.out.println(s1.equals(s2));  //s1 和 s2 中的元素进行比较打印 true
        System.out.println(s1.equals(s3));  //s1 和 s3 中的元素进行比较打印 false

3. int compareTo(String s) 方法: 按照字典序进行比较

s1.compareTo(s2)

compareTo 方法和 equals 不同的是，equlas返回的是 boolean 类型，而 compareTo 方法返回的是 int 类型。

• （1）按照字典次序大小比较，如果出现不相等的字符，直接返回这两个字符串的大小差值.
• （2）如果前 K 个字符相等（K 的长度 >= 2）,返回的是两个字符串的长度差值。

        String s1 = new String("abc");
        String s2 = new String("az");
        String s3 = new String("abcdef");
        String s4 = new String("abc");

        System.out.println(s1.compareTo(s2));   //b 98 和 z 122 相差 24 输出 -24
        System.out.println(s1.compareTo(s4));   //字符串元素相等输出 0
        System.out.println(s1.compareTo(s3));   //前 3 个字符串相同，输出长度差值 -3

int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较

3.字符串查找

如图，String 提供的常用的查找方法

        String s = "aaabbbcccaaabbbccc";
        System.out.println(s.charAt(3));    //查找第 3 个元素
        System.out.println(s.indexOf('c'));     //返回 c 第一次出现的位置
        System.out.println(s.indexOf('c', 10));     //从第 10 个位置开始，返回第一次出现 c 的位置
        System.out.println(s.indexOf("bbb"));   // 返回 ‘bbb’ 第一次出现的位置
        System.out.println(s.indexOf("bbb", 10));   //从第 10 个位置开始，返回第一次出现‘bbb’的位置
        System.out.println(s.lastIndexOf('c'));     //从后往前找到第一个出现 c 的位置
        System.out.println(s.lastIndexOf('c', 10));     //从正数第 10 个开始，从后向前找到第一次出现 c 的位置
        System.out.println(s.lastIndexOf("bbb"));
        System.out.println(s.lastIndexOf("bbb", 10)); // 字符串同理

4.转化

1. 数值和字符串变化

valueOf() //方法实现数字转字符串

        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        String s3 = String.valueOf(true);

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);

（2）将字符串转换为数字

        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");

        System.out.println(data1);
        System.out.println(data2);

2. 大小写转化

toUpperCase() 小写转大写
toLowerCase() 大写转小写

        String s1 = "hello";
        String s2 = "HELLO";

        System.out.println(s1.toUpperCase());
        System.out.println(s2.toLowerCase());

3. 字符串转数组

toCharArray(); //将字符串转化为数组方法

		String s = "hello";
        char[] ch = s.toCharArray();    //将String 转化为数组类型
        for (int i = 0; i < ch.length; i++) {
            System.out.print(ch[i]);
        }
        System.out.println();

        String s2 = new String(ch);     //将数组转化成字符串
        System.out.println(s2);

4. 格式化

format(); //将数字转化成所需的格式形式

        String data = String.format("%d/%d/%d",2022,12,20);
        //%d 之间的分割符 / 可以根据需要变换
        System.out.println(data);

5.字符串替换

        String str = "HelloWorld";

        String all = str.replaceAll("l","*");
        //将所有的 l 替换成 * 
        String first = str.replaceFirst("l","*");
        //将第一个出现的 l 替换成 *
        System.out.println(all);
        System.out.println(first);

6.字符串拆分

（1）按照空格进行拆分

        String str = "Hello world hello boy";

        String[] result = str.split(" ");   //按照空格进行拆分
        for (int i = 0; i < result.length; i++) {
            System.out.println(result[i]);
        }

（2）将字符串按照部分拆分

        String str = "Hello world hello boy";

        String[] result = str.split(" ",2);   //以第一个空格为界，将字符串分为两部分
        for (int i = 0; i < result.length; i++) {
            System.out.println(result[i]);
        }

（3）对于特定的分割条件需要转译

例如: 当前要将 ip 地址依照 “.” 进行分割。

不难看出这样直接输入分割对象是错误操作

正确操作如下：

        String str = "192.168.1.1";

        String[] result = str.split("\\.");
        for (String s:result) {
            System.out.println(s);
        }

对于字符串的多次分割

        String str = "name=zhangsan&age=18";

        String[] result = str.split("&");   //根据 & 先将整体分为两部分
        for (int i = 0; i < result.length; i++) {

            String[] temp = result[i].split("=");   //在进行细分

            System.out.println(temp[0]+"="+temp[1]);
        }

7.字符串截取

        String str = "helloworld";

        String one = str.substring(5);
        String two = str.substring(0,5);

        System.out.println(one);
        System.out.println(two);

二、StringBuilder 和 StringBuffer

1.引入两者的原因

1. 字符串的不可变性

   String 类在设计时就是不可改变的，如图：
   
   String 类中的字符实际保存在内部维护的 value 字符数组中，从图中还可以看出：
   (1) String 类被 final 进行修饰，表明该类不能被继承。
   (2) value 被 final 修饰，表明 value 自身的值不能改变，即，不能引用其他的字符数组，但是其引用空间的内容都可以修改。

因此，为了避免对 String 类的直接修改，我们就需要引入 StringBuilder 和 StringBuffer 进行修改。

2.相关修改操作的介绍

在 Java 中提供的修改字符串操作 StringBuilder和StringBuffer类，这两大类的部分操作功能是相同的，在这里介绍一些常用的 StringBuilder 操作方法。

1. append（String str）
   在尾部追加字符串，相当于String 的 += 操作。

        StringBuilder sb1 = new StringBuilder("hello");
        //追加：即尾插如--> 字符、字符串、整形数字。
        sb1.append(' ');    //插入空格
        sb1.append("world");    //插入world字符
        sb1.append(123);    //插入123
        System.out.println(sb1);

2. char charAt（int index）
   获取 index 位置的字符

        char a = sb1.charAt(0);	//获取0下标的字符串元素，使用 char 类型
        System.out.println(a);

3. int length（）
   获取字符串长度

        int b = sb1.length();   //获取字符串的有效长度
        System.out.println(b);

4. int capacity（）
   获取底层保存字符串的总长度大小

        int c = sb1.capacity();     //获取底层数组的总大小
        System.out.println(c);

5. setCharAt（int index，char ch）
   将 index 位置的字符设置为 ch

        sb1.setCharAt(0,'H');   //修改设置任意位置的字符 h-->H
        System.out.println(sb1);

6. insert（int index，char ch）
   在 index 位置前插入 ch 字符串

        sb1.insert(1,"Hello world!!!");     //在任意前位置插入字符
        System.out.println(sb1);

7. indexOf（char ch）
   查找字符 ch 第一次出现的位置

        int d = sb1.indexOf("Hello");	//查找第一次 Hello 出现的位置
        System.out.println(sb1);
        System.out.println(d);

8. lastIndexOf（char ch）
   获取 ch 最后一次出现的位置

        int e = sb1.lastIndexOf("123");
        System.out.println(sb1);
        System.out.println(e);

9. deleteChar（0）
   删除指定位置的字符串元素

   System.out.println(sb1.deleteCharAt(0));

10. delete（int start，int end）
    删除指定范围的元素

        System.out.println(sb1.delete(0,6));

注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:

• String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
• StringBuilder变为String: 调用toString()方法。

到此, 文章结束, 如有不足, 欢迎提出. 如有错误, 欢迎指正!