【JavaSE】String类详解

flmz_Kk

已于 2024-05-23 02:38:43 修改

阅读量700

点赞数 29

分类专栏： JavaSE 文章标签： java 开发语言

于 2024-03-28 22:21:00 首次发布

本文链接：https://blog.csdn.net/flmz_Kk/article/details/137092146

版权

JavaSE 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

前言

1. 什么是String类

1.1 String的构造

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

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则未采用同步处理，属于线程不安全操作，但效率相对较高