day10-字符串

字符串

1、API 和 API 帮助文档

通过网盘分享的文件：资料
链接: https://pan.baidu.com/s/1jlQvGN1PHiud6NXhSYpIaA?pwd=reyn 提取码: reyn

什么是API？
API (Application Programming Interface) ：应用程序编程接口。
简单理解： API就是别人已经写好的东西，我们不需要自己编写，直接使用即可。

Java API：指的就是JDK中提供的各种功能的Java类。
这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

API帮助文档： 帮助开发人员更好的使用API和查询API的一个工具。

如何使用API帮助文档

①打开API帮助文档
②点击显示，找到索引选项卡中的输入框
③在输入框中输入类名并点击显示
④查看类所在的包
⑤查看类的描述
⑥查看构造方法
⑦查看成员方法

🍊API文档练习：
需求:按照帮助文档的使用步骤学习 Scanner 类的使用，并实现接收键盘录入一个小数，最后输出在控制台.

public class ScannerDemo1 {
    public static void main(String[] args) {
        //1.创建对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个小数");
        //2.接收一个小数
        double result = sc.nextDouble();
        //3.输出打印
        System.out.println(result);
    }
}

2、String概述

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。
String 类在 java.lang 包下，所以使用的时候不需要导包！

String类的特点：

字符串不可变，它们的值在创建后不能被更改
虽然 String 的值是不可变的，但是它们可以被共享
字符串效果上相当于字符数组( char[] )，但是底层原理是字节数组( byte[] )

String name = "阿伟";
String schoolName = "黑马程序员";
System.out.println(name + schoolName);
// 三个字符串

String name = "阿伟";
name = "三连.阿伟";
// 两个字符串
// 不是改变了字符串的内容，而是创建了一个新的字符串，
// 把新的字符串复制给了前面的变量 name，此时并没有改变第一个字符串里面的内容

3、String构造方法代码实现和内存分析

3.1 创建String对象的两种方式

1、直接赋值

2、通过构造方法

构造方法	说明
public String()	创建一个空白字符串对象，不含有任何内容
public String(String original)	根据传入的字符串，创建字符串对象
public String(char[] chs)	根据字符数组的内容，来创建字符串对象
public String(byte[] bys)	根据字节数组的内容，来创建字符串对象

🌰代码示例：

public class StringDemo1 {
    public static void main(String[] args) {
        //1.使用直接赋值的方式获取一个字符串对象
        String s1 = "abc";
        System.out.println(s1);//abc


        //2.使用new的方式来获取一个字符串对象
        
        //public String()：创建一个空白字符串对象，不含有任何内容
        //空参构造：可以获取一个空白的字符串对象
        String s2 = new String();
        System.out.println("@" + s2 + "!");//"@!"

        //传递一个字符串，根据传递的字符串内容再创建一个新的字符串对象
        //这种方式只要知道有它存在就好了
        String s3 = new String("abc");
        System.out.println(s3);

        //public String(char[] chs)：根据字符数组的内容，来创建字符串对象
        //传递一个字符数组，根据字符数组的内容再创建一个新的字符串对象
        //需求：我要修改字符串的内容。  abc --> Qbc
        //abc -->  {'a','b','c'}  -->  {'Q','b','c'} --> "Qbc"
        char[] chs = {'a', 'b', 'c', 'd'};
        String s4 = new String(chs);
        System.out.println(s4);//abcd

        //public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
        //传递一个字节数组，根据字节数组的内容再创建一个新的字符串对象
        //应用场景：以后在网络当中传输的数据其实都是字节信息
        //我们一般要把字节信息进行转换，转成字符串，此时就要用到这个构造了。
        byte[] bytes = {97, 98, 99, 100};
        String s5 = new String(bytes);
        System.out.println(s5);//abcd

    }
}

通过构造方法创建字符串中，前面两种方法少用，后面两种方法以后用得上。

3.2 Java的内存模型

在这里插入图片描述

串池，可以理解成字符串常量池，但是只有直接赋值的字符串才存在这个串池中。

🍎直接赋值
在这里插入图片描述

给 s1 赋值时系统会先去串池中观察，有没有abc，没有的话就会创建一个新的abc，然后把她得地址值赋值给 s1。
给 s2 赋值时，串池已经有一个abc了，它就不会创建abc，而是会复用已经存在的abc。

⭐️小结：
当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在：
不存在:创建新的
存在:复用

🍎手动new出来的
在这里插入图片描述

以字符数组为例，给 s1 赋值时遇到 new 关键字，在堆里面创建了一个小空间，这个小空间里面的内容就是字符数组的内容abc，然后再把这个小空间的地址值，赋给 s1，s1 通过地址值就能找到创建出来的字符串了。
给 s2 赋值时遇到 new 关键字，其实就是把上述过程重复了一遍，假设开辟出来的第三个小空间的地址值是 0x0033，此时就会把 0x0033 赋给 s2 ，s2 通过它就能找到第二个字符串对象。

