• 【Java课堂】String类

    🎈目录🎈

    🥾前言

    1.字符串构造

    2.String 对象的比较 

    3.字符串查找

    4.转化

    1. 数值、对象、布尔值转化为字符串

     2.大小写转化

     3.字符串转数组

    4.格式化

    5.字符串替换

    6.字符串拆分

    7.字符串截取

    8.字符串常量池

    1.创建对象的思考

     2.字符串常量池（StringTable）

    3.深度讲解String对象创建

    9.字符串的不可变性

    10.字符串修改

    前言

            对于刚学过C语言的小伙伴来说，String类可能比较陌生。在C语言中我们可以用指针来表示一串字符  如 char* p = "abcd" ，而在Java中我们可以用String类来直接表示 String p = "abcd"。

    是不是方便许多，同时String类还具有很多实用的方法，现在让我们开始String类的学习吧！

    1.字符串构造

    String 类提供的构造方式非常多，常用的有以下三种

    1. public static void main(String[] args) {
    2.         //使用常量串构造
    3.         String s1 = "你好！";
    4.         
    5.         //直接 newString 对象
    6.         String s2 = new String("我是");
    7.  
    8.         //使用字符数组进行构造
    9.         char[] array ={'S','t','r','i','n','g','类'};
    10.         String s3 = new String(array);
    11.         
    12.         //打印
    13.         System.out.println(s1);
    14.         System.out.println(s2);
    15.         System.out.println(s3);
    16.     }

    如果想了解更多方法，可以参考Java在线文档 

     【注意】

    ① String是引用类型，内部并不存储字符串本身，这点我们可以从原码看出，其内部分为两部分 分别为 value 【存储数组】和 hash【默认为0】

    1. public static void main(String[] args) {
    2.         // s1 和 s2引用的是不同对象 s1 和 s3引用的是同一对象
    3.         String s1 = new String("hello");
    4.         String s2 = new String("world");
    5.         String s3 = s1;
    6.     }

     ② 在Java中 "" 引起来的也是String类型对象

    1. // 打印"hello"字符串(String对象)的长度
    2. System.out.println("hello".length());

    2.String 对象的比较 

     字符串比较是常见的操作之一，比如：字符串排序。Java中总共提供4中方式：

    ⅰ ==比较是否引用同一个对象  

    注意：对于内置类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址

    1. public static void main(String[] args) {
    2.         //对于引用类型==比较的是引用中的地址
    3.         String s1 = new String("hello");
    4.         String s2 = new String("hello");
    5.         String s3 = new String("world");
    6.         String s4 =s1;
    7.         System.out.println(s1 == s2);//false
    8.         System.out.println(s2 == s3);//false
    9.         System.out.println(s1 == s4);//true
    10.     }

     ⅱ equals方法比较

    equals是Object中的方法，但是String类中重写了该方法，用于比较String类中引用内容是否相同 用法如下

    1. public static void main(String[] args) {
    2.         //对于引用类型==比较的是引用中的地址
    3.         String s1 = new String("hello");
    4.         String s2 = new String("hello");
    5.         String s3 = new String("world");
    6.         
    7.         //equals比较： String对象中的逐个字符
    8.         //虽然s1和s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
    9.         //s2和s3引用的不是同一个对象，而且两个对象中内容也不相同，因此输出true
    10.         System.out.println(s1.equals(s2));
    11.         System.out.println(s2.equals(s3));
    12.     }

     关于equals更多细节可以参考：equals() 方法详解

    ⅲ compareTo(String s) 方法：按照字典序进行比较

    字典序：字符串大小的顺序

    与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：

    1. 先按照字典序大小比较，如果出现不等的字符，直接返回这连个字符的大小差值
    2. 如果前k个字符相等，返回两个字符串的差值
    1. public static void main(String[] args) {
    2.         String s1 = new String("abc");
    3.         String s2 = new String("ac");
    4.         String s3 = new String("abc");
    5.         String s4 = new String("abcdefg");
    6.         String s5 = new String("ABC");
    7.  
    8.         System.out.println(s1.compareTo(s2));//不同输出字符差值-1
    9.         System.out.println(s1.compareTo(s3));//相同输出0
    10.         System.out.println(s1.compareTo(s4));//前k个字符完全相同，输出长度差值-4
    11.         System.out.println(s1.compareTo(s5));//大写和小写判定为两个字符串
    12.     }

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

    1. public static void main(String[] args) {
    2.         String s1 = new String("abc");
    3.         String s2 = new String("aBc");
    4.         String s3 = new String("ABc");
    5.         String s4 = new String("abcdefg");
    6.         String s5 = new String("ABC");
    7.  
    8.         System.out.println(s1.compareToIgnoreCase(s2));
    9.         System.out.println(s1.compareToIgnoreCase(s3));
    10.         System.out.println(s1.compareToIgnoreCase(s4));
    11.         System.out.println(s1.compareToIgnoreCase(s5));
    12.     }

    3.字符串查找

    字符串查找也是字符串中常见的操作，String类提供了常用查找方法：

    方法功能
    char charAt(int index)【用到次数很多】返回index位置上的字符，如果index为负数或者越界，则会抛出IndexOutOfBoundsException异常
    int indexOf(int ch)返回ch第一次出现的位置，没有返回-1
    int indexOf(int ch , int fromindex)从fromIndex位置开始找ch第一次出现的位置，没有返回-1
    int indexOf(String str)返回str第一次出现的位置，没有返回-1
    int indexOf(String str, int fromindex)从fromIndex位置开始找str第一次出现的位置，没有返回-1
    int lastIndexOf(int ch)从后往前找，返回ch第一次出现的位置，没有返回-1
    int lastIndexOf(int ch, int fromindex)从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1
    int lastIndexOf(String str)从后往前找，返回str第一次出现的位置，没有返回-1
    int lastIndexOf(String str,int fromIndex)从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1
    1. public static void main(String[] args) {
    2.         String str = "abc abc abc defg abc cba";
    3.  
    4.         System.out.println(str.length());//24
    5.         System.out.println(str.charAt(2));//c
    6.  
    7.         System.out.println(str.indexOf('e'));//13
    8.         System.out.println(str.indexOf('a',7));//8
    9.         System.out.println(str.indexOf("abc"));//返回首字母a位置的值 0
    10.         System.out.println(str.indexOf("abc",3));//4
    11.  
    12.         System.out.println(str.lastIndexOf('c'));//21
    13.         System.out.println(str.lastIndexOf('c',20));//17
    14.         System.out.println(str.lastIndexOf("abc"));//返回首字母a位置的值 17
    15.         System.out.println(str.lastIndexOf("abc",16));//8
    16.     }

    注意：上述方法都是实例方法

    4.转化

    1. 数值、对象、布尔值转化为字符串

    一般情况下数值、对象或布尔值是不行转化成字符串的，但是String类提供了一个valueOf方法可以把这些转化成字符串

     具体操作如下

    1. public static void main(String[] args) {
    2.         String str1 = String.valueOf(123);
    3.         String str2 = String.valueOf(6.6);
    4.         String str3 = String.valueOf(true);
    5.         System.out.println(str1);
    6.         System.out.println(str2);
    7.         System.out.println(str3);
    8.     }

     而对象转化成字符串有点复杂，如果该对象类型没有重写toString方法的话，valueOf就会调用Object类中的toString方法，最后字符串中存放的是该对象的hash值

    1. public static void main(String[] args) {
    2.         String str = String.valueOf(new Student(10));
    3.         System.out.println(str);
    4.     }

    如果该类重写了toString方法，那就存放是toString方法中的内容

    1. class Student{
    2.     int age;
    3.  
    4.     public Student(int age) {
    5.         this.age = age;
    6.     }
    7.  
    8.     @Override
    9.     public String toString() {
    10.         return "Student{" +
    11.                 "age=" + age +
    12.                 '}';
    13.     }
    14. }
    15. public class Test {
    16.     public static void main(String[] args) {
    17.         String str = String.valueOf(new Student(10));
    18.         System.out.println(str);
    19.     }
    20. }

     

     2.大小写转化

    String类中也提供了大小写转换的方法

    小写转大写：toUpperCase()

    大写转小写：toLowerCAse()

    当上述两个方法只会对英文转换，对中文无效，同时改变大小写，并不是把当前字符串的值改变，而是产生新的字符串！

    1. public static void main(String[] args) {
    2.         String s1 = "hello";
    3.         String s2 = "HELLO";
    4.         //小写转大写
    5.         String ret = s1.toUpperCase();
    6.         System.out.println(ret+" s1->"+s1);
    7.         //大写转小写
    8.         ret = s2.toLowerCase();
    9.         System.out.println(ret+" s2->"+s2);
    10.     }

     3.字符串转数组

    String类中还提供了一个toCharArray方法，可以把字符串有引用的数据提取出来转换为数组

    1. public static void main(String[] args) {
    2.         String s = "hello";
    3.         //字符串数组
    4.         char[] ch = s.toCharArray();
    5.         for (int i = 0; i < ch.length; i++) {
    6.             System.out.println(ch[i]);
    7.         }
    8.         System.out.println();
    9.         //数组转字符串
    10.         String s2 = new String(ch);
    11.         System.out.println(s2);
    12.     }

     

    4.格式化

    1. public static void main(String[] args) {
    2.      String s = String.format("%d-%d-%d", 2019, 9,14);
    3.      System.out.println(s);
    4. }

    5.字符串替换

    使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：

    方法功能
    String replaceAll(String regex, String replacement)
    		替换所有指定内容
    String replaceFirst(String regex, String replacement)
    		替换首个指定内容

    regex: 要替换字符串内容        replacement：替换成字符串内容

    1. public static void main(String[] args) {
    2.         String s="我不想学习，我不想内卷，我不想打代码";
    3.         System.out.println(s.replaceAll("不想","想"));
    4.         System.out.println(s.replaceFirst("我不想学习", "麻木了"));
    5.     }

     注意事项: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串。

    6.字符串拆分

    可以将一个完整的字符串安装指定的分隔符划分为若干个子类，可用方法如下：

    方法功能
    String[] split(String regex)
    		将字符串全部拆分
    String[] split(String regex, int limit)
    		将字符串以指定的格式，拆分为limit组

    我想大家一个都做个这个题，将字符串按照空格拆分

    1. public static void main(String[] args) {
    2.         String str = "hello world welcom to study Java";
    3.         String[] ret = str.split(" ");
    4.         for (String s:ret) {
    5.             System.out.println(s);
    6.         }
    7.     }

     我们还可以在split方法中添加参数，表明拆分几组

    String[] ret = str.split(" ",3);

     拆分是特别常用的操作. 一定要重点掌握. 另外有些特殊字符作为分割符可能无法正确切分, 需要加上转义。

    例如：拆分IP地址

    1. public static void main(String[] args) {
    2.         String str = "192.168.1.1";
    3.         String[] ret = str.split("\\.");
    4.         for (String s:ret) {
    5.             System.out.println(s);
    6.         }
    7.     }

    注意事项:

    1.  字符"|","*","+"都得加上转义字符，前面加上 "\\" 。
    2. 而如果是 "\" ，那么就得写成 "\\\\" 。
    3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符。

    7.字符串截取

    从一个完整的字符串之中截取部分内容，可用方法如下：

    方法功能
    String substring(int beginIndex)
    		从指定索引截取到结尾
    String substring(int beginIndex, int endIndex)
    		截取部分内容

     beginIndex：起始位置      endIndex：结束位置

    1. public static void main(String[] args) {
    2.         String s = "helloworld";
    3.         System.out.println(s.substring(5));
    4.         System.out.println(s.substring(0,5));
    5.     }

     注意事项:

    1. 索引从0开始。
    2. 注意左闭右开, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标[ 0, 5 )。

    8.字符串常量池

    1.创建对象的思考

    我们知道对于引用类型==比较的是引用的对象是否相同，我们来看下面代码

    1. public static void main(String[] args) {
    2.         String s1 = "hello";
    3.         String s2 = "hello";
    4.         String s3 = new String("hello");
    5.         String s4 = new String("hello");
    6.         System.out.println(s1 == s2);
    7.         System.out.println(s1 == s3);
    8.         System.out.println(s3 == s4);
    9.     }

     上述程序创建方式类似，那为什么s1和s2引用的是同一个对象，而s3和s4不是呢？

    在Java程序中，类似于：1 、2、3.14、" hello " 等字面类型的常量经常频繁使用，为了使程序的运行速度更快、更节省内存，Java为8种基本数据类型和String类都提供了常量池。

    “池”是编程中的一种常见的，重要的提升效率的方式，我们会在未来的学习中遇到各种“内存池”，“线程池”，“数据库连接池”....

    我来举一个池化技术的示例

    比如我们学习编程要看关于编程的书籍

            1. 当我们学习数据库时，我们就要去书柜找关于数据库的书，看完就要放回去。如果接下来我们遇到关于数据库的问题，那我们还要再去书柜找关于数据库的书，这样效率低，速度慢。

            2.我们在书桌上放一个书架，将我们想要学习编程相关书籍放到书架里面，随拿随用，效率高，速度快。

    对于池化技术来说，方式2就是池化技术的一种实例，书放书架上，随去随用，效率非常高。

     为了节省存储空间以及程序的运行效率，Java中引入了：

    1. Class文件常量池：每个.java源文件编译后生成.Class文件中会保存当前类中的字面常量以及符号信息
    2. 运行时常量池：在.Class文件被加载时，.Class文件中的常量池被加载到内存中称为运行时常量池，运行时常量池每个类都有一份。
    3. 字符串常量池

     2.字符串常量池（StringTable）

    字符串常量在JVM中是StringTable类，实际上是一个固定大小的HashTable，在不同JDK版本下字符串常量池的位置以及默认大小是不同的：

    JDK版本字符串常量池位置大小设置
    Java6（方法区）永久代固定大小：1009
    Java7堆中可设置，没有大小限制，默认大小：60013
    Java8堆中可设置，有范围限制，最小是1009

    3.深度讲解String对象创建

    由于不同JDK版本对字符串常量池的处理方式不同，此处在Java8 HotSpot上分析

    1.直接使用字符串常量进行赋值

    1. public static void main(String[] args) {
    2.         String s1 = "hello";
    3.         String s2 = "hello";
    4.         System.out.println(s1 == s2);//true
    5.     
    6.     }

    接下我来展示一下，上述代码在内存中的情况。

    在内存中，我们可以分为虚拟机栈和堆区，而s1 和 s2 变量在虚拟机中存储，而StringTable哈希表在堆中存储。

    对于没有学过哈希表的读者，我们可以把它理解为一个数组，而数组中的每个元素是一个链表。而链表中每个结点又都包含一个hash值和一个String对象。而我们代码中的常量字符串“hello”，就存在String对象所引用的数组存储。是不是有点绕，我们来看下图

     如图，在字节码加载时，“hello”常量串就已经创建好了，并保存在字符串常量池中。当时用String s1 = "hello";创建对象时，先在字符串常量池中找，找到了，就将该字符串引用赋值给s1。同理，对s2的操作也是如此。

    2.通过new创建String类对象

    1. public static void main(String[] args) {
    2.         String s3 = new String("hello");
    3.         String s4 = new String("hello");
    4.         System.out.println(s3 == s4);//false
    5.     }

    s3和s4都是new了一个对象，也就是在堆上开辟String对象大小的空间，且这两个对象在堆中的存储地址不同， 然后常量池把“hello”添加上，然后把“hello”的值分别存储在s3、s4引用对象的value数组中。

    也就是为什么s3==s4为false的原因。

     总结来说：只要是new的对象，都是唯一的。

    通过上面例子可以看出：使用常量字符串创建String类型对象的效率更高，而且更节省空间。同时用户也可以将创建的字符串对象通过 intern 方式添加进常量池中。

     3.intern 方法

    intern 是一个native方法（native 方法指：底层使用C++实现的，看不到其实现的源代码），该方法的作用是手动将创建的String对象添加到常量池中。

    我们看下面两个例子会发现，就是因为少写一句 s1.intern() 结果就变的不一样，这是为什么呢？

     我们一步一步来分析，上述代码中 s1 先在堆区创建一个对象，因为 s1 引用对象存储的 “abc” 是字符数组 ch 拷贝过去的，所以 abc 并没有存入字符串内存池中。而当 执行 String s2 = "abc" 时，内存池变会检测内否存有 “abc”，没有内存池便会把 “abc” 收入其中，同时把在内存池中存储 “abc” 的对象赋值给 s2 。

     

     而当添加 s1.intern() 之后，内存池变会检测“abc”是否在其中存储，如果没有，这会把s1引用的String对象添加到内存池中，如下。当 执行 String s2 = "abc" 时，内存池中检测到“abc”，变会把“abc”的对象赋值给s2。

      同样，如果 s1.intern()  之后，内存池检测到 “abc”，那就不会把 s1 引用String对象添加到内存池中。

     注意：在Java6 和 Java7、8中intern的实现会有些许差别。

    我们来看三道面试题，巩固一下

    解释String类中两种对象实例化的区别：

     1. String str = "hello";

       只会开辟一块堆内存空间，保存在字符串常量池中，然后 str 共享常量池中的 String 对象。

    2. String str = new String("hello");

      会开辟两块堆内存空间，字符串"hello"保存在字符串常量池中，然后用常量池中的 String 对象给新开辟的 String 对象赋值。

    3. String str = new String(new char[]{'h','e','l','l','o'})

      现在堆上创建一个 String 对象，然后利用 copyof 将重新开辟数组空间，将参数字符串数组中内容拷贝到 String 对象中。

    9.字符串的不可变性

    String 是一种不可变对象，字符串中的内容时不可改变的。字符串不可被修改，是因为其中存储字符串的value数组被private修饰，如下图

     对于 value[] 不可修改，是因为有private修饰在类外不能拿取value的值，而不是因为被 final 修饰的原因。

    final 修饰类表面该类不想被继承，final修饰内置类型表明该变量不能修改其值。

     而对于引用类型来说，final 修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的。

     所以，String类不能修改不是其内部value被final修饰的原因。

    同时，我们还肯被一下代码所骗，认为String类可以被修改

    1. public static void main(String[] args) {
    2.         String s = "hello";
    3.         s += " world";
    4.         System.out.println(s);// 输出：hello world
    5.     }

    这是为什么呢？这串代码并不是代表String类可以修改，当s += " world" 执行后，s引用的就是一个全新的对象，而不是在原理hello这个内存上拼接的。

    而且所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象

    例如 repalce 方法：

     为什么 String 要设计成不可变的呢？

    1.  方便实现字符串对象池。如果String可变，那么对象池就需要考虑写时拷贝的问题了。
    2. 不可变对象是线程安全的。
    3. 不可变对象更方便缓存 hash code，作为 key 时可以更高效的保存到 HashMap 中。

    那如果想要修改字符串中内容呢？我们接着往下看

    10.字符串修改

    我们知道，真正修改字符串的内容是很难的，如果我们要修改的话就是要new一个新的对象。

    借用上述举的例子

    1. public static void main(String[] args) {
    2.         String s = "hello";
    3.         s += " world";
    4.         System.out.println(s);// 输出：hello world
    5.     }

    注意：我们应尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建对象，效率会非常低下。

    如果要修改的话，建议尽量使用StringBuffer或者StringBuilder，这样效率会高一点

     我们来比较一下 +=  、StringBuffer、 StringBuilder这三种方法修改对象的耗时

    1. public static void main(String[] args) {
    2.         long start = System.currentTimeMillis();
    3.         String s1 = "";
    4.         for(int i = 0; i < 10000; ++i){
    5.             s1 += i;
    6.         } long end = System.currentTimeMillis();
    7.         System.out.println(end - start);
    8.  
    9.         start = System.currentTimeMillis();
    10.         StringBuffer s2 = new StringBuffer("");
    11.         for(int i = 0; i < 10000; ++i){
    12.             s2.append(i);
    13.         } end = System.currentTimeMillis();
    14.         System.out.println(end - start);
    15.  
    16.         start = System.currentTimeMillis();
    17.         StringBuilder s3 = new StringBuilder();
    18.         for(int i = 0; i < 10000; ++i){
    19.             s3.append(i);
    20.         } end = System.currentTimeMillis();
    21.         System.out.println(end - start);
    22.     }

    可以看出StringBuffer、 StringBuilder方法比用 += 修改效率更高。

    因此能不修改就不修改，实在不行尽量使用StringBuffer或者StringBuilder。

    到此，String类基本上是讲完了，有错误的地方希望大家能批评指正，别忘了点赞👍+收藏⭐️哦 

          😜  关注我！带来等多精彩🎉🎉

  • 相关阅读:
    黑马mysql教程笔记（mysql8教程）基础篇——数据库相关概念、mysql安装及卸载、数据模型、SQL通用语法及分类（DDL、DML、DQL、DCL）
    基于R语言、MATLAB、Python机器学习方法与案例分析
    LinkedHashMap实现LRU缓存cache机制，Kotlin
    无代码开发平台全部应用设置入门教程
    粘性文本整页滚动效果
    audiotrack与audioflinger
    系统篇： ubuntu 下 sudo 命令执行慢的解决办法
    OwnCloud个人云盘搭建方法
    http和https区别，第三方证书如何保证服务器可信
    力扣贪心——跳跃游戏I和II
  • 原文地址：https://blog.csdn.net/weixin_53564801/article/details/125534696