一、前言

二、介绍和溯源

三、String类常用构造器

1.String()

2.String(byte[] bytes)

3.String(char[] value)

4.String(char[] value, int offset, int count)

5.String(String original)

Δ演示 :

四、不同方式创建String类对象的区别

1.直接赋值的方式

2.常规new的方式

3.内容延申

五、String类常用成员方法

0.前言 :

1.判断功能的方法 :

①boolean equals(Object anObject)

②boolean equalsIngoreCase(String anotherString)

③boolean startWith(String prefix)

④boolean isEmpty()

演示 :

2.获取功能的方法 :

①int length()

②char charAt(int index)

③int indexOf(String str)

④int indexOf(String str, int t)

⑤int lastIndexOf(String str)

⑥int compareTo(String anotherString)

⑦String substring(int beginIndex)

⑧String substring(int beginIndex, int endIndex)

演示 :

3.转换功能的方法：

①byte[] getByte()

②char[] toCharArray()

③static String valueOf(...)

④String replace(String old, String new)

⑤String[] split(String regex)

⑥String trim()

⑦String concat(String str)

⑧String toUpperCase()

⑨String toLowerCase()

⑩static String format(String format, Object... args)

演示 :

六、String类总结

一、前言

本节内容是我们《API-常用类》专题的第二小节了。本节内容主要讲String类，内容包括但不限于 String介绍和溯源 ， String类的类图 ， String类的构造器 ， 不同方式创建String类对象的区别，以及 String类常用方法的演示。up希望通过这篇博文的知识分享，能够帮助大家快速上手并理解java String类。 注意 : ① 代码中的注释也很重要； ② 不要眼高手低，自己敲一遍才能知道怎么用。 ③ 点击侧边栏目录或者文章开头的目录可以跳转。良工不示人以朴，所有文章都会适时改进。大家如果有什么问题，都可以在评论区一块儿交流，或者私信up。 感谢阅读！

二、介绍和溯源

字符串是一组用双引号括起来的字符序列，eg : "CSDN"，"Cyan"，"RA9"等等。每一个字符串对象都是常量。字符串中的字符使用unicode编码，一个字符（不区分中英文）均占两个字节。java中用String类描述字符串，如下图所示 :

可以看到，String类用final关键字修饰，因此String类是不可被其他类继承的；并且，通过String类中的属性value及其源码描述，我们可以得知String类的底层实际仍是字符数组byte[]。也就是说，new出的String对象在堆空间中，该对象的空间里有value属性，用于存放字符串的内容（实际是指向常量池的地址）。同时，该value数组也使用了final关键字修饰，我们在面向对象专题详解过final关键字，当final关键字修饰引用类型时，不可更改其引用的指向，即不能更改其保存的地址值。

接下来我们再来看看String类的“家庭关系图”。首先，String类属于java.base模块，java.lang包下，并且实现了Serializable，Comparable等接口。如下图所示 :

我们再来看看String类的类图，如下 :

可以看到，String类除了继承自Object类之外，还实现了许多接口。这么多接口中，大家只需要记住关键的两个接口——①Serializable接口，实现该接口使得String类型可串行化，串行化后，String类型可以进行网络传输。②Comparable接口，实现该接口使得String类型可以进行“比较”的操作。

三、String类常用构造器

String类的构造器非常多，如下图所示 :

有些还是过时的。当然，我们就挑几个重点的，常见的构造器给大家演示一下即可。

1.String()

该构造器可以初始化一个String对象，使其指向一个空字符序列。

2.String(byte[] bytes)

该构造器可以初始化一个String对象，并将指定字节数组中的数据转化成字符串。

3.String(char[] value)

该构造器可以初始化一个String对象，并将指定字符数组中的数据转化成字符串。

4.String(char[] value, int offset, int count)

该构造器可以初始化一个String对象，并将指定字符数组中的指定数据转化成字符串。

5.String(String original)

该构造器可以初始化一个String对象，使该对象实际指向的字符串常量与传入的字符串形参相同，相当于是形参的一份拷贝。

Δ演示 :

以String_Constructors为演示类，代码如下 :

package csdn.knowledge.api.string;