⭐️每new一次就会开辟一个小空间，不会复用。

4、字符串的比较

4.1 ==号的作用

比较基本数据类型：比较的是具体的值
比较引用数据类型：比较的是对象地址值

int a = 10;
int b = 20;
System.out.println(a == b); // false

String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2); // false

4.2 equals方法的作用

方法介绍
- public boolean equals(String s) ：
  比较两个字符串内容是否相同、区分大小
- public boolean equalslgnoreCase(String s) ：
  比较两个字符串内容是否相同、不区分大小写

🌰代码示例：

public class StringDemo2 {
    public static void main(String[] args) {
        //1.创建两个字符串对象
        String s1 = new String("abc");
        String s2 = "Abc";

        //2.==号比较
        //基本数据类型：比的是数据值
        //引用数据类型：比的是地址值
        System.out.println(s1 == s2);//false


        //3.比较字符串对象中的内容是否相等
        boolean result1 = s1.equals(s2);
        System.out.println(result1); // false

        //4.比较字符串对象中的内容是否相等，忽略大小写
        //1 一 壹 这不行
        //忽略大小写只能是英文状态下的a A
        boolean result2 = s1.equalsIgnoreCase(s2);
        System.out.println(result2);//true
    }
}

练习

5、用户登录

需求：
已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示。

📖代码示例：

public class Test1登录案例 {
    public static void main(String[] args) {
        //1.定义两个变量用来记录正确的用户名和密码
        String rightUsername = "itheima";
        String rightPassword = "1234qwer";

        //2.键盘录入用户名和密码
        //ctrl + alt + T 选择包裹方式

        for (int i = 0; i < 3; i++) {//0 1 2
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入用户名");
            String username = sc.next();
            System.out.println("请输入密码");
            String password = sc.next();

            //3.判断比较
            if (username.equals(rightUsername) && password.equals(rightPassword)) {
                System.out.println("登录成功");
                //如果正确，循环结束
                break;
            } else {
                //最后一次机会
                if(i == 2){
                    System.out.println("账户" + username + "被锁定，请联系黑马程序员官方小姐姐：XXXXXXX");
                }else{
                    //不是最后一次机会
                    System.out.println("用户名或密码错误，登录失败,还剩下" + (2 - i) + "次机会");//2 1 0
                }
            }
        }
    }
}

6、遍历字符串和统计字符个数

需求：
键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)。

📖代码示例：

public class Test4统计个数 {
    public static void main(String[] args) {
        //键盘录入一个字符串，统计大写，小写，数字出现的次数


        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();


        //2.统计 --- 计数器count
        //此时我要统计的有3样东西，所以要定义3个计数器分别进行统计
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        //得到这个字符串里面每一个字符
        for (int i = 0; i < str.length(); i++) {
            //i 表示字符串中的索引
            //c 表示字符串中的每一个字符
            char c = str.charAt(i);

            //对c进行判断
            if (c >= 'a' && c <= 'z') {
                smallCount++;
            }else if(c >= 'A' && c <= 'Z'){
                bigCount++;
            }else if(c >= '0' && c <= '9'){
                numberCount++;
            }
        }

        //3.当循环结束之后，三个变量记录的就是对应的个数
        System.out.println("大写字符有:" + bigCount + "个");
        System.out.println("小写字符有:" + smallCount + "个");
        System.out.println("数字字符有:" + numberCount + "个");
    }
}

7、字符串拼接和翻转

需求：
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。例如，数组为 int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]。

📖代码示例：

public class Test5数组拼接成字符串 {
    public static void main(String[] args) {
        //定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
        //并在控制台输出结果。例如，数组为 int[] arr = {1,2,3};
        //执行方法后的输出结果为：[1, 2, 3]

        int[] arr = {1, 2, 3, 4, 5};

        String str = arrToString(arr);
        System.out.println(str);
    }

    //作用：把一个数组变成字符串
    public static String arrToString(int[] arr) {
        String s = "";
        //拼接左括号
        s = s + "["; //此时是拿着长度为0的字符串，跟[进行拼接，产生一个新的字符串。
        // *这里不用"s+"，直接s ="["也可以，
        //把新的字符串再赋值给s，此时变量s记录的就是新的字符串"["的地址值

        //下面我想得到数组里面的每一个元素并进行拼接
        //那么就需要遍历数组，得到每一个元素才行
        for (int i = 0; i < arr.length; i++) {
           if(i == arr.length - 1){
               //如果是最后一个元素，那么不需要拼接逗号空格
               s = s + arr[i];
           }else{
               //如果不是最后一个元素，需要拼接元素和逗号空格
               s = s + arr[i] + ", ";
           }
        }

        //等循环结束之后，再拼接最后一个右括号
        s = s + "]";

        return s;
    }


