Java学习笔记===》6. API & 字符串

API & 字符串

如何使用别人已经写好的类

一、API(Application ProgrammingInterface）

简单理解：API就是别人已经写好的东西，我们不需要自己编写，直接使用即可

public static void main(String[] args){
    Random r = new Random();
    int number = r.nextInt(100);
}

1. Java API:

​ 指的就是jdk中提供的各种功能的类

已经学习过的API：

​ Scanner：键盘录入

​ Random：获取随机数

其他的API:**

2.API 和API 帮助文档

（1）API：指的就是jdk中提供的各种功能的类

​ 这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可

（2）API帮助文档：

​ 帮助开发人员更好的使用API和车讯API的一个工具

（3）如可使用帮助文档

​ ① 打开API帮助文档

​ ②点击显示，并找到索引下面的输入

​ ③在输入框中输入类名并点击显示

​ ④查看类所在的包

​ ⑤查看类的描述

​ ⑥查看构造

​ ⑦查看成员方法

二、字符串

1、字符串在开发中的应用场景

用户登录、大小写转换、敏感词替换

2.字符串学习内容

（1）String概述

​ java.lang.String类代表字符串，Java程序中所有字符串文字都为此类的对象

​ String name = “尼古拉斯”；

​ String schoolname = “chengxuyuan”;

​ 注意：字符串的内容是不会发生改变的，他的对象在创建后不能被更改

​ 字符串拼接后会产生一个新的字符串

（2）创建String对象的两种方式

①直接赋值

​ String name = “尼古拉斯”;

②new关键字构造方法

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

③字符串在Java中的内存模型

当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在

如果不存在：创建新的

如果存在：直接复用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7CILBlG1-1685444820931)(D:\java笔记\笔记图片\字符串内存模型.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gYs8TjuL-1685444820933)(D:\java笔记\笔记图片\new出来的字符串的内存原理.png)]

3.Java常用的方法

（1）比较：

① ” == “号比较的到底是什么

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3p7RhPwr-1685444820934)(D:\java笔记\笔记图片\不同数据类型的比较.png)]

②字符串比较

Ⅰ.boolean equals（）

方法	说明
Boolean equals（要比较的字符串）	完全一样结果才是true，否则为false
Boolean equalsIgnoreCase（要比较的字符串）	忽略大小写的比较

package com._11_API_String;

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

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


        //3，比较字符串对象中的内容是否相等
        boolean resutl1 = s1.equals(s2);
        System.out.println(resutl1);         //true 表示完全相等


        //4.比较字符串对象中的内容是否相等（忽略大小写）
        //这里的忽略大小写只能是英文状态下的
        boolean result2 = s1.equalsIgnoreCase(s3);
        System.out.println(result2);        //true 忽略大小写之后内容一样

    }
}

案例：

package com._11_API_String;

import java.util.Scanner;

public class Demo_04_String_compare {
    public static void main(String[] args) {
        //1.假设现在线盘录入一个abc
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String s1 = sc.next();  //键盘录入的字符串最终是new出来的，存在栈中


        //2.代码中再定义一个字符串
        String s2 = "abc";
        String s3 = new String("Abc");


        //进行比较
        boolean b1 = s1.equals(s2);
        boolean b2 = s1.equals(s3);
        boolean b3 = s1.equalsIgnoreCase(s2);
        boolean b4 = s1.equalsIgnoreCase(s3);


        System.out.println(b1);     //true
        System.out.println(b2);     //false
        System.out.println(b3);     //true
        System.out.println(b4);     //true
        //使用 == 号比较
        System.out.println(s1 == s2);       //false
        System.out.println(s1 == s3);       //false
        System.out.println(s2 == s3);       //false
    }
}
//结论：
//以后只要想比较String里面的内容，就必须要用String里面的方法

package com._11_API_String;

import java.util.Scanner;

public class Demo_05_String_test {
    //需求：已知正确的用户名和密码，请用程序实现模拟用户登录
    //总共给三次机会，登录之后，给出相应的提示
    public static void main(String[] args) {
        //读题拆解法
        //1.定义正确的用户名和密码
        String rightUsername = "zhangsan";
        String rightPassword = "zs123456";

        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            //2.用程序实现模拟用户登录
            //键盘录入用户名和密码

            System.out.println("请输入您的用户名");
            String reciveUsername = sc.next();
            System.out.println("请输入您的密码");
            String recivePassword = sc.next();

            //3.对接受的用户名和密码进行比较

            if (reciveUsername.equals(rightUsername) && recivePassword.equals(rightPassword)) {
                System.out.println("输入正确，用户登录成功");
                break;
            } else {
                if (i == 2) {
                    System.out.println("错误次数已达" + (i+1) + "次,账户"+reciveUsername+"已被锁定");
                } else {
                    System.out.println("登录失败 用户名或密码错误，请重新输入，还剩下" + (2 - i) + "次机会");
                }
            }
        }
    }
}