public class String_Constructors {
    public static void main(String[] args) {
    //演示 : String类的常用构造器
        //1 —— String()
        String str_0 = new String();
        System.out.println(str_0);
        System.out.println("--------------------");

        //2 —— String(byte[] bytes)
        byte[] bytes = {65, 66, 67, 68};   //65~68对应ASCII码表A~D
        String str_1 = new String(bytes);
        System.out.println(str_1);
        System.out.println("--------------------");

        //3 —— String(char[] value)
        char[] value = {'C', 'y', 'a', 'n', '_', 'R', 'A', '9'};
        String str_2 = new String(value);
        System.out.println(str_2);
        System.out.println("--------------------");

        //4 —— String(char[] value, int offset, int count)
        String str_3 = new String(value, 0, 4);
        System.out.println(str_3);
        System.out.println("--------------------");

        //5 —— String(String original)
        String str_4 = new String("CSDN yyds!");
        System.out.println(str_4);
    }
}

运行结果 :

四、不同方式创建String类对象的区别

1.直接赋值的方式

String类在实际开发中的使用场景非常多，java在底层提供了针对String类的优化，即可以不通过构造器来创建String对象。而是直接赋值一个字符串。
eg : String str_0 = "Cyan"; ，使用这种方式来创建String对象，jvm会先从常量池中查看是否有"Cyan"字符串的数据空间，若有，令引用变量直接指向该空间；若无，重写创建"Cyan"的数据空间并令其引用变量指向它。因此，str_0引用最终直接指向的是常量池中"Cyan"常量的空间地址。

内存图如下所示 :

2.常规new的方式

eg : String str_1 = new String("Cyan"); ，使用这种方式来创建String对象，jvm会先在堆空间中给String对象开辟空间，这片空间中维护了value数组这一属性，该属性指向常量池的"Cyan"数据空间。若常量池中没有"Cyan"，则重写创建"Cyan"数据空间，并让value引用指向该数据空间。最后，将该对象堆空间的地址值返回给str_1引用。因此，str_1引用最终直接指向的是堆中的空间地址。

内存图如下所示 :

3.内容延申

若使用字符串拼接的方式来创建字符串对象，如下 :
eg : String str_0 = "Cyan" + "RA9";
当我们以两个字符串拼接的形式来创建字符串对象时，jvm不会在常量池中分别创建"Cyan"字符串常量和"RA9"字符串常量，再把它们拼接起来。而是直接在底层优化，先把两个字符串拼接起来，之后直接去常量池中寻找有没有拼接起来的这个字符串常量，如果有，直接令该引用指向这个字符串常量的空间地址；如果没有则先创建该字符串常量，再让引用指向这里。当然，我们已经学过了Debug，此时我们就可以直接通过Debug来验证我们的结论，如下图所示 :

五、String类常用成员方法

0.前言 :

在IDEA类图中我们可以查看String类中的方法，如下GIF图所示 :

😂可以看到，String类中的方法真是多得⑧彳亍！不过你放心，up从这些方法中挑选了一些我们经常用到的方法，并根据它们的功能将其分为了“判断功能”，“获取功能”，以及“转化功能”三部分。如此一来，大家就可以放心食用🌶！

1.判断功能的方法 :

①boolean equals(Object anObject)

该方法可以判断当前字符串与指定对象的内容是否相同，实际在底层比较的就是字符串的内容，会区分大小写。

②boolean equalsIngoreCase(String anotherString)

该方法可以判断当前字符串与给定字符串的内容是否相同，不区分大小写。

③boolean startWith(String prefix)

该方法可以判断当前字符串是否以给定字符串开头。

④boolean isEmpty()

该方法可以判断当前字符串是否为空。

演示 :

以String_methods类为演示类，代码如下 :

package csdn.knowledge.api.string;

public class String_methods {
    public static void main(String[] args) {
    //演示 : String常用方法之判断功能的方法
        //1 —— boolean equals(Object anObject)
            String str_0 = "cyan";
            System.out.println("\"Cyan\"字符串与str_0字符串的内容相等吗？" + "Cyan".equals(str_0));
            System.out.println("================");

        //2 —— boolean equalsIgnoreCase(String anotherString)
            System.out.println("\"Cyan\"字符串与str_0字符串的内容相等吗？" + "Cyan".equalsIgnoreCase(str_0));
            System.out.println("================");

        //3 —— boolean startWith(String prefix)
            System.out.println("str_0字符串是否以\"cy\"开头？" + str_0.startsWith("cy"));
            System.out.println("str_0字符串是否以\"Cy\"开头？" + str_0.startsWith("Cy"));
            System.out.println("================");

        //4 —— boolean isEmpty()
            System.out.println("str_0字符串是否为空？" + str_0.isEmpty());
    }
}

