【大数据】学习笔记 1 Java SE 第10章基础API与常见算法 10.5 字符串

╰+哭是因爲堅強的太久メ 2024-03-22 12:18 16阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第10章 基础API与常见算法
             *   *  10.5 字符串
                 *   *  10.5.1 字符串的特点
                     *  10.5.2 构造字符串对象
                     *  10.5.3 字符串的对象的个数
                     *  10.5.4 字符串对象的内存分析
                     *  10.5.5 字符串拼接问题
                     *  10.5.6 字符串对象的比较
                     *  10.5.7 空字符的比较
                     *  10.5.8 字符串的常用方法

![在这里插入图片描述][0748abd58d4b4c98a792696b86c73c61.png_pic_center]

#### 1 Java SE ####

##### 第10章 基础API与常见算法 #####

###### 10.5 字符串 ######

`java.lang.String` 类代表字符串。Java程序中所有的字符串文字（例如`"abc"` ）都可以被看作是实现此类的实例。字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。

`String` 类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写。

Java 语言提供对字符串串联符号（“+”）以及将其他对象转换为字符串的特殊支持（toString()方法）。

###### 10.5.1 字符串的特点 ######

1、字符串String类型本身是final声明的，意味着我们不能继承String。

2、字符串的对象也是不可变对象，意味着一旦进行修改，就会产生新对象

> 我们修改了字符串后，如果想要获得新的内容，必须重新接收。
> 
> 如果程序中涉及到大量的字符串的修改操作，那么此时的时空消耗比较高。可能需要考虑使用StringBuilder或StringBuffer的可变字符序列。

3、String对象内部是用字符数组进行保存的

> JDK1.9之前有一个char\[\] value数组，JDK1.9之后byte\[\]数组

`"abc"` 等效于 `char[] data={ 'a' , 'b' , 'c' }`。

例如： 
    String str = "abc";
    
    相当于： 
    char data[] = {
        'a', 'b', 'c'};     
    String str = new String(data);
    // String底层是靠字符数组实现的。

4、String类中这个char\[\] values数组也是final修饰的，意味着这个数组不可变，然后它是private修饰，外部不能直接操作它，String类型提供的所有的方法都是用新对象来表示修改后内容的，所以保证了String对象的不可变。

5、就因为字符串对象设计为不可变，那么所以字符串有常量池来保存很多常量对象

常量池在方法区。

如果细致的划分：

（1）JDK1.6及其之前：方法区

（2）JDK1.7：堆

（3）JDK1.8：元空间

String s1 = "abc";
    String s2 = "abc";
    System.out.println(s1 == s2);
    // 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

###### 10.5.2 构造字符串对象 ######

【1】使用构造方法

*  `public String()` ：初始化新创建的 String对象，以使其表示空字符序列。
 *  `String(String original)`： 初始化一个新创建的 `String` 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
 *  `public String(char[] value)` ：通过当前参数中的字符数组来构造新的String。
 *  `public String(char[] value,int offset, int count)` ：通过字符数组的一部分来构造新的String。
 *  `public String(byte[] bytes)` ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。
 *  `public String(byte[] bytes,String charsetName)` ：通过使用指定的字符集解码当前参数中的字节数组来构造新的String。

构造举例，代码如下：

//字符串常量对象
    String str = "hello";
    
    // 无参构造
    String str1 = new String（）；
    
    //创建"hello"字符串常量的副本
    String str2 = new String("hello");
    
    //通过字符数组构造
    char chars[] = {
        'a', 'b', 'c','d','e'};     
    String str3 = new String(chars);
    String str4 = new String(chars,0,3);
    
    // 通过字节数组构造
    byte bytes[] = {
        97, 98, 99 };     
    String str5 = new String(bytes);
    String str6 = new String(bytes,"GBK");

【2】使用静态方法

