【JavaSE】String类详解

前言

1. 什么是String类

1.1 String的构造

1.2 String类的基本操作：打印、拼接、求字符串长度

2. String类的常用方法

2.1 字符串查找

2.2 字符串替换

2.3 字符串拆分

2.4 字符串截取

2.5 字符串和其他类型的转换

2.6 去除字符串左右两边的空格

3. String对象的比较

3.1 比较字符串是否相等

3.2 比较字符串大小

4. 字符串不可变性

5. StringBuilder和StringBuffer：字符串修改

结语

前言

在C语言中，字符串单纯是字符数组的另一种叫法，我们是通过指针去操作它；而在Java中，却是有实打实的字符串类型，那就是String类，我们可以用String直接创建一个字符串出来。今天就让我们一起来学习一下Java中的String类以及它的一些常用方法吧

1. 什么是String类

概述：字符串是由多个字符组成的一串数字，也就是字符序列。在Java中所有的字符串变量都可以看作是字符串对象

1.1 String的构造

字符串有很多构造方式，常用的有以下三种：直接构造、使用new String构造、使用字符数组帮忙构造，我们最常用的还是第一种直接构造

    public static void main(String[] args) {
        //第一种：直接构造
        String str1 = "hello";

        //第二种：使用new String构造
        String str2 = new String("hello");

        //第三种：使用字符数组帮忙构造
        char[] chars = {'h','e','l','l','o'};
        String str3 = new String(chars);
    }

1.2 String类的基本操作：打印、拼接、求字符串长度

打印：直接打印

        String str = "hello";
        System.out.println(str);//hello

拼接：直接+=

        String str = "hello";
        str += "world";
        System.out.println(str);//helloworld

但是此类方法有瑕疵，在每次拼接的时候都会创建一个新的字符串，导致效率低下，关于这个问题，我们在下面会讲解到怎么高效拼接字符串

求字符串长度：和数组类似，数组求长度是用array.length，字符串求长度使用str.lengtg( )

        //求数组长度
        int[] array = {1,2,3,4,5};
        System.out.println(array.length);//5
        //求字符串长度
        String str = "hello";
        System.out.println(str.length());//5

2. String类的常用方法

2.1 字符串查找

（1）char charAt(int index)：返回index位置上的字符，如果index为负或者越界，就返回异常。我们可以用它来拆分一个字符串

        String str = "hello";
        char ch = str.charAt(4); //从零开始
        System.out.println(ch); //o

如果index是违法的，就会返回异常

我们可以用它来将字符串拆解成一个个字符存入字符数组，此时得到的字符数组ch就存放了字符串的所有字符

        String str = "hello";
        char[] ch = new char[str.length()];
        for (int i = 0; i < str.length(); i++) {
            ch[i] = str.charAt(i);
        }

（2）int indexOf(int ch)：返回ch第一次出现的位置，没有就返回-1

        String str = "hello";
        int ret = str.indexOf('o');
        System.out.println(ret);//4

（3）int indexOf(int ch，int fromIndex)：从fromIndex位置开始找ch第一次出现的位置，没有就返回-1

        String str = "hello";
        int ret1 = str.indexOf('l',3);
        System.out.println(ret1);//3
        int ret2 = str.indexOf('l',4);
        System.out.println(ret2);//-1

（4）int indexOf(String str)：返回str第一次出现的位置，没有就返回-1

        String str = "helloworld";
        int ret = str.indexOf("world");
        System.out.println(ret);//5

（5）int indexOf(String str，int fromIndex)：从fromIndex位置开始找str第一次出现的位置，没有就返回-1

        String str = "helloworld";
        int ret1 = str.indexOf("world",5);
        System.out.println(ret1);//5
        int ret2 = str.indexOf("world",6);
        System.out.println(ret2);//-1

（6）int lastIndexOf(int ch)：从后往前找，返回ch第一次出现的位置，没有就返回-1

        String str = "hello";
        int ret = str.lastIndexOf('e');
        System.out.println(ret);//1