    //用来遍历数组
    public static void printArr(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
        System.out.println("]");

        //[1, 2, 3, 4, 5]
        //我们现在要知道，这个最终结果是怎么来的？
        //从到右依次打印得来的。
    }
}

8、较难练习-金额转换

需求：
把2135变成：零佰零拾零万贰仟壹佰叁拾伍元
把789变成：零佰零拾零万零仟柒佰捌拾玖元

📖代码示例：

package com.itheima.stringdemo;

import java.util.Scanner;

public class StringDemo9 {
    public static void main(String[] args) {
        //1.键盘录入一个金额
        Scanner sc = new Scanner(System.in);
        int money;
        while (true) {
            System.out.println("请录入一个金额");
            money = sc.nextInt();
            if (money >= 0 && money <= 9999999) {
                break;
            } else {
                System.out.println("金额无效");
            }
        }

        //定义一个变量用来表示钱的大写
        String moneyStr = "";

        //2.得到money里面的每一位数字,再转成中文
        while (true) {//2135
            //从右往左获取数据，因为右侧是数据的个位
            int ge = money % 10;
            String capitalNumber = getCapitalNumber(ge);
            //把转换之后的大写拼接到moneyStr当中
            moneyStr = capitalNumber + moneyStr;
            //第一次循环 ： "伍" + "" = "伍"
            //第二次循环 ： "叁" + "伍" = "叁伍"
            //去掉刚刚获取的数据
            money = money / 10;

            //如果数字上的每一位全部获取到了，那么money记录的就是0，此时循环结束
            if (money == 0) {
                break;
            }
        }

        //3.在前面补0，补齐7位
        int count = 7 - moneyStr.length();
        for (int i = 0; i < count; i++) {
            moneyStr = "零" + moneyStr;
        }
        System.out.println(moneyStr);//零零零贰壹叁伍

        //4.插入单位
        //定义一个数组表示单位
        String[] arr = {"佰","拾","万","仟","佰","拾","元"};
        //               零    零   零   贰   壹   叁   伍

        //遍历moneyStr，依次得到 零    零   零   贰   壹   叁   伍
        //然后把arr的单位插入进去

        String result = "";
        for (int i = 0; i < moneyStr.length(); i++) {
            char c = moneyStr.charAt(i);
            //把大写数字和单位拼接到result当中
            result = result + c + arr[i]; // 零，零佰，零佰零，零佰零拾...
        }

        //5.打印最终结果
        System.out.println(result);

    }

    //定义一个方法把数字变成大写的中文
    //1 -- 壹
    public static String getCapitalNumber(int number) {
        //定义数组，让数字跟大写的中文产生一个对应关系
        String[] arr = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        //返回结果
        return arr[number];
    }
}

9、手机号屏蔽

需求：
以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽。
最终效果为：131****9468

📖代码示例：

public class Test8手机号屏蔽 {
    public static void main(String[] args) {
        /*以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
        最终效果为：131****9468*/

        //1.键盘录入一个手机号码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号码");
        String phoneNumber = sc.next();//13112349408

        //2.截取手机号码中的前三位
        String star = phoneNumber.substring(0, 3);

        //3.截取手机号码中的最后四位
        //此时我用substring方法，是用1个参数的，还是两个参数的？1个参数的会更好
        //因为现在我要截取到最后，所以建议使用1个参数的。
        String end = phoneNumber.substring(7); // *从第 7 位到最后

        //4.拼接
        String result = star + "****" + end;

        System.out.println(result);
    }
}

10、StringBuilder

StringBuilder 可以看成是一个容器，创建之后里面的内容是可变的。

作用：提高字符串的操作效率。

String s1 = "aaa";
String s2 = "bbb";
String s3 = "ccc";
String s4 = "ddd";
String s5 = "eee";

String s6 = s1 + s2 + s3 + s4 + s5;
// 在拼接过程中会产生很多没有用的字符串

// 用StringBuilder，在拼接过程中不会产生那么多没有用的字符串，所以用StringBuilder效率会更高。

⭐️StringBuilder构造方法

方法名	说明
public StringBuilder()	创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象

⭐️StringBuilder常用方法

方法名	说明
public StringBuilder append (任意类型)	添加数据，并返回对象本身
public StringBuilder reverse()	反转容器中的内容
public int length0	返回长度(字符出现的个数)
public String toString0	通过toString()就可以实现把StringBuilder转换为String

🌰代码示例：

package com.itheima.stringbuilderdemo;