*  static String copyValueOf(char\[\] data)： 返回指定数组中表示该字符序列的 String
 *  static String copyValueOf(char\[\] data, int offset, int count)：返回指定数组中表示该字符序列的 String
 *  static String valueOf(char\[\] data) ： 返回指定数组中表示该字符序列的 String
 *  static String valueOf(char\[\] data, int offset, int count) ： 返回指定数组中表示该字符序列的 String
 *  static String valueOf(xx value)：xx支持各种数据类型，返回各种数据类型的value参数的字符串表示形式。

public static void main(String[] args) {
        
    		char[] data = {
        'h','e','l','l','o','j','a','v','a'};
    		String s1 = String.copyValueOf(data);
    		String s2 = String.copyValueOf(data,0,5);
    		int num = 123456;
    		String s3 = String.valueOf(num);
    		System.out.println(s1);
    		System.out.println(s2);
    		System.out.println(s3);
    	}

【3】使用""+

任意数据类型与"字符串"进行拼接，结果都是字符串

public static void main(String[] args) {
        
    		int num = 123456;
    		String s = num + "";
    		System.out.println(s);
    		
    		Student stu = new Student();
    		String s2 = stu + "";//自动调用对象的toString()，然后与""进行拼接
    		System.out.println(s2);
    	}

###### 10.5.3 字符串的对象的个数 ######

1、字符串常量对象

String str1 = "hello";//1个，在常量池中

2、字符串的普通对象和常量对象一起

String str3 = new String("hello");
    //str3首先指向堆中的一个字符串对象，然后堆中字符串的value数组指向常量池中常量对象的value数组

3、面试题

String str1 = "hello";
    String str2 = new String("hello");
    
    //上面的代码一共有几个字符串对象。
    //2个

###### 10.5.4 字符串对象的内存分析 ######

String s;
    
    String s = null;
    
    String s = "";
    String s = new String();
    String s = new String("");
    
    String s = "abc";
    String s = new String("abc");
    
    char[] arr = {
        'a','b'};
    String s = new String(arr);
    
    
    char[] arr = {
        'a','b','c','d','e'};
    String s = new String(arr,0,3);

![在这里插入图片描述][12e68345271946ad875336f6e78cf95b.png_pic_center]

###### 10.5.5 字符串拼接问题 ######

【1】拼接结果的存储和比较问题

原则：

（1）常量+常量：结果是常量池

（2）常量与变量 或 变量与变量：结果是堆

（3）拼接后调用intern方法：结果在常量池

@Test
    	public void test06(){
        
    		String s1 = "hello";
    		String s2 = "world";
    		String s3 = "helloworld";
    		
    		String s4 = (s1 + "world").intern();//把拼接的结果放到常量池中
    		String s5 = (s1 + s2).intern();
    		
    		System.out.println(s3 == s4);//true
    		System.out.println(s3 == s5);//true
    	}
    	
    	@Test
    	public void test05(){
        
    		final String s1 = "hello";
    		final String s2 = "world";
    		String s3 = "helloworld";
    		
    		String s4 = s1 + "world";//s4字符串内容也helloworld，s1是常量，"world"常量，常量+ 常量 结果在常量池中
    		String s5 = s1 + s2;//s5字符串内容也helloworld，s1和s2都是常量，常量+ 常量 结果在常量池中
    		String s6 = "hello" + "world";//常量+ 常量 结果在常量池中，因为编译期间就可以确定结果
    		
    		System.out.println(s3 == s4);//true
    		System.out.println(s3 == s5);//true
    		System.out.println(s3 == s6);//true
    	}
    	
    	@Test
    	public void test04(){
        
    		String s1 = "hello";
    		String s2 = "world";
    		String s3 = "helloworld";
    		
    		String s4 = s1 + "world";//s4字符串内容也helloworld，s1是变量，"world"常量，变量 + 常量的结果在堆中
    		String s5 = s1 + s2;//s5字符串内容也helloworld，s1和s2都是变量，变量 + 变量的结果在堆中
    		String s6 = "hello" + "world";//常量+ 常量 结果在常量池中，因为编译期间就可以确定结果
    		
    		System.out.println(s3 == s4);//false
    		System.out.println(s3 == s5);//false
    		System.out.println(s3 == s6);//true
    	}