③遍历字符串

方法	说明
public char charAt ( int index )	根据索引返回字符
public int length ( )	返回此字符串的长度

数组的长度：数组名.length

字符串的长度：字符串对象 . length（ ）

package com._11_API_String;

import java.util.Scanner;

public class Demo_07_String_bianli {
    //需求：
    //键盘录入一个字符串，使用程序实现在控制台遍历该字符串

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

        //2.进行遍历
        for (int i = 0; i < str.length(); i++) {
            // i 依次表示该字符串的每一个索引
            char c = str.charAt(i);
            System.out.println(c);
        }
    }
}

package com._11_API_String;

import java.util.Scanner;

public class Demo_07_String_bianli_test {
    //需求：
    //键盘录入一个字符串，拥挤该字符串中大写字母字符、小写字母字符
    //数字字符出现的次数（不考虑其他字符）
    public static void main(String[] args) {
        //1.键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();

        //2.统计字符串---->计数器思想
        int bigCount = 0,smallCount = 0, numCount = 0;
        for (int i = 0; i < str.length(); i++) {
            // i 依次表示字符串的索引
            char c = str.charAt(i);

            //char类型的变量在参与计算的时候自动类型提升为int，查询ASCII码表
            if(c>='a' && c<='z'){
                smallCount++;

            }else if(c<='Z' && c>='A'){
                bigCount++;
            }else if (c>= '0' && c<='9'){
                numCount++;
            }

        }
        System.out.println("大写字符一共有"+bigCount+"个");
        System.out.println("小写字符一共有"+smallCount+"个");
        System.out.println("数字字符一共有"+numCount+"个");

        }
        }

字符串反转

package com._11_API_String;

import javax.xml.transform.Result;
import java.util.Scanner;

public class Demo_08_String_fanzhuan_test2 {
    //需求：
    //定义一个方法，实现字符串反转
    //键盘录入一个字符串，调用该方法后，在控制台输出结果
    //例如：键盘录入abc，输出结果cba
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
        String str2 = reverser(str);
        System.out.println(str2);
    }
    public static String reverser(String str){
        String result = "";
        //遍历字符串
        for (int i = str.length()-1; i >=0; i--) {
            //i依次表示字符串中的每一个索引（倒着的）
            char c = str.charAt(i);
            result = result + c;
        }
        return result;
    }
}

字符串大写

package com._11_API_String;
import java.util.Scanner;
public class Demo_09_String_zhuanhuan_test3 {
    //将数字转换为大写的金额
    public static void main(String[] args) {
        //键盘录入一个金额
        int money;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个金额");
        money = sc.nextInt();
        //对输入的金额做出判断
        while (true) {
            if(money >= 0 && money <=9999999){
                break;
            }else{
                System.out.println("输入的金额有误,请重新输入");
            }
        }
        //定义一个变量来表示钱的大写
        String moneyStr = "";
        //2.得到money里面的每一位数字,再转成大写中文
       while(true){
           //从右往左获取数据
           int ge = money % 10;
           String upNum = getUpMoney(ge);
           //把转换之后的大写拼接到moneyStr当中
           moneyStr = upNum + 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;
        }


        //4.插入单位
        //定义一个数组表示单位
        String []arr = {"佰","拾","万","仟","佰","拾","元"};
        String result = "";
        for (int i = 0; i < moneyStr.length(); i++) {
            char c = moneyStr.charAt(i);
            //把大写数字和单位拼接到result中
            result = result + c + arr[i];
        }
        System.out.println(result);
    }

    //定义一个方法，将数字变成大写的金额
    public static String getUpMoney(int number){
        //定义数组，让数字跟大写的字一一对应
        String [] arr = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
        //返回结果
        return arr[number] ;
    }
}

字符串截取
//String substring(int beginindex, int endIndex)
        //注意：
        //包头不包尾，包左不包右
        //只有返回值才是截取的小串
    //String substring(int beginIndex)====>截取到末尾

package com._11_API_String;

import java.util.Scanner;

public class Demo_10_String_number_Pingbi_test4 {