public class StringBuilderDemo3 {
    public static void main(String[] args) {
        //1.创建对象
        StringBuilder sb = new StringBuilder("abc");

        //2.添加元素
        /*sb.append(1);
        sb.append(2.3);
        sb.append(true);*/
        // abc12.3true

        //反转
        sb.reverse();

        //获取长度
        int len = sb.length();
        System.out.println(len);


        //打印
        //普及：
        //因为StringBuilder是Java已经写好的类
        //java在底层对他做了一些特殊处理。
        //打印对象不是地址值而是属性值。
        System.out.println(sb);
    }
}

package com.itheima.stringbuilderdemo;

public class StringBuilderDemo4 {
    public static void main(String[] args) {
        //1.创建对象
        StringBuilder sb = new StringBuilder();

        //2.添加字符串
        sb.append("aaa").append("bbb").append("ccc").append("ddd");

        System.out.println(sb);//aaabbbcccddd

        //3.再把StringBuilder变回字符串
        String str = sb.toString();
        System.out.println(str);//aaabbbcccddd
    }
}

sb 只是一个容器，来帮助我们操作字符串的工具。所以在拼接完之后，还需要把 StringBuilder 变回字符串。

⭐️链式编程
当我们在调用一个方法的时候，不需要用变量接收他的结果，可以继续调用其他方法。

🌰代码示例：

package com.itheima.stringbuilderdemo;

import java.util.Scanner;

public class StringBuilderDemo5 {
    public static void main(String[] args) {
        //链式编程：
        //当我们在调用一个方法的时候，不需要用变量接收他的结果，可以继续调用其他方法
        int len = getString().substring(1).replace("A", "Q").length();
        System.out.println(len);
    }

    public static String getString(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
        return str;
    }
}

链式编程：依赖前一个方法的结果再去调用后面的方法。
substring 截取完的结果是一个小的字符串，可以继续调用字符串里面的方法 replace (把字符串里面的A替换成Q），然后再调用 length 获取字符串的长度。

public class StringBuilderDemo4 {
    public static void main(String[] args) {
        //1.创建对象
        StringBuilder sb = new StringBuilder();

        //2.添加字符串
        sb.append("aaa").append("bbb").append("ccc").append("ddd");

        System.out.println(sb);//aaabbbcccddd

        //3.再把StringBuilder变回字符串
        String str = sb.toString();
        System.out.println(str);//aaabbbcccddd
    }
}

🍊练习：对称字符串
需求：
键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是。

对称字符串：123321、111
非对称字符串：123123

📖代码示例：

public class StringBuilderDemo6 {
    //使用StringBuilder的场景：
    //1.字符串的拼接
    //2.字符串的反转

    public static void main(String[] args) {
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();

        //2.反转键盘录入的字符串
        String result = new StringBuilder().append(str).reverse().toString();

        //3.比较
        if(str.equals(result)){
            System.out.println("当前字符串是对称字符串");
        }else{
            System.out.println("当前字符串不是对称字符串");
        }
    }
}

🍊练习：拼接字符串

需求：定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回。调用该方法，并在控制台输出结果。
例如：数组为 int[] arr = {1,2,3};
执行方法后的输出结果为：[1, 2, 3]

📖代码示例:

package com.itheima.stringbuilderdemo;

public class StringBuilderDemo7 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {1,2,3};

        //2.调用方法把数组变成字符串
        String str = arrToString(arr);
        
        System.out.println(str);
    }


    public static String arrToString(int[] arr){
        StringBuilder sb = new StringBuilder();
        sb.append("[");

        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length - 1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");

        return sb.toString();
    }
}

11、StringJoiner

StringJoiner跟StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的。
作用：提高字符串的操作效率，而且代码编写特别简洁，但是目前市场上很少有人用。
JDK8出现的

⭐️StringJoiner的构造方法

方法名	说明
public StringJoiner (间隔符号)	创建一个StringJoiner对象，指定拼接时的间隔符号
public StringJoiner (间隔符号，开始符号，结束符号)	创建一个StringJoiner对象，指定拼接时的间隔符号、开始符号、结束符号

⭐️StringJoiner的成员方法

方法名	说明
public StringJoiner add (添加的内容)	添加数据，并返回对象本身
public int length()	返回长度(字符出现的个数)
public String toString()	返回一个字符串(该字符串就是拼接之后的结果)

🌰代码示例：

package com.itheima.stringjoinerdemo;

import java.util.StringJoiner;

public class StringJoinerDemo1 {
    public static void main(String[] args) {
        //1.创建一个对象，并指定中间的间隔符号
        StringJoiner sj = new StringJoiner("---");

        //2.添加元素
        sj.add("aaa").add("bbb").add("ccc");
        
        //3.打印结果
        System.out.println(sj);//aaa---bbb---ccc
    }
}

package com.itheima.stringjoinerdemo;

import java.util.StringJoiner;