![在这里插入图片描述][5e80c4816cd044239c43e7a11d34b9ad.png_pic_center]

【2】拼接效率问题

package com.dingjiaxiong.string;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestString
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:13
     */
    
    public class TestString {
        
        public static void main(String[] args) {
        
            String str = "0";
            for (int i = 0; i <= 5; i++) {
        
                str += i;
            }
            System.out.println(str);
        }
    }

![在这里插入图片描述][a4c9486884434117bd3de1b67baac63a.png_pic_center]

![在这里插入图片描述][732b028ec1474443a6e58b5dd1474f77.png_pic_center]

不过现在的JDK版本，都会使用可变字符序列对如上代码进行优化，我们反编译查看字节码：

javap -c TestString.class

![在这里插入图片描述][5f8c3121e84c40cca6f5a70043c4bb96.png_pic_center]

【3】两种拼接

package com.dingjiaxiong.string;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestString
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:13
     */
    
    public class TestString {
        
        public static void main(String[] args) {
        
            String str = "hello";
            String str2 = "world";
            String str3 = "helloworld";
    
            String str4 = "hello".concat("world");
            String str5 = "hello" + "world";
    
            System.out.println(str3 == str4);//false
            System.out.println(str3 == str5);//true
        }
    }

![在这里插入图片描述][9beb412ececc49a9902b8aac04f31b16.png_pic_center]

> concat方法拼接，哪怕是两个常量对象拼接，结果也是在堆。

###### 10.5.6 字符串对象的比较 ######

1、==：比较是对象的地址

> 只有两个字符串变量都是指向字符串的常量对象时，才会返回true

String str1 = "hello";
    String str2 = "hello";
    System.out.println(str1 == str2);//true
        
    String str3 = new String("hello");
    String str4 = new String("hello");
    System.out.println(str1 == str4); //false
    System.out.println(str3 == str4); //false

2、equals：比较是对象的内容，因为String类型重写equals，区分大小写

只要两个字符串的字符内容相同，就会返回true

String str1 = "hello";
    String str2 = "hello";
    System.out.println(str1.equals(str2));//true
        
    String str3 = new String("hello");
    String str4 = new String("hello");
    System.out.println(str1.equals(str3));//true
    System.out.println(str3.equals(str4));//true

3、equalsIgnoreCase：比较的是对象的内容，不区分大小写

String str1 = new String("hello");
    String str2 = new String("HELLO");
    System.out.println(str1.equalsIgnoreCase(strs)); //true

4、compareTo：String类型重写了Comparable接口的抽象方法，自然排序，按照字符的Unicode编码值进行比较大小的，严格区分大小写

String str1 = "hello";
    String str2 = "world";
    str1.compareTo(str2) //小于0的值

5、compareToIgnoreCase：不区分大小写，其他按照字符的Unicode编码值进行比较大小

String str1 = new String("hello");
    String str2 = new String("HELLO");
    str1.compareToIgnoreCase(str2)  //等于0

###### 10.5.7 空字符的比较 ######

1、哪些是空字符串

String str1 = "";
    String str2 = new String();
    String str3 = new String("");

空字符串：长度为0

2、如何判断某个字符串是否是空字符串

if("".equals(str))
    
    if(str!=null  && str.isEmpty())
    
    if(str!=null && str.equals(""))
    
    if(str!=null && str.length()==0)

###### 10.5.8 字符串的常用方法 ######

【1】系列1：常用方法

（1）boolean isEmpty()：字符串是否为空

（2）int length()：返回字符串的长度

（3）String concat(xx)：拼接，等价于+