    //字符串截取
    //String substring(int beginindex, int endIndex)
        //注意：
        //包头不包尾，包左不包右
        //只有返回值才是截取的小串
    //String substring(int beginIndex)====>截取到末尾
    public static void main(String[] args) {
        //1.获取一个手机号码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个手机号");
        String number = sc.next();
        //2.将获取的号码存入数组
        String str1 = number.substring(0,3);
        String str2 = number.substring(7);
        String result = str1+"****"+str2;
        System.out.println(result);
    }
}

字符串截取
//String substring(int beginindex, int endIndex)
        //注意：
        //包头不包尾，包左不包右
        //只有返回值才是截取的小串
    //String substring(int beginIndex)====>截取到末尾
package com._11_API_String;

import java.util.Scanner;

public class Demo_11_String_IDCheck_test05 {
    public static void main(String[] args) {
        //获取身份证号码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入18位身份证号码");
        String idNum = sc.next();

        String birthDate= idNum.substring(6,14);
        char gender = idNum.charAt(16);
        System.out.println(birthDate+"----"+gender);


        String year = birthDate.substring(0,4);
        String month = birthDate.substring(4,6);
        String day = birthDate.substring(6);

        int num = gender - 48;
        if(num % 2 == 1){
            gender ='男';
        }else{
            gender = '女';
        }


        System.out.println("这个人的出生年份位"+year+"年"+month+"月"+day+"日,性别为"+gender);
    }
}

字符串替换
//String replace(旧值，新值)  替换
//注意：只有返回值才是替换后的结果
    
    
package com._11_API_String;

public class Demo_12_String_replace_test06 {
    //String replace(旧值，新值)  替换
    //注意：只有返回值才是替换后的结果
    public static void main(String[] args) {
        //1.获取说的话
        String talk = "你玩的真好，以后不要在玩了，真是绝绝子，细狗你行不行啊";


        //2.定义一个敏感词库
        String talk1;
        String [] arr = {"tmd","绝绝子","细狗"};

        //3.循环遍历得到数组中的每一个敏感词
        for (int i = 0; i < arr.length; i++) {
            //2.把里面的绝绝子替换为  ***
            talk = talk.replace(arr[i],"***");
        }
        //4.打印结果
        System.out.println(talk);
    }
}

（2）StringBuilder

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

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

①StringBuilder创建对象

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

​ 例如：

​ StringBuilder sb = new SreingBuilder ( );

​ StringBuilder sb = new SreingBuilder (“abc” );

②StringBuilder常用方法

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

package com._11_API_String;

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

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

        //字符串反转
        sb.reverse();


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


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

package com._11_API_String;

import java.lang.reflect.Type;

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

        //2.添加字符拆
        sb.append(2);
        sb.append(true);
        sb.append("abc");
        sb.append('c');
        sb.append(2.4);
		//代码优化
        sb.append(2).append(true).append("abc").append('c').append(2.4);
        
        //3.打印结果
        System.out.println(sb);

        //4.将StringBuilder转换为string
        String s = sb.toString();

        System.out.println(s.getClass());
    }
}

链式编程：

package com._11_API_String;

import java.util.Scanner;

public class Demo_15_ChainCode {
    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;
    }
}

/*
* 使用 StringBuilder的使用场景
* 1.字符串的拼接
* 2.字符串的反转
*/
public class Demo_16_String_test {
    //需求：
    //键盘接收一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是
    //对称字符串：123321、111    非对称字符串 123123
    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("该字符串不是对称字符串");
        }
    }
}

package com._11_API_String;

public class Demo_17_String_pinjie_test1 {
/*
* 拼接字符串
* 需求：
* 定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回
* 调用该方法，并在控制台输出结果
* 例如：数组为 int [] arr = {1,2,3,4}
* 执行方法后的输出结果为[1,2,3,4]
*/
    public static void main(String[] args) {
        //1.定义数组
       int [] arr = {1,2,3,4,5};
       //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("]");
        String str = sb.toString();
        return str;
    }
}

（3）Stringjonier

为社么要学习StringJoiner？

①概述：

​ ★StringJoiner和StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可以改变的

​ ★作用：提高字符串的操作效率，而且代码编写特别简洁，但是目前市场上 很少有人用

​ ★这个方法是在JDK8出现的

②构造方法（没有空参构造）

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

例如：

StringJoiner sj = new StringJoiner("---");		//1---2---3

StringJoiner sj = new StringJoiner("--","[","]");		//[1--2--3]

③StringJoiner的成员方法

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

package com._11_API_String;