public class StringJoinerDemo2 {
    public static void main(String[] args) {
        //1.创建对象
        StringJoiner sj = new StringJoiner(", ","[","]");

        //2.添加元素
        sj.add("aaa").add("bbb").add("ccc");

        int len = sj.length();
        System.out.println(len);//15 // *逗号后面还有个空格

        //3.打印
        System.out.println(sj);//[aaa, bbb, ccc]

        String str = sj.toString();
        System.out.println(str);//[aaa, bbb, ccc]
    }
}

🍎总结：

String
表示字符串的类，定义了很多操作字符串的方法。
StringBuilder
一个可变的操作字符串的容器。
可以高效的拼接字符串，还可以将容器里面的内容反转。
StringJoiner
JDK8出现的一个可变的操作字符串的容器，可以高效，方便的拼接字符串。
在拼接的时候，可以制定间隔符号，开始符号，结束符号。

12、字符串相关类的底层原理

扩展底层原理1：字符串存储的内存原理

直接赋值会复用字符串常量池中的东西
new出来不会复用，而是开辟一个新的空间

扩展底层原理2：==号比较的到底是什么?

基本数据类型比较数据值
引用数据类型比较地址值

扩展底层原理3：字符串拼接的底层原理

第一种情况：等号的右边没有变量
在这里插入图片描述

第二种情况：等号的右边有变量
🍑画图解释（JDK8以前）：
在这里插入图片描述

字符串和变量一次拼接，堆内存中至少会出现两个对象，一个是 StringBuilder对象，一个是字符串String 对象。
String s2 = s1 + "b";，相当于是，new StringBuilder().append(s1).append("b").toString();，toString的底层原理是 new，所以内存中会有两个对象。

在这里插入图片描述

🍑画图解释（JDK8）：
在这里插入图片描述

JDK8 在字符串拼接的时候会做一个预估。预估成数组，最后再去创建字符串对象。

但是预估也是需要时间的，如果每一行都要进行字符串和变量的拼接的话，每一行都要进行预估，再创建数组，再变成字符串。

所以就算JDK优化了，还是一样的浪费时间。字符串拼接的时候有变量参与，在内存中创建了很多对象浪费空间，时间也非常慢。

✅结论：如果很多字符串变量拼接，不要直接+。在底层会创建多个对象，浪费时间，浪费性能。

扩展底层原理4：StringBuilder提高效率原理图

🍑画图解释：在这里插入图片描述

StringBuilder是一个内容可变的容器，我们是把所有的数据往同一个StringBuilder 里面放的，所以效率会高。

📝常见面试题：
1️⃣
在这里插入图片描述
📚答案：

2️⃣
在这里插入图片描述
📚答案：

⭕️字符串原理小结：

扩展底层原理3:字符串拼接的底层原理

如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的字符串。
如果有变量参与，每一行拼接的代码，都会在内存中创建新的字符串，浪费内存。

扩展底层原理4:StrinqBuilder提高效率原理图

所有要拼接的内容都会往StringBuilder中放，不会创建很多无用的空间，节约内存.

扩展底层原理5：StringBuilder源码分析

默认创建一个长度为16的字节数组
添加的内容长度小于16，直接存
添加的内容大于16会扩容(原来的容量*2+2)
如果扩容之后还不够，以实际长度为准

🌰代码示例：

package test;

import java.util.Scanner;

public class A {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();

        // 容量：最多装多少
        // 长度：已经装了多少
        System.out.println(sb.capacity()); // 16
        System.out.println(sb.length()); // 0

        sb.append("abc");
        System.out.println(sb.capacity()); // 16
        System.out.println(sb.length()); // 3

        sb.append("defghijklmnopqrstuvwxyz");
        System.out.println(sb.capacity()); // 34
        System.out.println(sb.length()); // 26

        sb.append("0123456789");
        System.out.println(sb.capacity()); // 36
        System.out.println(sb.length()); // 36

    }
}

🍎字符串原理小结

扩展底层原理1：字符串存储的内存原理

直接赋值会复用字符串常量池中的东西
new出来不会复用，而是开辟一个新的空间

扩展底层原理2：==号比较的到底是什么?

基本数据类型比较数据值
引用数据类型比较地址值

扩展底层原理3:字符串拼接的底层原理

如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的字符串。
如果有变量参与，每一行拼接的代码，都会在内存中创建新的字符串，浪费内存。

扩展底层原理4:StrinqBuilder提高效率原理图

所有要拼接的内容都会往StringBuilder中放，不会创建很多无用的空间，节约内存

扩展底层原理5：StringBuilder源码分析

默认创建一个长度为16的字节数组
添加的内容长度小于16，直接存
添加的内容大于16会扩容(原来的容量*2+2)
如果扩容之后还不够，以实际长度为准

练习

13、较难练习-罗马数字的两种写法