（4）boolean equals(Object obj)：比较字符串是否相等，区分大小写

（5）boolean equalsIgnoreCase(Object obj)：比较字符串是否相等，不区分大小写

（6）int compareTo(String other)：比较字符串大小，区分大小写，按照Unicode编码值比较大小

（7）int compareToIgnoreCase(String other)：比较字符串大小，不区分大小写

（8）String toLowerCase()：将字符串中大写字母转为小写

（9）String toUpperCase()：将字符串中小写字母转为大写

（10）String trim()：去掉字符串前后空白符

（11）public String intern()：结果在常量池中共享

package com.dingjiaxiong.string;
    
    import org.junit.Test;
    
    import java.util.Random;
    import java.util.Scanner;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: StringMethod1
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:19
     */
    
    public class StringMethod1 {
        
    
        @Test
        public void test01() {
        
            //将用户输入的单词全部转为小写，如果用户没有输入单词，重新输入
            Scanner input = new Scanner(System.in);
            String word;
            while (true) {
        
                System.out.print("请输入单词：");
                word = input.nextLine();
                if (word.trim().length() != 0) {
        
                    word = word.toLowerCase();
                    break;
                }
            }
            System.out.println(word);
        }
    
        @Test
        public void test02() {
        
            //随机生成验证码，验证码由0-9，A-Z,a-z的字符组成
            char[] array = new char[26 * 2 + 10];
            for (int i = 0; i < 10; i++) {
        
                array[i] = (char) ('0' + i);
            }
            for (int i = 10, j = 0; i < 10 + 26; i++, j++) {
        
                array[i] = (char) ('A' + j);
            }
            for (int i = 10 + 26, j = 0; i < array.length; i++, j++) {
        
                array[i] = (char) ('a' + j);
            }
            String code = "";
            Random rand = new Random();
            for (int i = 0; i < 4; i++) {
        
                code += array[rand.nextInt(array.length)];
            }
            System.out.println("验证码：" + code);
            //将用户输入的单词全部转为小写，如果用户没有输入单词，重新输入
            Scanner input = new Scanner(System.in);
            System.out.print("请输入验证码：");
            String inputCode = input.nextLine();
    
            if (!code.equalsIgnoreCase(inputCode)) {
        
                System.out.println("验证码输入不正确");
            }
        }
    
    }

![在这里插入图片描述][6b7382c2f2be4bd3b3a319f5ac172f53.png_pic_center]

【2】系列2：查找

（11）boolean contains(xx)：是否包含xx

（12）int indexOf(xx)：从前往后找当前字符串中xx，即如果有返回第一次出现的下标，要是没有返回-1

（13）int lastIndexOf(xx)：从后往前找当前字符串中xx，即如果有返回最后一次出现的下标，要是没有返回-1

package com.dingjiaxiong.string;
    
    import org.junit.Test;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: StringMethod2
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:20
     */
    
    public class StringMethod2 {
        
    
        @Test
        public void test01() {
        
            String str = "尚硅谷是一家靠谱的培训机构，尚硅谷可以说是IT培训的小清华，JavaEE是尚硅谷的当家学科，尚硅谷的大数据培训是行业独角兽。尚硅谷的前端和运维专业一样独领风骚。";
            System.out.println("是否包含清华：" + str.contains("清华"));
            System.out.println("培训出现的第一次下标：" + str.indexOf("培训"));
            System.out.println("培训出现的最后一次下标：" + str.lastIndexOf("培训"));
        }
    
    }

![在这里插入图片描述][b65fbe7aab0c430fa67e5b1a4188e2ab.png_pic_center]

【3】系列3：字符串截取

（14）String substring(int beginIndex) ：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。

（15）String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