import java.util.StringJoiner;

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

        //2.添加元素
        sj1.add("l").add("z").add("b");
        sj2.add("lll").add("zzz").add("bbb");


        //3.获取长度。 .length();
        int len1 = sj1.length();        //表示字符的个数，而不是添加的元素的个
        int len2 = sj2.length();        //会将间隔符开始符号结束符号加在一起

        //4.返回字符串toString ();
        String str1 = sj1.toString();
        String str2 = sj2.toString();
        
        //5.打印
        System.out.println(sj1);        // l---z---b
        System.out.println(sj2);        // [lll ; zzz ; bbb]
        System.out.println(len1);       // 9
        System.out.println(len2);       // 17
        System.out.println(str1);
        System.out.println(str2);
    }
}

4.字符串原理

（1）字符串存储的内存原理

​ ★ 直接赋值会复用字符串常量池中的

​ ★ new出来的不会复用，而是开辟一个新的空间

（2）“ == ”号比较的到底是什么

​ ★ 引用数据类型比较地址值

​ ★ 基本数据类型比较数据值

（3）字符串拼接的底层原理

①等号的右边没有变量参与

String s = "a"+"b"+"c";		//abc

​ 拼接的时候没有变量，都是字符串，出发字符串的优化机制，在编译的时候就已经是最终结果了

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lYRtg4aZ-1685444820935)(D:\java笔记\笔记图片\字符串拼接的底层原理1.png)]

②等号的右边有变量参与

String s1 = "a";
String s2 = s1 + "b";
String s3 = s2 + "c";
System.out.println(s3); 		// s3 = a + b + c = abc

在拼接的时候有变量，JDK8以前的底层会使用StringBuilder

public String toString() {
    // Create a copy, don't share the array
    return isLatin1() ? StringLatin1.newString(value, 0, count)
                      : StringUTF16.newString(value, 0, count);
}

public static String newString(byte[] val, int index, int len) {
    return new String(Arrays.copyOfRange(val, index, index + len),
                      LATIN1);
}

注意：在有变量参与拼接的情况下，每次与变量拼接，都会创建一个新的StringBuilder对象

③JDK8字符串拼接的底层原理

JDK8以前：系统底层会自动创建一个StringBuilder对象，然后再调用其append方法完成拼接。拼接后再调用其toString方法转换为String类型，而toString方法的底层直接new了一个字符转对象

JDK8以后：系统会预估字符串拼接后的长度大小，把要拼接的内容都放在数组中，此时也是产生一个新的字符串

注意：首先会预估字符串的长度，并创建一个数组，将字符串存入数组中，然后将数组转换为字符串，但是在内存中创建了很多数组对象，浪费空间，时间也非常慢

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

★如果没有变量参与，都是字符串直接相加，编译之后就是拼接的结果，会复用串池中的字符串

★如果有变量参与，每一行拼接的代码，都会在内存中创建新的字符串，浪费内存

（4）StringBuilder提高效率原理图

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

（5）StringBuilder的源码分析

★ 默认创建一个长度为16的字节数组

★ 添加的内容小于16，直接存

★ 添加的内容大于16会扩容（原来的容量 x 2 + 2）

★ 如果扩容之后还不够，以实际长度为准

package com._11_API_String;

public class Demo_19_StringBuilder_check{
    public static void main(String[] args) {
        //创建StringBuilder对象
        StringBuilder sb = new StringBuilder();
        //长度：已经装了多少
        //容量：最多装多少
        System.out.println(sb.capacity());  //获取容量==>16
        System.out.println(sb.length());    //获取长度==>0

        //添加数据
        //sb.append("zbcde");
        System.out.println(sb.capacity());  //获取容量==>16
        System.out.println(sb.length());    //获取长度==>5

        //sb.append("qwertyuiopasdfghjklzxc");
        System.out.println(sb.capacity());  //获取容量==>34  ===>16*2+2=34
        System.out.println(sb.length());    //获取长度==>22


        sb.append("1234567890qwertyuiopasdfghjklzxcvbnm");
        System.out.println(sb.capacity());  //获取容量==>36 和实际长度保持一致
        System.out.println(sb.length());    //获取长度==>36
    }
}

StringBuilder源码分析：

★空参构造

@HotSpotIntrinsicCandidate
public StringBuilder() {
    super(capacity：16);		//默认容量为16=====》int capacity=16
}

AbstractStringBuilder(int capacity) {	//int capacity 
    if (COMPACT_STRINGS) {
        value = new byte[capacity];
        coder = LATIN1;
    } else {
        value = StringUTF16.newBytesFor(capacity);
        coder = UTF16;
    }
}