（7）int lastIndexOf(int ch，int fromIndex)：从fromIndex位置开始，从后往前找ch第一次出现的位置，没有就返回-1

        String str = "hello";
        int ret1 = str.lastIndexOf('e',3);
        System.out.println(ret1);//1
        int ret2 = str.lastIndexOf('e',0);
        System.out.println(ret2);//-1

（8） int lastIndexOf(String str)：从后往前找，返回str第一次出现的位置，没有就返回-1

        String str = "hello";
        int ret = str.lastIndexOf("ll");
        System.out.println(ret);//2

（9） int lastIndexOf(String str，int fromIndex)：从fromIndex位置开始，从后往前找str第一次出现的位置，没有就返回-1

        String str = "hello";
        int ret1 = str.lastIndexOf("ll",4);
        System.out.println(ret1);//2
        int ret2 = str.lastIndexOf("ll",1);
        System.out.println(ret2);//-1

关于字符串查找：

当我们要提取字符串中某个索引位置的字符时，可以使用charAt方法
当我们想要查找某个字符或者某个字符串的位置时，从前往后的使用indexOf方法，从后往前的使用lastIndexOf方法

2.2 字符串替换

（1）String replace(char oldChar，char newChar)：字符整体替换

（2）String replace(String target，String replacement)：字符串整体替换

（3）String replaceFirst(String regex，String replacement)：替换字符串首个内容

（4）String replaceAll(String regex，String replacement)：替换字符串所有指定内容

        String str = "abcab";
        String ret1 = str.replace('a','h');
        String ret2 = str.replace("ab","hh");
        String ret3 = str.replaceFirst("ab","hh");
        String ret4 = str.replaceAll("ab","hh");
        System.out.println(ret1);//hbchb
        System.out.println(ret2);//hhchh
        System.out.println(ret3);//hhcab
        System.out.println(ret4);//hhchh

我们可以发现，第二个和第四个方法的功能是重合的，它们都能将字符串中的某个字符串整体替换掉

2.3 字符串拆分

（1）String[ ] split(String regex)：将字符串全部拆分

（2）String[ ] split(String regex, int limit)：将字符串拆分成limit组

        String str1 = "hello world";
        String[] ret1 = str1.split(" ");
        for (String s : ret1) {
            System.out.println(s);
        }
        System.out.println("=========");
        String str2 = "hello world hello life";
        String[] ret2 = str2.split(" ",2);
        for (String s : ret2) {
            System.out.println(s);
        }

我们常用来拆分一些字符，如邮箱123456@qq.com，但是有一些特殊字符作为分割符无法正确切分，需要在它的前面加上转义

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

注意事项：

字符 “ . ”，“ | ”，“ * ”，" + "都是特殊字符，都得在前面加上“ \\ ”才能转义并正确切分
如果是字符“ \ ”，那就需要写成“ \\ ”，因为它本身也是需要转义的
如果需要多个分隔符，那就可以在中间加上“ | ”作为连字符，“ | ”作为连字符时不需要转转义

        String str = "123456@qq.com";
        String[] ret = str.split("@|\\.");
        for (String s : ret) {
            System.out.println(s);
        }

2.4 字符串截取

（1）String substring(int beginIndex)：从指定索引截取到结尾

（2）Stirng snbString(int beginIndex, int endIndex)：截取部分内容（左闭右开）

        String str = "hello";
        System.out.println(str.substring(1));
        System.out.println(str.substring(1,4)); //左闭右开

2.5 字符串和其他类型的转换

（1）数值和字符串的转换（在转换对象时记得重写toString方法）

String String.valueOf（数值）

        String str1 = String.valueOf(1234);
        System.out.println(str1);
        String str2 = String.valueOf(new Student("张三",18));
        System.out.println(str2); //对象也可以转换

（2）大小写转换：

小写转大写——str.toUpperCase（）

大写转小写——str.toLowerCase（）

        String str = "hello";
        String str1 = str.toUpperCase();//小写转大写
        System.out.println(str1);
        String str2 = str.toLowerCase();//大写转小写
        System.out.println(str2);