package com.dingjiaxiong.string;
    
    import org.junit.Test;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: StringMethod3
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:21
     */
    
    public class StringMethod3 {
        
    
        @Test
        public void test01() {
        
            String str = "helloworldjavaatguigu";
            String sub1 = str.substring(5);
            String sub2 = str.substring(5, 10);
            System.out.println(sub1);
            System.out.println(sub2);
        }
    
        @Test
        public void test02() {
        
            String fileName = "快速学习Java的秘诀.dat";
            //截取文件名
            System.out.println("文件名：" + fileName.substring(0, fileName.lastIndexOf(".")));
            //截取后缀名
            System.out.println("后缀名：" + fileName.substring(fileName.lastIndexOf(".")));
        }
    
    }

![在这里插入图片描述][f8ff74b72fef4d6a97f8e13cc513c3e8.png_pic_center]

【4】系列4：和字符相关

（16）char charAt(index)：返回\[index\]位置的字符

（17）char\[\] toCharArray()： 将此字符串转换为一个新的字符数组返回

（18）String(char\[\] value)：返回指定数组中表示该字符序列的 String。

（19）String(char\[\] value, int offset, int count)：返回指定数组中表示该字符序列的 String。

（20）static String copyValueOf(char\[\] data)： 返回指定数组中表示该字符序列的 String

（21）static String copyValueOf(char\[\] data, int offset, int count)：返回指定数组中表示该字符序列的 String

（22）static String valueOf(char\[\] data, int offset, int count) ： 返回指定数组中表示该字符序列的 String

（23）static String valueOf(char\[\] data) ：返回指定数组中表示该字符序列的 String

package com.dingjiaxiong.string;
    
    import org.junit.Test;
    
    import java.util.Arrays;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: StringMethod4
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:21
     */
    
    public class StringMethod4 {
        
    
        @Test
        public void test01() {
        
            //将字符串中的字符按照大小顺序排列
            String str = "helloworldjavaatguigu";
            char[] array = str.toCharArray();
            Arrays.sort(array);
            str = new String(array);
            System.out.println(str);
        }
    
        @Test
        public void test02() {
        
            //将首字母转为大写
            String str = "jack";
            str = Character.toUpperCase(str.charAt(0)) + str.substring(1);
            System.out.println(str);
        }
    
    }

![在这里插入图片描述][fa31867a49f645f9a71c5adaab27ed9f.png_pic_center]

【5】系列5：编码与解码

（24）byte\[\] getBytes()：编码，把字符串变为字节数组，按照平台默认的字符编码方式进行编码

byte\[\] getBytes(字符编码方式)：按照指定的编码方式进行编码

（25）new String(byte\[\] ) 或 new String(byte\[\], int, int)：解码，按照平台默认的字符编码进行解码

new String(byte\[\]，字符编码方式 ) 或 new String(byte\[\], int, int，字符编码方式)：解码，按照指定的编码方式进行解码

package com.dingjiaxiong.string;
    
    import org.junit.Test;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: StringMethod5
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:18
     */
    
    public class StringMethod5 {
        
        @Test
        public void test01() throws Exception {
        
            byte[] data = {
        (byte) 0B11100101, (byte) 0B10110000, (byte) 0B10011010, (byte) 0B11000111, (byte) 0B10101011, (byte) 0B01110110};
            System.out.println(new String(data, "ISO8859-1"));
            System.out.println(new String(data, "GBK"));
            System.out.println(new String(data, "UTF-8"));
        }
    
        @Test
        public void test02() throws Exception {
        
            String str = "中国";
            System.out.println(str.getBytes("ISO8859-1").length);// 2
            // ISO8859-1把所有的字符都当做一个byte处理，处理不了多个字节
            System.out.println(str.getBytes("GBK").length);// 4 每一个中文都是对应2个字节
            System.out.println(str.getBytes("UTF-8").length);// 6 常规的中文都是3个字节
    
            /*
             * 不乱码：（1）保证编码与解码的字符集名称一样（2）不缺字节
             */
            System.out.println(new String(str.getBytes("ISO8859-1"), "ISO8859-1"));// 乱码
            System.out.println(new String(str.getBytes("GBK"), "GBK"));// 中国
            System.out.println(new String(str.getBytes("UTF-8"), "UTF-8"));// 中国
        }
    }