★含参构造：

public AbstractStringBuilder append(String str) {
    if (str == null) {
        return appendNull();
    }
    int len = str.length();
    ensureCapacityInternal(count + len);
    putStringAt(count, str);
    count += len;
    return this;
}

private AbstractStringBuilder appendNull() {
    ensureCapacityInternal(count + 4);
    int count = this.count;
    byte[] val = this.value;
    if (isLatin1()) {
        val[count++] = 'n';
        val[count++] = 'u';
        val[count++] = 'l';
        val[count++] = 'l';
    } else {
        count = StringUTF16.putCharsAt(val, count, 'n', 'u', 'l', 'l');
    }
    this.count = count;
    return this;
}

字符串原理小结：

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

​ ①直接赋值会复用字符串常量池中的

​ ②new出来不会复用，而是开辟一个新的空间

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

①基本数据类型比较的是数据值

②引用数据类型比较的是地址值

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

①如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的字符串

②如果有变量参与，会创建新的字符串，浪费内存

★扩展的曾原理4：StringBuilder提高效率原理图

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

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

①默认创建一个长度为16的字节数组

②添加的内容小于16，直接存

③添加的内容大于16会扩容（原来的容量 x 2 + 2）

④如果扩容之后还不够，以实际长度为准

三、字符串练习

package com._11_API_String;

import java.util.Scanner;
import java.util.StringJoiner;

public class Demo_20_StringTest1 {
    /*需求：
    1.键盘录入一个字符串
    要求1：长度为小于等于9
    要求2：只能是数字
    将内容变成罗马数字
    阿拉伯数字与罗马数字的关系
    1-Ⅰ、2-Ⅱ、3Ⅲ、4Ⅳ、5Ⅴ、6Ⅵ、7Ⅶ、8Ⅷ、9Ⅸ、
    注意点；罗马数字里面没有0，如果键盘录入的数字包含0，可以变成“”（长度为0的字符串）
     */
    public static void main(String[] args) {
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        String str;
        while (true) {
            System.out.println("请输入一个9位以内的字符串");
             str = sc.next();

            //2.对接收的字符串进行校验
            boolean flag = checkStr(str);
            if(flag == true){
                break;
            }else{
                System.out.println("您输入的字符串超出范围或字符错误，请重新输入");
                continue;
            }
        }
        //3.将阿拉伯数字转换成罗马数字
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            //System.out.println(c);
            int number = c - 48;
            String str2 = stringTrans(number);
            sb.append(str2).append(",").toString();
        }

        System.out.println(sb);

    }

    //书写方法对字符串进行规则校验
    public static boolean checkStr(String str) {
        //要求1：长度为小于等于9
        if (str.length() > 9) {
            return false;
        }
        //要求2：只能是数字
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if ( c <'0' || c > '9'){
                return false;
            }
        }
        //只有当字符串里面所有字符都比较完毕，才能返回true
        return true;
    }


    //书写方法对字符串内容进行转换
    public static String stringTrans(int number){
        //定义一个数组，存放罗马数字,让索引和罗马数字产生对应关系
        String []srr = {"null","Ⅰ","Ⅱ","Ⅲ","Ⅳ","Ⅴ","Ⅵ","Ⅶ","Ⅷ","Ⅸ"};
        return srr[number];
    }
}

package com._11_API_String;

import java.util.Scanner;
import java.util.StringJoiner;

public class Demo_21_StringTest1case2 {
    /*需求：
    1.键盘录入一个字符串
    要求1：长度为小于等于9
    要求2：只能是数字
    将内容变成罗马数字
    阿拉伯数字与罗马数字的关系
    1-Ⅰ、2-Ⅱ、3Ⅲ、4Ⅳ、5Ⅴ、6Ⅵ、7Ⅶ、8Ⅷ、9Ⅸ、
    注意点；罗马数字里面没有0，如果键盘录入的数字包含0，可以变成“”（长度为0的字符串）
     */
    public static void main(String[] args) {
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        String str;
        while (true) {
            System.out.println("请输入一个9位以内的字符串");
            str = sc.next();

            //2.对接收的字符串进行校验
            boolean flag = checkStr(str);
            if(flag == true){
                break;
            }else{
                System.out.println("您输入的字符串超出范围或字符错误，请重新输入");
                continue;
            }
        }
        //3.将阿拉伯数字转换成罗马数字
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            //System.out.println(c);
            String str2 = stringTrans(c);
            sb.append(str2).append(",").toString();
        }

