黑马Java零基础视频教程精华部分_6_字符串

系列文章目录

---

---

前言

之前我们学习了面向对象的内容，现在需要学习如何使用别人写好的东西(类），以及学习字符串相关内容。

---

一、API是什么？ API帮助文档

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

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

例如以上代码所示，Random()就是别人写好的类，我们可以直接使用，不用自己编写。
Java API:指的就是JDK 中提供的各种功能的Java类，这些类我们不用都背过，想使用的时候，查询API帮助文档即可。
API帮助文档百度网盘链接提取码：zd3t

案例：API文档练习

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

Step1：查找文档中Scanner内容。

输入Scanne后回车。

选择第一个后，点击显示。如下图所示

Step2：学习文档中Scanner内容。

根据其构造方法摘要和方法摘要进行使用。如下图所示，Scanner没有空参构造方法。我们之前输入的system.in是第三种的参数。

二、字符串String类

1、String概述

java.lang.String 类代表字符串，Java 程序中的所有字符串文字(例如“abc”)都为此类的对象。
字符串的内容是不会发生改变的，它的对象在创建后不能被更改。
以下代码一共产生了3个字符串，因为name+schoolName会产生一个新的字符串。

String name ="尼古拉斯·阿玮";String schoolName ="黑马程序员";System.out.println(name +schoolName);

总结：

1.Strin是Java定义好的一个类。定义在java.lang 包中所以使用的时候不需要导包。
2.Java 程序中的所有字符串文字(例如“abcdefg”)。都被实为此类的对象，
3.字符串不可变，它们的值在创建后不能被更改。

创建String对象的两种方式

1. 直接赋值法：String name ="尼古拉斯·阿玮";
2. 使用new来调用构造函数创建String对象：如下图所示。
   
   

2、Java针对String的内存分析

（1）首先要了解Java的内存模型，如下图所示，其中字节码文件就是.class文件。但在处理String时，有一个新的部分叫做StringTable(串池），new出来的字符串放在堆中，而直接赋值的放在串池中。JDK7之前，串池在方法去中，之后在堆内存中，运行机制不变。

串池运行机制：运行代码如下所示：

public class stringDemo {public static void main(string[] args){
	String s1 ="abc";
	String s2 ="abc";
}

示意图如下所示：

首先方法入栈，然后执行第一行代码String s1 ="abc";因为要使用String，而串池中没有字符串abc，所以在串池中新建“abc”并用s1来保存这个地址，执行第二行代码的时候，发现有相同的字符串“abc"在串池中，所以不需要新建字符串，只需把存在的abc的地址赋值给s2即可。

总结：当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在，不存在需要创建新的；存在直接复用，节约内存。

（2）使用new时的情况如下所示：s1和s2保存不同的地址

public class Test {
public static void main(string[] args){
	char[] chs = {'a','b','c'};
	String sl=new string(chs);
	String s2 =new string(chs);
}

3、Java的常用方法（比较）

（1）==号比的到底是什么？

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

（2）字符串比较

1. boolean equals方法(要比较的字符串) 完全一样结果才是true，否则为false
2. boolean equalslgnorecase(要比较的字符串) 忽略大小写的比较

（3）一个小问题：我们通过Scanner获得的字符串abc是通过什么途径创建String对象来存储？答案：new。

package com.itheima.stringdemo;
import java.util.Scanner;
public class StringDemo3 {
    public static void main(String[] args) {
        //1.假设我现在键盘录入一个abc
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str1 = sc.next();//abc  是new出来的。
        //2.代码中再定义一个字符串abc
        String str2 = "abc";
        //3.用==比较，这两者能一样吗？
        System.out.println(str1 == str2);//false

        //结论:
        //以后只要想比较字符串的内容，就必须要用String里面的方法
    }
}

三、字符串练习

1、用户登录

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

public class StringDemo4 {
    public static void main(String[] args) {
        //读题拆解法

        //1.定义两个变量记录正确的用户名和密码
        String rightUsername = "zhangsan";
        String rightPassword = "123456";


        Scanner sc = new Scanner(System.in);
        //2.键盘录入用户名和密码
        for (int i = 0; i < 3; i++) {// 0 1 2
            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 + "被锁定，请联系黑马程序员官方客服小姐姐:XXX-XXXXX");
                }else{
                    System.out.println("用户登录失败，用户名或密码有误,您还剩下" + (2 - i) + "次机会");//2 1 0
                }
            }
        }

    }
}

2、遍历字符串

要求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串。代码如下：

public class StringDemo5 {
    public static void main(String[] args) {
        //1.键盘录入一个字符串
        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);
        }
    }
}