![在这里插入图片描述][8ac8c6def81c4dc995424f5d35275fa7.png_pic_center]

【6】系列6：开头与结尾

（26）boolean startsWith(xx)：是否以xx开头

（27）boolean endsWith(xx)：是否以xx结尾

package com.dingjiaxiong.string;
    
    import org.junit.Test;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: StringMethod6
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:23
     */
    
    public class StringMethod6 {
        
    
        @Test
        public void test2() {
        
            String name = "张三";
            System.out.println(name.startsWith("张"));
        }
    
        @Test
        public void test() {
        
            String file = "Hello.txt";
            if (file.endsWith(".java")) {
        
                System.out.println("Java源文件");
            } else if (file.endsWith(".class")) {
        
                System.out.println("Java字节码文件");
            } else {
        
                System.out.println("其他文件");
            }
        }
    
    }

![在这里插入图片描述][64a30aba994446adb4bf4c35895b375a.png_pic_center]

【7】系列7：正则匹配

（28）boolean matchs(正则表达式)：判断当前字符串是否匹配某个正则表达式。

package com.dingjiaxiong.string;
    
    import org.junit.Test;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: StringMethod7
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:24
     */
    
    public class StringMethod7 {
        
    
        @Test
        public void test1() {
        
            //简单判断是否全部是数字，这个数字可以是1~n位
            String str = "12a345";
    
            //正则不是Java的语法，它是独立与Java的规则
            //在正则中\是表示转义，
            //同时在Java中\也是转义
            boolean flag = str.matches("\\d+");
            System.out.println(flag);
        }
    
        @Test
        public void test2() {
        
            String str = "123456789";
    
            //判断它是否全部由数字组成，并且第1位不能是0，长度为9位
            //第一位不能是0，那么数字[1-9]
            //接下来8位的数字，那么[0-9]{8}+
            boolean flag = str.matches("[1-9][0-9]{8}+");
            System.out.println(flag);
        }
    
        @Test
        public void test03() {
        
            //密码要求：必须有大写字母，小写字母，数字组成，6位
            System.out.println("Cly892".matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//true
            System.out.println("1A2c45".matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//true
            System.out.println("Clyyyy".matches("^(?=.*[A-Z])(?=.*[0-9])[A-Za-z0-9]{6}$"));//false
        }
    
    }

![在这里插入图片描述][102b082ceb394c98bd9d0f062383f263.png_pic_center]

【8】系列8：替换

（29）String replace(xx,xx)：不支持正则

（30）String replaceFirst(正则，value)：替换第一个匹配部分

（31）String repalceAll(正则， value)：替换所有匹配部分

package com.dingjiaxiong.string;
    
    import org.junit.Test;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: StringMethod8
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:25
     */
    
    public class StringMethod8 {
        
    
        @Test
        public void test4() {
        
            String str = "hello244world.java;887";
            //把其中的非字母去掉
            str = str.replaceAll("[^a-zA-Z]", "");
            System.out.println(str);
        }
    
    }

![在这里插入图片描述][9bd932f5075e4021a28b5a0925fd874b.png_pic_center]

【9】系列9：拆分

（32）String\[\] split(正则)：按照某种规则进行拆分

package com.dingjiaxiong.string;
    
    import org.junit.Test;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: StringMethod9
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 17:26
     */
    
    public class StringMethod9 {
        
    
        @Test
        public void test4() {
        
            String str = "张三.23|李四.24|王五.25";
            //|在正则中是有特殊意义，我这里要把它当做普通的|
            String[] all = str.split("\\|");
    
            //转成一个一个学生对象
            Student[] students = new Student[all.length];
            for (int i = 0; i < students.length; i++) {
        
                //.在正则中是特殊意义，我这里想要表示普通的.
                String[] strings = all[i].split("\\.");//张三,  23
                String name = strings[0];
                int age = Integer.parseInt(strings[1]);
                students[i] = new Student(name, age);
            }
    
            for (int i = 0; i < students.length; i++) {
        
                System.out.println(students[i]);
            }
    
        }
    
        @Test
        public void test3() {
        
            String str = "1Hello2World3java4atguigu5";
            str = str.replaceAll("^\\d|\\d$", "");
            String[] all = str.split("\\d");
            for (int i = 0; i < all.length; i++) {
        
                System.out.println(all[i]);
            }
        }
    
        @Test
        public void test2() {
        
            String str = "1Hello2World3java4atguigu";
            str = str.replaceFirst("\\d", "");
            System.out.println(str);
            String[] all = str.split("\\d");
            for (int i = 0; i < all.length; i++) {
        
                System.out.println(all[i]);
            }
        }
    
    
        @Test
        public void test1() {
        
            String str = "Hello World java atguigu";
            String[] all = str.split(" ");
            for (int i = 0; i < all.length; i++) {
        
                System.out.println(all[i]);
            }
        }
    
    }

package com.dingjiaxiong.string;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Student
     * @Author: Ding Jiaxiong
     * @Date:2023/4/27 16:59
     */
    
    public class Student implements Comparable {
        
        private String name;
        private int score;
    
        public Student(String name, int score) {
        
            this.name = name;
            this.score = score;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getScore() {
        
            return score;
        }
    
        public void setScore(int score) {
        
            this.score = score;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "name='" + name + '\'' +
                    ", score=" + score +
                    '}';
        }
    
        @Override
        public int compareTo(Object o) {
        
            return this.score - ((Student) o).score;
        }
    }

![在这里插入图片描述][8fd6788316e443ab87b10c766f2f77c6.png_pic_center]

[0748abd58d4b4c98a792696b86c73c61.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/b465f93a1c42432ea0058a821b1de7f0.png
[12e68345271946ad875336f6e78cf95b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/b5c0cf8d735e472b9750284db62bd290.png
[5e80c4816cd044239c43e7a11d34b9ad.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/2e7e0504f43d464aa27999a41225698d.png
[a4c9486884434117bd3de1b67baac63a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/1a525fb3b0dc426599dd64645a5c527c.png
[732b028ec1474443a6e58b5dd1474f77.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/7895f45901e9471c844c3bfac25b86e8.png
[5f8c3121e84c40cca6f5a70043c4bb96.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/53cdb4c132804635afb1d816f57f0fb9.png
[9beb412ececc49a9902b8aac04f31b16.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/9ba9c09190cb4ca6bbfcee0d40cf0331.png
[6b7382c2f2be4bd3b3a319f5ac172f53.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/6c51eadeef25482bbccc7f8d3616455a.png
[b65fbe7aab0c430fa67e5b1a4188e2ab.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/c42b3616911e4a61b83e9426432878f2.png
[f8ff74b72fef4d6a97f8e13cc513c3e8.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ceb5304e295f47e1874ecb8b765971e1.png
[fa31867a49f645f9a71c5adaab27ed9f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/7133ddacf2fc4441927b1b4e9b803831.png
[8ac8c6def81c4dc995424f5d35275fa7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/bd5bdb42aea341ec915238a5a539866f.png
[64a30aba994446adb4bf4c35895b375a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/f829785d55354a5e8ddff1ec855c5a33.png
[102b082ceb394c98bd9d0f062383f263.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/962b139cf74c4975879a97ef22766617.png
[9bd932f5075e4021a28b5a0925fd874b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/52310c8dfe5f4672bbb5db0f8c129327.png
[8fd6788316e443ab87b10c766f2f77c6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/d21026b4f6d84a95b8d29b0d1a85db5e.png