键盘录入一个字符串
要求1:长度为小于等于9
要求2:只能是数字
将内容变成罗马数字
下面是阿拉伯数字跟罗马数字的对比关系:
1-1、1-2、1-3、IV-4、V-5、V-6、V-7、V-8、1X-9注意点:
罗马数字里面是没有0的
如果键盘录入的数字包含0，可以变成""(长度为0的字符串)

📖代码示例：

package com.itheima.test;

import java.util.Scanner;

public class Test1Case1 {
    public static void main(String[] args) {
       /* 键盘录入一个字符串，
        要求1：长度为小于等于9
        要求2：只能是数字
                将内容变成罗马数字
        下面是阿拉伯数字跟罗马数字的对比关系：
        Ⅰ－1、Ⅱ－2、Ⅲ－3、Ⅳ－4、Ⅴ－5、Ⅵ－6、Ⅶ－7、Ⅷ－8、Ⅸ－9
        注意点：
        罗马数字里面是没有0的
        如果键盘录入的数字包含0，可以变成""(长度为0的字符串)*/

        //1.键盘录入一个字符串
        //书写Scanner的代码
        Scanner sc = new Scanner(System.in);
        String str;
        while (true) {
            System.out.println("请输入一个字符串");
            str = sc.next();
            //2.校验字符串是否满足规则
            boolean flag = checkStr(str);
            if (flag) {
                break;
            } else {
                System.out.println("当前的字符串不符合规则，请重新输入");
                continue;
            }
        }

        //将内容变成罗马数字
        //下面是阿拉伯数字跟罗马数字的对比关系：
        //Ⅰ－1、Ⅱ－2、Ⅲ－3、Ⅳ－4、Ⅴ－5、Ⅵ－6、Ⅶ－7、Ⅷ－8、Ⅸ－9
        //查表法：数字跟数据产生一个对应关系
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            int number = c - 48; // 1 2 3 4 5
            String s = changeLuoMa(number);
            sb.append(s);
        }

        System.out.println(sb);

    }

    public static String changeLuoMa(int number) {
        //定义一个数组，让索引跟罗马数字产生一个对应关系
        String[] arr = {"", "Ⅰ", "Ⅱ", "Ⅲ", "Ⅳ", "Ⅴ", "Ⅵ", "Ⅶ", "Ⅷ", "Ⅸ"};
        return arr[number];

    }

    public static boolean checkStr(String str) {//123456
        //要求1：长度为小于等于9
        if (str.length() > 9) {
            return false;
        }

        //要求2：只能是数字
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);//0~9
            if (c < '0' || c > '9') {
                return false;
            }
        }

        //只有当字符串里面所有的字符全都判断完毕了，我才能认为当前的字符串是符合规则
        return true;
    }
}

package com.itheima.test;

import java.util.Scanner;

public class Test1Case2 {
    public static void main(String[] args) {
       /* 键盘录入一个字符串，
        要求1：长度为小于等于9
        要求2：只能是数字
                将内容变成罗马数字
        下面是阿拉伯数字跟罗马数字的对比关系：
        Ⅰ－1、Ⅱ－2、Ⅲ－3、Ⅳ－4、Ⅴ－5、Ⅵ－6、Ⅶ－7、Ⅷ－8、Ⅸ－9
        注意点：
        罗马数字里面是没有0的
        如果键盘录入的数字包含0，可以变成""(长度为0的字符串)*/

        //1.键盘录入一个字符串
        //书写Scanner的代码
        Scanner sc = new Scanner(System.in);
        String str;
        while (true) {
            System.out.println("请输入一个字符串");
            str = sc.next();
            //2.校验字符串是否满足规则
            boolean flag = checkStr(str);
            if (flag) {
                break;
            } else {
                System.out.println("当前的字符串不符合规则，请重新输入");
                continue;
            }
        }

        //将内容变成罗马数字
        //下面是阿拉伯数字跟罗马数字的对比关系：
        //Ⅰ－1、Ⅱ－2、Ⅲ－3、Ⅳ－4、Ⅴ－5、Ⅵ－6、Ⅶ－7、Ⅷ－8、Ⅸ－9
        //查表法：数字跟数据产生一个对应关系
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            String s = changeLuoMa(c);
            sb.append(s);
        }

        System.out.println(sb);

    }

    //利用switch进行匹配
    public static String changeLuoMa(char number) {
        return switch (number) {
            case '0' -> "";
            case '1' -> "Ⅰ";
            case '2' -> "Ⅱ";
            case '3' -> "Ⅲ";
            case '4' -> "Ⅳ";
            case '5' -> "Ⅴ";
            case '6' -> "Ⅵ";
            case '7' -> "Ⅶ";
            case '8' -> "Ⅷ";
            case '9' -> "Ⅸ";
            // *修正：直接返回空字符串
            // *这部分有报错
            default -> "";
        };
    }

    public static boolean checkStr(String str) {//123456
        //要求1：长度为小于等于9
        if (str.length() > 9) {
            return false;
        }

        //要求2：只能是数字
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);//0~9
            if (c < '0' || c > '9') {
                return false;
            }
        }

        //只有当字符串里面所有的字符全都判断完毕了，我才能认为当前的字符串是符合规则
        return true;
    }
}