        System.out.println(sb);

    }

    //书写方法对字符串进行规则校验
    public static boolean checkStr(String str) {
        //要求1：长度为小于等于9
        if (str.length() > 9) {
            return false;
        }
        //要求2：只能是数字
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if ( c <'0' || c > '9'){
                return false;
            }
        }
        //只有当字符串里面所有字符都比较完毕，才能返回true
        return true;
    }


    //书写方法对字符串内容进行转换
    public static String stringTrans(char number){
//        String str;
//        //利用Switch进行匹配
//       switch (number){
//           case '0':
//               str = "null";
//               break;
//           case '1':
//               str = "Ⅰ";
//               break;
//           case '2':
//               str = "Ⅱ";
//               break;
//           case '3':
//               str = "Ⅲ";
//               break;
//           case '4':
//               str = "Ⅳ";
//               break;
//           case '5':
//               str = "Ⅴ";
//               break;
//           case '6':
//               str = "Ⅵ";
//               break;
//           case '7':
//               str = "Ⅶ";
//               break;
//           case '8':
//               str = "Ⅷ";
//               break;
//           case '9':
//               str = "null";
//           default:
//               str = "null";
//       }

          //jdk12以后的switch新特性：
            String str = switch (number) {
                //switch开关表达式
                case '0' -> " ";
                case '1' -> "Ⅰ";
                case '2' -> "Ⅱ";
                case '3' -> "Ⅲ";
                case '4' -> "Ⅳ";
                case '5' -> "Ⅴ";
                case '6' -> "Ⅵ";
                case '7' -> "Ⅶ";
                case '8' -> "Ⅷ";
                case '9' -> "Ⅸ";
                default -> "null";
                };

       return str;
    }
}

package com._11_API_String;
/*
需求：
给定两个字符串A和B
A的旋转操作就是将A最左边的字符移动到最右边
例如：若A = “abcde”，在移动一次之后的结果就是“bcdea”
如果在若干次调整操作之后，A能变成B，那么返回true
如果不能匹配成功，则返回false
 */

//套路：
//如果遇到修改字符串
//1.使用sunString进行截取，把左边的字符截取出来拼接到右边
// 2.可以把字符串先变成一个字符数组，然年调整字符数组里面的数据，最后把字符数组变成字符串
//截取思路

public class Demo_22_StringCompareTest1 {
    public static void main(String[] args) {
        String str1 = "abcde";
        String str2 = "deabc";  //bcdea,cdeab
        //调用方法旋转第一次
        String s = roatate(str1);
        //调用方法，进行比较
        boolean flag = check(s,str2);
        System.out.println(flag);
    }

    //循环旋转并比较
    public static boolean check(String str1,String str2){
        for (int i = 0; i < str1.length(); i++) {
            str1 = roatate(str1);
            if (str1.equals(str2)){
                return true;
            }
        }
        //所有情况都比较完毕，还不一样
        return false;
    }

    //构造方法，将第一个字符移到末尾
    public static String roatate(String str){
        //获取第一个字符
        String first = str.substring(0,1);
        //char first = str.charAt(0);          //获取索引位0的元素并截取
        //获取剩余的字符
        String end = str.substring(1);
        //进行拼接
        str = end + first;
        return str;
    }
}

package com._11_API_String;

import java.util.Scanner;

public class Demo_23_StringCpmpare_Test2 {
    public static void main(String[] args) {
        String str1 = "abcde";
        String str2 = "cdeab";  //bcdea,cdeab
        //调用方法旋转第一次
        String s = retate(str1);
        //调用方法，进行比较
        boolean flag = check(s,str2);
        System.out.println(flag);
    }

    //循环旋转并比较
    public static boolean check(String str1,String str2){
        for (int i = 0; i < str1.length(); i++) {
            str1 = retate(str1);
            if (str1.equals(str2)){
                return true;
            }
        }
        //所有情况都比较完毕，还不一样
        return false;
    }
    //将字符先变成一个数组，然后调整字符里面数据，最后再把字符数组变成字符串
    public static String retate(String str){
        char []crr =str.toCharArray();
        //拿到0索引上的字符
        char first = crr[0];
        //把剩余的字符依次向前诺一个位置
        for (int i = 1; i < crr.length; i++) {
           crr[i-1] = crr[i];
        }
        //把原来0索引上的字符放到最后一个位置
        crr[crr.length-1] = first;
        String s = new String(crr);
        return s;

    }
}