运行结果 :

2.获取功能的方法 :

①int length()

获取当前字符串的长度。

②char charAt(int index)

获取指定位置索引的字符（指字符串的指定索引)。

③int indexOf(String str)

获取指定字符(串) 第一次出现的索引，默认从第0位开始。若返回-1，则表示没有该字符（串）。

④int indexOf(String str, int t)

功能与上一次方法相同，但默认从字符串索引第 t 位开始找。

⑤int lastIndexOf(String str)

获取指定字符(串)最后一次出现的索引，若没有，返回-1。

⑥int compareTo(String anotherString)

返回两个字符串对象的比较结果——若相等，返回0；若不相等，从两个字符串的第一个字符开始比较，返回第一个不相等的字符的ASCII码差值。当较长字符串的前面部分恰巧是较短的字符串时，返回两个字符串的长度差。

⑦String substring(int beginIndex)

获取指定索引位置（包含该位置) 之后的字符串。

⑧String substring(int beginIndex, int endIndex)

获取从索引beginIndex开始，到索引endIndex之间的字符串（区间为前闭后开）。

演示 :

以String_methods_2类为演示类，代码如下 :

package csdn.knowledge.api.string;

public class String_methods_2 {
    public static void main(String[] args) {
    //演示 : String常用方法之获取功能的方法
        //1 —— int length()
            String str_0 = "We are the best.";
            System.out.println("当前字符串str_0 : " + str_0);
            int length = str_0.length();
            System.out.println("str_0字符串的长度为：" + length);
            System.out.println("========================");

        //2 —— char charAt(int index)
            char ch_0 = str_0.charAt(0);
            char ch_1 = str_0.charAt(5);
            System.out.println("str_0字符串中，索引为0的字符是：" + ch_0);
            System.out.println("str_0字符串中，索引为5的字符是：" + ch_1);
            System.out.println("========================");

        //3 —— int indexOf(String str)
            int i_0 = str_0.indexOf('e');
            System.out.println("字符\'e\'在字符串str_0中首次出现时的索引为：" + i_0);
            int i_2 = str_0.indexOf("are");
            System.out.println("字符串\"are\"在字符串str_0中首次出现时的索引为：" + i_2);
            System.out.println("========================");

        //4 —— int indexOf(String str, int t)
            int i_1 = str_0.indexOf('e', 7);
            System.out.println("从字符串str_0索引为7的地方开始找，字符\'e\'在字符串str_0中首次出现时的索引为：" + i_1);
            System.out.println("========================");

        //5 —— int lastIndexOf(String str)
            int i_3 = str_0.lastIndexOf('t');
            System.out.println("字符\'t\'在字符串str_0中最后一次出现时的索引为：" + i_3);
            System.out.println("========================");

        //6 —— int compareTo(String anotherString)
                //第一种情况 : 俩字符串相同
            int i_4 = str_0.compareTo("We are the best.");
            System.out.println("compareTo方法返回0说明俩字符串相等: " + i_4);
                //第二种情况 : 俩字符串长度相同，内容不同
            int i_5 = str_0.compareTo("You are so good.");  //W : 77, Y : 79.
            System.out.println("\'W\'和\'Y\'的ASCII码差值为：" + i_5);
                //第三种情况 : 俩字符串长度不相同，但长的字符串的前一部分与短的字符串相同。
            int i_6 = str_0.compareTo("We are the best.we are the king!");
            int i_7 = "We are the best.we are the king!".compareTo(str_0);
            System.out.println("str_0字符串与传入字符串的长度差值为：" + i_6);
            System.out.println("传入字符串与str_0字符串的长度差值为：" + i_6);
            System.out.println("========================");

        //7 —— String substring(int beginIndex)
            String str_1 = str_0.substring(11); //"best."
            System.out.println("str_0字符串中，从索引11开始到结束的字符串为：" + str_1);
            System.out.println("========================");

        //8 —— String substring(int beginIndex, int endIndex)
            String str_2 = str_0.substring(7, 10);  //[7,10)——注意区间的格式。
            System.out.println("str_0字符串中，从索引7到10（不包括10）的字符串为：" + str_2);
    }
}

运行结果 :

3.转换功能的方法：

①byte[] getByte()

将字符串转换成字节数组。（ASCII码）。

②char[] toCharArray()

将字符串转换成字符数组。

③static String valueOf(...)

将指定类型数据转换成字符串。

④String replace(String old, String new)