14、调整字符串的内容并比较

给定两个字符串，A 和 B。
A 的旋转操作就是将 A最左边的字符移动到最右边。例如,若 A=‘abcde’，在移动一次之后结果就是’bcdea’如果在若干次调整操作之后，A能变成B，那么返回True。如果不能匹配成功，则返回false。

📖代码示例：

package com.itheima.test;

public class Test2Case1 {
    public static void main(String[] args) {
       /* 给定两个字符串, A和B。
        A的旋转操作就是将A 最左边的字符移动到最右边。
        例如, 若A = 'abcde'，在移动一次之后结果就是'bcdea'
        如果在若干次调整操作之后，A能变成B，那么返回True。
        如果不能匹配成功，则返回false*/

        //1.定义两个字符串
        String strA = "abcde";
        String strB = "ABC";

        //2.调用方法进行比较
        boolean result = check(strA, strB);

        //3.输出
        System.out.println(result);
    }

    public static boolean check(String strA, String strB) {
        for (int i = 0; i < strA.length(); i++) {
            strA = rotate(strA);
            if(strA.equals(strB)){
                return true;
            }
        }
        //所有的情况都比较完毕了，还不一样那么直接返回false
        return false;
    }


    //作用：旋转字符串，把左侧的字符移动到右侧去
    //形参：旋转前的字符串
    //返回值：旋转后的字符串
    public static String rotate(String str) {
        //套路：
        //如果我们看到要修改字符串的内容
        //可以有两个办法：
        //1.用subString进行截取，把左边的字符截取出来拼接到右侧去
        //2.可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串。

        //截取思路
        //获取最左侧那个字符
        char first = str.charAt(0);
        //获取剩余的字符
        String end = str.substring(1);

        return end + first;
    }
}

package com.itheima.test;

public class Test2Case2 {
    public static void main(String[] args) {
       /* 给定两个字符串, A和B。
        A的旋转操作就是将A 最左边的字符移动到最右边。
        例如, 若A = 'abcde'，在移动一次之后结果就是'bcdea'
        如果在若干次调整操作之后，A能变成B，那么返回True。
        如果不能匹配成功，则返回false*/

        //1.定义两个字符串
        String strA = "abcde";
        String strB = "ABC";
        
        //2.调用方法进行比较
        boolean result = check(strA, strB);

        //3.输出
        System.out.println(result);
    }

    public static boolean check(String strA, String strB) {
        for (int i = 0; i < strA.length(); i++) {
            strA = rotate(strA);
            if (strA.equals(strB)) {
                return true;
            }
        }
        //所有的情况都比较完毕了，还不一样那么直接返回false
        return false;
    }

    //作用：旋转字符串，把左侧的字符移动到右侧去
    //形参：旋转前的字符串
    //返回值：旋转后的字符串
    public static String rotate(String str) {
        //套路：
        //如果我们看到要修改字符串的内容
        //可以有两个办法：
        //1.用subString进行截取，把左边的字符截取出来拼接到右侧去
        //2.可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串。

        //可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串。
        
        //"ABC"   ['A','B','C']  ['B','C','A']   new String(字符数组);
        char[] arr = str.toCharArray();
        //拿到0索引上的字符
        char first = arr[0];
        //把剩余的字符依次往前挪一个位置
        for (int i = 1; i < arr.length; i++) {
            arr[i - 1] = arr[i];
        }
        //把原来0索引上的字符放到最后一个索引
        arr[arr.length - 1] = first;

        //利用字符数组创建一个字符串对象
        String result = new String(arr);
        return result;
    }
}

15、后续练习思路分析

1️⃣键盘输入任意字符串，打乱里面的内容
📖代码示例：

package com.itheima.test;

public class Test3 {
    public static void main(String[] args) {
        //键盘输入任意字符串，打乱里面的内容

        //1.键盘输入任意字符串
        String str = "abcdefg";

        //2.打乱里面的内容
        //修改字符串里面的内容：
        //1.subString
        //2.变成字符数组
        char[] arr = str.toCharArray();//['a','b','c','d','e','f','g']

        //3.打乱数组里面的内容
        //从0索引开始，跟一个随机索引进行位置的交换
        //当数组里面的每一个元素都跟一个随机索引进行交换完毕之后，那么内容就打乱了

        //4.把字符数组再变回字符串
        String result = new String(arr);

        System.out.println(result);
    }
}

2️⃣生成验证码