3、字符串反转

要求：定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果例如，键盘录入 abc，输出结果 cba
代码如下：

public static void main(String[] args) {
        String result = reverser("abc");
        System.out.println(result);
    }
    //1.我要干嘛？  --- 字符串的反转
    //2.我干这件事情，需要什么才能完成？  --- 需要一个字符串
    //3.调用处是否需要继续使用方法的结果呢？ ---需要结果进行输出
    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;
    }

4、统计字符次数

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

public static void main(String[] args) {
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();
        //2.统计--- 计数器思想
        //定义三个计数器
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        for (int i = 0; i < str.length(); i++) {
            //i 依次表示字符串中的每一个索引
            char c = str.charAt(i);
            if(c >= 'a' && c <= 'z'){
                //char类型的变量在参与计算的时候自动类型提升为int 查询ascii码表
                smallCount++;
            }else if(c >= 'A' && c <= 'Z'){
                bigCount++;
            }else if(c >= '0' && c <= '9'){
                numberCount++;
            }
        }

        //3.输出打印
        System.out.println("小写字母有：" + smallCount + "个");
        System.out.println("大写字母有：" + bigCount + "个");
        System.out.println("数字字母有：" + numberCount + "个");
    }

4、字符串拼接

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

public static void main(String[] args) {
        int[] arr = {1,2,3};

        String str = arrToString(arr);
        System.out.println(str);//[123
    }
    //1.我要干嘛？ --- 遍历数组并把数组拼接成一个字符串
    //2.我干这件事情需要什么才能完成？ --- 数组
    //3.我干完了是否要把结果返回给调用处 --- 返回一个拼接之后的字符串
    //如果调用处需要继续使用，那么必须返回
    //如果调用处不需要继续使用，那么可以返回也可以不返回
    public static String arrToString(int[] arr){
        if(arr == null){
            return "";
        }

        if(arr.length == 0){
            return "[]";
        }
        String result = "[";
        //当代码执行到这里表示什么？
        //表示数组不是null，也不是长度为0的
        for (int i = 0; i < arr.length; i++) {
            //i 索引  arr[i] 元素
            if(i == arr.length - 1){
                result = result + arr[i];
            }else{
                result = result + arr[i] + ", ";
            }
        }
        //此时拼接右括号
        result = result + "]";
        return result;
    }

5、金额转换

2135转换为零佰零拾零万贰仟壹佰叁拾伍元
代码如下：

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];
    }

}

6、手机号屏蔽

例如：13112349468 转换为 131****9468。
代码如下：

public static void main(String[] args) {
        //1.获取一个手机号码
        String phoneNumber = "13112349468";

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

        //3.截取手机号码后面四位
        String end = phoneNumber.substring(7);

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

        //5.打印
        System.out.println(result);


    }

7、身份证信息查看

根据身份证号算出公民生日和性别。
代码如下：

package com.itheima.stringdemo;