将指定字符(串)替换为新的字符(串)。原字符串不受影响。

⑤String[] split(String regex)

以传入的字符(串)为标准来切割原字符串，返回切割后的字符串数据，以String类型的数组作为接收。原字符串不受影响。

⑥String trim()

去掉字符串两端的空白字符。（eg : 对登录账号和密码的处理）。

⑦String concat(String str)

将传入的字符串拼接到当前字符串的末尾。

⑧String toUpperCase()

将当前字符串全部转换成大写后返回。

⑨String toLowerCase()

将当前字符串全部转换成小写后返回。

⑩static String format(String format, Object... args)

将指定参数以指定的输出控制格式来输出。形参“String format部分”即输出格式控制，是包含占位符的String类型。形参“Object... args”部分即要输出的参数。占位符由后面的参数按照顺序来一一替换。
至于什么是占位符，比如 : "%s", "%d", "%f"这些，就是C语言中的printf语句用的那几个，这里不再赘述。

演示 :

以String_methods_3类为演示类，代码如下 :

package csdn.knowledge.api.string;

public class String_methods_3 {
    public static void main(String[] args) {
    //演示 : String常用方法之转换功能的方法
        //1 —— byte[] getByte()
            String str_0 = "ABCD";  //A~D对应ASCII码值 = 65~68
            byte[] bytes = str_0.getBytes();
            for (int i = 0; i < bytes.length; i++) {
                System.out.println("字节数组的第" + (i + 1) + "个元素 = " + bytes[i]);
            }
            System.out.println("-----------------------");

        //2 —— char[] toCharArray()
            char[] chars = str_0.toCharArray();
            for (int i = 0; i < chars.length; i++) {
                System.out.println("字符数组的第" + (i + 1) + "个元素 = " + chars[i]);
            }
            System.out.println("-----------------------");

        //3 —— static String valueOf(...)
            String str_1 = String.valueOf(1111);
            String str_2 = String.valueOf('h');
            String str_3 = String.valueOf(123.6666);
            System.out.println("int类型转String类型：" + str_1);
            System.out.println("char类型转String类型：" + str_2);
            System.out.println("double类型转String类型：" + str_3);
            System.out.println("-----------------------");

        //4 —— String replace(String old, String new)
            String str_4 = "You_are_so_beautiful!";
            String str_5 = str_4.replace('_', ' ');    //以' '替换掉'_'
            System.out.println("原字符串：" + str_4);
            System.out.println("新字符串：" + str_5);
            System.out.println("-----------------------");

        //5 —— String[] split(String regex)
            String str_6 = "What hahaa hahacoincidence haha!";
            String[] strings = str_6.split("haha");     //以"haha"来切割字符串。
            for (String string : strings) {
                System.out.print(string);
            }
            System.out.println("\n-----------------------");

        //6 —— String trim()
            String str_7 = "      hey,man!    ";
            String str_8 = str_7.trim();
            System.out.println("去掉两端空白字符前的字符串：" + str_7);
            System.out.println("去掉两端空白字符后的字符串：" + str_8);
            System.out.println("-----------------------");

        //7 —— String concat(String str)
            String str_9 = "I ";
            String str_10 = str_9.concat("love ").concat("programming!");
            System.out.println("拼接后的字符串str_10 = " + str_10);
            System.out.println("-----------------------");

        //8 —— String toUpperCase()
            String str_11 = "i love you!";
            System.out.println("大写之前的字符串：" + str_11);
            System.out.println("大写之后的字符串：" + str_11.toUpperCase());
            System.out.println("-----------------------");

        //9 —— String toLowerCase()
            System.out.println("小写之前的字符串：" + str_11.toUpperCase());
            System.out.println("小写之后的字符串：" + str_11.toUpperCase().toLowerCase());
            System.out.println("-----------------------");

        //10 —— static String format(String format, Object... args)
            String name = "Cyan";
            int age = 21;
            String hobby = "programming!";
            String sss = String.format("My name is %s, and I'm %d years old, my hobby is %s", name, age, hobby);
            System.out.println(sss);
    }
}

运行结果 :

六、String类总结

🆗，以上就是关于String类的全部内容了。希望这篇博文的内容分享，可以帮助大家对String类有进一步的认识。同时，关于String类的常用方法，up都做了较为详细的演示和批注，大家可以多回来看看😆。API专题的下一小节，我们来讲讲常用类StringBuilder和StringBuffer类，不见不散。感谢阅读！