内容：可以是小写字母，也可以是大写字母，还可以是数字

规则：长度为5。
内容中是四位字母，1位数字。
其中数字只有1位，但是可以出现在任意的位置。

📖代码示例：

package com.itheima.test;

public class Test4 {
    public static void main(String[] args) {
       /*
        生成验证码
        内容：可以是小写字母，也可以是大写字母，还可以是数字
        规则：
        长度为5
        内容中是四位字母，1位数字。
        其中数字只有1位，但是可以出现在任意的位置。*/

        //1.可以把所有的大写字母，小写字母都放到一个数组当中
        char[] arr = new char[52];
        //a-z  A-Z

        //2.从数组中随机获取4次

        //3.生成一个0~9之间的随机数拼接到最后
        //ACFG7
        //思考，我们把7放到前面，修改了字符串的内容
        //把生成的验证码先变成一个字符数组
        //再让最后一个元素跟前面的随机位置的元素进行交换
        //交换完毕之后再变成字符串就可以了。
    }
}

3️⃣
给定两个以字符串形式表示的非负整数num1和num2，返回num1和num2的乘积，它们的乘积也表示为字符串形式。
注意：需要用已有的知识完成。

📖代码示例：

package com.itheima.test;

public class Test5 {
    public static void main(String[] args) {
        /* 给定两个以字符串形式表示的非负整数num1和num2，返回num1和num2的乘积，它们的乘积也表示为字符串形式。
        注意：需要用已有的知识完成。*/

        //不需要考虑乘积过大之后的结果
        //就认为乘积一定是小于int的最大值的

        String num1 = "123456789";
        String num2 = "12345";

        //1.把num1和num2变成对应的整数才可以
        //"123456789"
        //先遍历字符串依次得到每一个字符 '1'  '2'  '3'  '4'  '5'  '6'  '7'  '8'  '9'
        //再把字符变成对应的数字即可     1    2    3     4    5    6    7    8    9
        //把每一个数字组合到一起 123456789

        //2.利用整数进行相乘

        //3.可以把整数变成字符串
        //+""
    }
}

4️⃣
给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。
返回字符串中最后一个单词的长度。
单词是指仅由字母组成、不包含任何空格字符的最大子字符串。

📖代码示例：

package com.itheima.test;

public class Test6 {
    public static void main(String[] args) {
      /* 给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。
        返回字符串中最后一个单词的长度。
        单词是指仅由字母组成、不包含任何空格字符的最大子字符串。

        示例 1：输入：s = "Hello World“	输出：5
        解释：最后一个单词是“World”，长度为5。

        示例 2：输入：s = "   fly me   to   the moon"	输出：4
        解释：最后一个单词是“moon”，长度为4。

        示例 3：输入：s = "luffy is still joyboy"	输出：6
        解释：最后一个单词是长度为6的“joyboy”。*/

        //倒着遍历
        //直到遇到空格为止
        //那么遍历的次数就是单词的长度
    }
}

day10-字符串

目录

字符串

1、API 和 API 帮助文档

2、String概述

3、String构造方法代码实现和内存分析

3.1 创建String对象的两种方式

3.2 Java的内存模型

4、字符串的比较

4.1 ==号的作用

4.2 equals方法的作用

练习

5、用户登录

6、遍历字符串和统计字符个数

7、字符串拼接和翻转

8、较难练习-金额转换

9、手机号屏蔽

10、StringBuilder

11、StringJoiner

12、字符串相关类的底层原理

扩展底层原理1：字符串存储的内存原理

扩展底层原理2：==号比较的到底是什么?

扩展底层原理3：字符串拼接的底层原理

扩展底层原理4：StringBuilder提高效率原理图

扩展底层原理5：StringBuilder源码分析

练习

13、较难练习-罗马数字的两种写法

14、调整字符串的内容并比较

15、后续练习思路分析

悦读

day10-字符串

目录

字符串

1、API 和 API 帮助文档

2、String概述

3、String构造方法代码实现 和 内存分析

3.1 创建String对象的两种方式

3.2 Java的内存模型

4、字符串的比较

4.1 ==号的作用

4.2 equals方法的作用

练习

5、用户登录

6、遍历字符串和统计字符个数

7、字符串拼接和翻转

8、较难练习-金额转换

9、手机号屏蔽

10、StringBuilder

11、StringJoiner

12、字符串相关类的底层原理

扩展底层原理1：字符串存储的内存原理

扩展底层原理2：==号比较的到底是什么?

扩展底层原理3：字符串拼接的底层原理

扩展底层原理4：StringBuilder提高效率原理图

扩展底层原理5：StringBuilder源码分析

练习

13、较难练习-罗马数字的两种写法

14、调整字符串的内容并比较

15、后续练习思路分析

悦读

3、String构造方法代码实现和内存分析