（3）数组和字符串的转换：

字符串转数组——char[ ] String.toCharArray（）

数组转字符串——直接new String（charName）

        String str1 = "world";
        char[] ch1 = str1.toCharArray();
        for (int i = 0; i < ch1.length; i++) {
            System.out.print(ch1[i]+" ");
        }
        System.out.println();
        System.out.println("==========");
        char[] ch2 = {'h','e','l','l','o'};
        String str2 = new String(ch2);
        System.out.println(str2);

2.6 去除字符串左右两边的空格

String String.trim（）

        String str = "    a b c   ";
        System.out.println(str.trim());
        System.out.println("["+str.trim()+"]");

3. String对象的比较

String是引用类型，它的内部存储的并不是字符串本身，而是地址

正是因为这样，所有我们没办法直接比较两个字符串的谁大谁小，是否相等

3.1 比较字符串是否相等

（1）直接用“ == ”比较

        String str1 = "abc";
        String str2 = "abc";
        System.out.println(str1 == str2);

        String str3 = new String("cba");
        String str4 = new String("cba");
        System.out.println(str3 == str4);

可以猜猜看，两个打印的结果是多少？

为什么会这样呢？实际上这就是String类的特殊之处了。

我们直接构造str1时，它会在字符串常量池中存入“abc”，str1就指向这个地址，而在构造str2的时候，由于是直接构造，且内容一致，字符串常量池就不会再重现创建一份，str2也指向了同一地址。
但是str3和str4是使用new对象出来的，它们会各自在堆中开辟空间存放字符串的内容，str3和str4指向的地址就不一样了

（2）使用boolean equals（Object anObject）方法来判断字符串是否相等

        String str1 = "abc";
        String str2 = "abc";
        System.out.println(str1.equals(str2));
        
        String str3 = new String("cba");
        String str4 = new String("cba");
        System.out.println(str3.equals(str4));

运行结果如下

由此我们可以看出，equal方法跟直接比较不同，它可以根据对象中的内容来判断是否相等，当两字符串内容相等时，就会返回true，反之返回false

3.2 比较字符串大小

（字符串比较大小是根据每个位置上的字符的ASCII码值大小来比较的）

（1）int compareTo（String str）：用来判断字符串的大小，大于返回大于零，小于返回小于零，相等返回零

（2）int compareToIgnoreCase（String str）：功能跟上面的一样，但是它可以忽略大小写比较

        String str1 = "abc";
        String str2 = "cba";
        String str3 = "ABC";
        System.out.println(str1.compareTo(str2));
        System.out.println(str1.compareToIgnoreCase(str3));

4. 字符串不可变性

String是一种不可变对象，字符串在初始化后里面的内容就是不可改变的

我们之前对字符串进行的操作都会创建一个新的对象，我们改变的是新对象，所以我们需要尽量避免直接对String类型的对象进行修改，所有的修改都会创建对象，效率非常低

例如：String str = “abc”；

System.out.println(str + “def”);

5. StringBuilder和StringBuffer：字符串修改

由于String不可更改的性质，Java又给我们提供给了方法来修改字符串，也就是StringBuilder和StringBuffer。在这里我们简单演示一下StringBuilder该怎么使用：

        StringBuilder str = new StringBuilder("abc");
        System.out.println(str.append("def"));

StringBuilder也是一种引用类型，我们可以像String一样创建对象，然后使用str.append（“xxx”）在str尾部追加，用来拼接其他字符串，这样的好处在于：它不会产生额外的对象，效率非常高。

要注意的是：String和StringBuilder类不能直接转换，要想转换得使用特殊方法

String >>> StringBuilder：利用StringBuilder的构造方法或者是append（）方法
StringBuilder >>> String：调用toString（）方法

StringBuffer和StringBuilder功能十分相似，差别在于StringBuffer采用同步处理，属于线程安全操作，但是效率相对较低；而StringBuilder则未采用同步处理，属于线程不安全操作，但效率相对较高