public class StringDemo11 {
    public static void main(String[] args) {
        //1.定义一个字符串记录身份证号码
        String id = "321281202001011234";

        //2.获取出生年月日
        String year = id.substring(6, 10);
        String month = id.substring(10, 12);
        String day = id.substring(12, 14);
        System.out.println("人物信息为：");
        System.out.println("出生年月日:" + year + "年" + month + "月" + day + "日");
        //3.获取性别
        char gender = id.charAt(16);//'3'  ---> 3
        //利用ASCII码表进行转换
        //'0' --->  48
        //'1' --->  49
        //'2' --->  50
        //'3' --->  51
        //'4' --->  52
        //'5' --->  53
        //'6' --->  54
        //'7' --->  55
        //'8' --->  56
        //'9' --->  57

        int num = gender - 48;//字符转成数字
        if(num % 2 == 0){
            System.out.println("性别为:女");
        }else{
            System.out.println("性别为:男");
        }
    }
}

8、敏感词替换

代码如下：

public static void main(String[] args) {
        //1.获取到说的话
        String talk = "你玩的真好，以后不要再玩了，TMD,CNM";

        //2.定义一个敏感词库
        String[] arr = {"TMD","CNM","SB","MLGB"};

        //3.循环得到数组中的每一个敏感词，依次进行替换
        for (int i = 0; i < arr.length; i++) {
            talk = talk.replace(arr[i], "***");
        }
        //4.打印结果
        System.out.println(talk);
    }

四、字符串StringBuilder类

1、为什么学习StringBuilder类？

比较如下两个代码的运行速度即可：

public static void main(String[] args) {
        String s = "";
        for (int i = 0; i < 100; i++) {
            s = s + "abc";
        }
        System.out.println(s);
    }

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

        for (int i = 0; i < 1000000; i++) {
            sb.append("abc");
        }

        System.out.println(sb);
    }

2、StringBuilder概述

StringBuilder 可以看成是一个容器，创建之后里面的内容是可变的。作用:提高字符串的操作效率。
解释：之前的字符串拼接是每两个拼接后产生一个新的再去拼接后面的字符串，现在是把所有需要拼接的字符串都放到一个容器里，一起拼接起来。

3、StringBuilder的构造方法

4、StringBuilder的常用方法

5、注意：

因为StringBuilder是Java已经写好的类，java在底层对他做了一些特殊处理，打印对象不是地址值而是添加到StringBuilder中的属性值。

6、链式编程

当我们在调用一个方法的时候，不需要用变量接收他的结果，可以继续调用其他方法。
示例代码如下：

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;
}

7、应用：判断是否是对称字符串

代码如下 ：

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("当前字符串不是对称字符串");
        }
    }
}

8、应用：拼接字符串

需求:定义一个方法，把 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();
    }
}

五、字符串StringJoiner类

1、为什么使用StringJoiner？

之前的代码太复杂，使用StringJoiner简化，如下图所示：

2、StringJoiner概述

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

3、StringJoiner构造方法

如下图所示：其中间的元素通过add()方法添加。

3、StringJoiner的成员方法

4、示例代码

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
    }
}

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]
    }
}

五、字符串原理

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

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

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

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

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

1、拼接时等号右边没有变量

所以其实与直接赋值”abc"是相同的。

2、拼接时等号右边存在变量

总结

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

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

每个append会把后面的"a",“b”,"c"分别添加到相同地址的蓝色框中，所以仅有一个StringBuilder对象，不像原理三一个main方法会创建多个StringBuilder对象。

总结

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

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

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

六、综合联系

1、字符串转换为罗马数字

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

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) {
        String str = switch (number) {
            case '0' -> "";
            case '1' -> "Ⅰ";
            case '2' -> "Ⅱ";
            case '3' -> "Ⅲ";
            case '4' -> "Ⅳ";
            case '5' -> "Ⅴ";
            case '6' -> "Ⅵ";
            case '7' -> "Ⅶ";
            case '8' -> "Ⅷ";
            case '9' -> "Ⅸ";
            default -> str = "";
        };
        return str;
    }


    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;
    }


}

2、调整字符串

给定两个字符串, 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;
    }
}