• 12-JavaSE基础巩固练习：字符串练习

    字符串练习

    一、简单字符串练习

    1、用户登录

    • 需求：

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

    • 分析：

      • 需要一个用户类，属性是用户名、密码。
      • 需要一个数组，用于存储已知用户名和密码。
      • 需要实现用户登录的功能。

    • 实现：

      package com.app.demo21_string_test;

import java.util.Scanner;

/*
    需要一个用户类，属性是用户名、密码。
 */
class User {
    private String userName;
    private String password;

    public User() {
    }

    public User(String userName, String password) {
        this.userName = userName;
        this.password = password;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}


/*
    测试类
        字符串练习：用户登录
        需求：
            已知正确的用户名和密码，请用程序实现模拟用户登录。
            总共给三次机会，登录之后，给出相应的提示。
*/
public class StringDemo1 {
    public static void main(String[] args) {
        // 需要一个数组，用于存储已知用户名和密码。
        User[] users = new User[3];
        // 存储已知用户名和密码
        users[0] = new User("admin", "abcABC123");

        // 需要实现用户登录的功能。
        userLogin(users);
    }


    /**
     * 用户登录功能
     *
     * @param users 用户对象数组
     */
    public static void userLogin(User[] users) {
        System.out.println("------用户登录界面------");

        // for循环3次：三次机会
        for (int i = 0; i < 3; i++) {   // 0 1 2
            // 1、创建键盘录入对象，用于录入用户名和密码
            Scanner scanner = new Scanner(System.in);
            System.out.println("请您输入用户名：");
            String inputUserName = scanner.next();
            System.out.println("请您输入密码：");
            String inputPassword = scanner.next();

            // 2、判断用户名、密码是否正确
            // 判断用户名、密码是否存在用户对象数组中
            boolean flag = containsUserNameAndPassword(users, inputUserName, inputPassword);
            if (flag) {
                System.out.println("登录成功~ ^_^");
                break;  // 登录成功，跳出循环
            } else {
                // 当i是否等于2
                if (i == 2) {
                    // 是，则说明用户已没有机会，锁定账户
                    System.out.println("您的账户已被锁定！请联系Java官方客户小姐姐电话：XXXX-XXXXXX~");
                } else {
                    // 不是，则说明用户还有机会
                    // 第一次错误：2-i == 2-0 = 2
                    // 第二次错误：2-i == 2-1 = 1
                    System.out.println("您输入的用户名或密码有误！还有" + (2 - i) + "次机会~");   //
                }
            }
        }
    }


    /**
     * 判断用户名是否正确
     *
     * @param users         用户对象数组
     * @param inputUserName 用户名
     * @param inputPassword 密码
     * @return 正确返回true，不正确返回false
     */
    public static boolean containsUserNameAndPassword(User[] users, String inputUserName, String inputPassword) {
        // 1、遍历用户对象数组，依次获取每个用户对象
        for (int i = 0; i < users.length; i++) {
            // 每获取到一个用户对象，接收一下
            User user = users[i];
            // 当该用户对象不为null时
            if (user != null) {
                // 得到该用户的用户名和密码
                String userName = users[i].getUserName();
                String password = users[i].getPassword();

                // 判断输入的用户名和密码 与 该用户名和密码是否匹配
                if (inputUserName.equals(userName) && inputPassword.equals(password)) {
                    // 用户名和密码都匹配正确，返回true
                    return true;
                }
            }
        }

        // 2、遍历结束，输入的用户名和密码 与 所有用户对象的用户名和密码 都不匹配，返回false
        return false;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111
      • 112
      • 113
      • 114
      • 115
      • 116
      • 117
      • 118
      • 119
      • 120
      • 121
      • 122
      • 123
      • 124
      • 125
      • 126

      • 测试结果：

        ------用户登录界面------
请您输入用户名：
admin
请您输入密码：
123
您输入的用户名或密码有误！还有2次机会~
请您输入用户名：
avc123
请您输入密码：
admin
您输入的用户名或密码有误！还有1次机会~
请您输入用户名：
admin
请您输入密码：
sdf
您的账户已被锁定！请联系Java官方小姐姐电话：XXXX-XXXXXX~

Process finished with exit code 0


        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        ------用户登录界面------
请您输入用户名：
admin
请您输入密码：
abcABC123
登录成功~ ^_^

Process finished with exit code 0


        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        ------用户登录界面------
请您输入用户名：
admin
请您输入密码：
123
您输入的用户名或密码有误！还有2次机会~
请您输入用户名：
admin
请您输入密码：
123123
您输入的用户名或密码有误！还有1次机会~
请您输入用户名：
admin
请您输入密码：
abcABC123
登录成功~ ^_^

Process finished with exit code 0


        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
    2、遍历字符串

    • 需求：

      • 键盘录入一个字符串，使用程序实现在控制台遍历该字符串。

    • 分析：

      • 需要一个for循环，遍历该字符串依次输出到控制台。

    • 实现：

      package com.app.demo21_string_test;

import java.util.Scanner;

/*
    字符串练习：遍历字符串
        需求：
            键盘录入一个字符串，使用程序实现在控制台遍历该字符串。
 */
public class StringDemo2 {
    public static void main(String[] args) {
        // 1、从键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入一句想说的话：");
        String str = sc.nextLine();

        // 2、遍历字符串，依次得到每个字符，并打印在控制台，用空格隔开
        // str.length(): 表示字符串的长度
        for (int i = 0; i < str.length(); i++) {
            // i: 表示每个字符的索引
            // str.charAt(i): 表示依次字符串的每个字符
            System.out.print(str.charAt(i) + " ");
        }
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      请您输入一句想说的话：
我爱中国，就像老鼠爱大米！！ 哎呀
我 爱 中 国 ， 就 像 老 鼠 爱 大 米 ！ ！   哎 呀 
Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
    3、统计字符次数

    • 需求：

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

    • 分析：

      • 需要从键盘录入一个字符串
      • 需要定义三个计数器，分别用于统计大写、小写字母、数字的个数
      • 需要循环遍历，依次得到字符串的每个字符
      • 需要对每个字符进行判断，是大写字母、还是小写字母、还是数字

    • 实现：

      package com.app.demo21_string_test;

import java.util.Scanner;

/*
    字符串练习：统计字符次数
        需求：
            键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数（不考虑其他字符）
 */
public class StringDemo3 {
    public static void main(String[] args) {
        // 1、需要从键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入一句想说的话：");
        String str = sc.nextLine();

        // 2、需要定义三个计数器，分别用于统计大写、小写字母、数字的个数
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        // 3、需要循环遍历，依次得到字符串的每个字符
        for (int i = 0; i < str.length(); i++) {
            // 每得到一个字符，接收一下
            char ch = str.charAt(i);

            // 4、需要对每个字符进行判断，是大写字母、还是小写字母、还是数字
            // 判断这个字符是否为大写字母：A~Z(26个)
            // char类型的变量在参与计算的时候自动类型提升为int——>查询ASCII码表
            if (ch >= 'A' && ch <= 'Z') {
                // 是，则统计大写字母字符出现的次数
                bigCount++;
            } else if (ch >= 'a' && ch <= 'z') {    // 判断这个字符是否为小写字母：a~z(26个)
                // 是，则统计小写字母字母出现的次数
                smallCount++;
            } else if (ch >= '0' && ch <= '9'){     // 判断这个字符是否为数字：0~9
                // 是，则统计数字字符出现的次数
                numberCount++;
            }
        }

        System.out.println("这句话中，大写字母有：" + bigCount + "个。");
        System.out.println("这句话中，小写字母有：" + smallCount + "个。");
        System.out.println("这句话中，数字有：" + numberCount + "个。");
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      请您输入一句想说的话：
我爱中国，让我们一起大喊：“1 2 3 伟大中国 A b C Me就是这么强！”
这句话中，大写字母有：3个。
这句话中，小写字母有：2个。
这句话中，数字有：3个。

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
    4、拼接字符串

    • 需求：

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

    • 分析：

      • 需要一个int类型的数组，初始化一些数据。
      • 需要实现按照指定的格式拼接一个字符串返回的功能。
      • 需要调用该方法，在控制台输出结果。

    • 实现：

      package com.app.demo21_string_test;

/*
    字符串练习：拼接字符串
        需求：
            定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。
            例如：
              数组为: int[] arr = {1, 2, 3};
              执行方法后的输出结果为: [1, 2, 3]
 */
public class StringDemo4 {
    public static void main(String[] args) {
        // 1、需要一个int类型的数组，初始化一些数据。
        int[] number = {10, 2, 30, 66};

        // 2、需要实现按照指定的格式拼接一个字符串返回的功能。
        String str = arrayToString(number);

        // 3、需要调用该方法，在控制台输出结果。
        System.out.println(str);
    }


    /**
     * 实现把数组中的数据拼接成一个字符串的功能
     *
     * @param arr       数组
     * @return          返回拼接好的字符串
     */
    public static String arrayToString(int[] arr) {
        // 1、判断arr是否为null
        if (arr == null) {
            return "";
        }

        // 2、判断数组的长度是否为0
        if (arr.length == 0) {
            // 为0：表示数组没有元素
            return "[]";
        }

        // 3、定义一个空字符串变量，用于拼接字符串
        String str = "[";

        // 4、遍历数组，依次获取每个数据
        for (int i = 0; i < arr.length; i++) {
            // 如果该数据是最后一个，那就拼接一个右括号
            // 如果该数据不是最后一个，那就拼接一个逗号
            str += (i == arr.length-1 ? arr[i] + "]" : arr[i] + ", ");
        }
        // 4、遍历结束，拼接完成，返回最终结果
        return str;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      [10, 2, 30, 66]

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
    5、字符串反转

    • 需求：

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

    • 分析：

      • 需要从键盘录入一个字符串。
      • 需要实现将字符串反转的功能。
      • 需要调用该方法后，在控制台输出结果。

    • 实现：

      package com.app.demo21_string_test;

import java.util.Scanner;

/*
    字符串练习：字符串反转
        需求：
            定义一个方法，实现字符串反转。
            键盘录入一个字符串，调用该方法后，在控制台输出结果。
            例如：
              键盘录入 abc
              输出结果 cba
 */
public class StringDemo5 {
    public static void main(String[] args) {
        // 1、需要从键盘录入一个字符串。
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入一句想说的话：");
        String str = sc.nextLine();

        // 2、需要实现将字符串反转的功能。
        String result = reverseString(str);

        // 3、需要调用该方法后，在控制台输出结果。
        System.out.println("字符串反转后：" + result);
    }


    /**
     * 实现将字符串反转的功能
     * @param str       字符串
     * @return          返回反转后的字符串
     */
    public static String reverseString(String str) {
        // 1、判断str是否为null 或 是否长度为0
        if (str == null || str.length() == 0) {
            return "";
        }

        // 2、定义空字符串变量，用于存储反转后的字符串
        String result = "";

        // 3、反着遍历字符串，从后往前依次获取每个字符
        // str.length() - 1: 表示最后一个字符
        for (int i = str.length() - 1; i >= 0; i--) {
            // i: 依次表示字符串中的每个索引（倒着的）
            // 每得到一个字符，就拼接起来
            result += str.charAt(i);
        }

        // 4、遍历结束，说明字符串反转完成，返回反转后的结果
        return result;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      请您输入一句想说的话：
ABC 我爱中国，就像中国爱我一样！！
字符串反转后：！！样一我爱国中像就，国中爱我 CBA

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
    6、金额转换

    • 需求：

      • 将阿拉伯数字的金额转换成中文大写的金额。

      在这里插入图片描述

    • 分析：

      • 先用逆推法，得到从中文大写的金额 转换成 阿拉伯数字的金额的思路：

        在这里插入图片描述

      • 自然而然就得到了解题的思路：

        在这里插入图片描述

      • 使用查表法来实现：

        在这里插入图片描述

      在这里插入图片描述

    • 实现：

      package com.app.demo21_string_test;

import java.util.Scanner;

/*
    字符串练习：金额转换
        需求：
            从键盘录入一个阿拉伯数字的金额，要求是整数 并且 是7位；
            将这个数字的金额 转换成 中文大写的金额。
 */
public class StringDemo6 {
    public static void main(String[] args) {
        try {
            // 1、从键盘录入一个数字金额
            int money = inputMoney();
            System.out.println("金额为：" + money);

            // 2、根据输入的阿拉伯数字金额 转换成 中文大写金额
            String amountWords = getAmountWords(money);
            System.out.println("转换数字为大写后：" + amountWords);

            // 3、根据判断金额数字的个数，在前面补 "零"
            // 定义计数器变量，用于记录金额数字的个数
        /*
            解析：比如输入的是2135，那么个数就是4，
                 7 - 4 = 3，那么就遍历3次，在金额前面补三个 零
         */
            int count = 7 - amountWords.length();
            for (int i = 0; i < count; i++) {
                amountWords = "零" + amountWords;
            }
            System.out.println("空位补零后：" + amountWords);

            // 4、在每个大写数字后面插入金额单位
            amountWords = insertAmountUnit(amountWords);
            System.out.println("插入金额单位后：" + amountWords);
        } catch (Exception e) {	// 捕获异常
            System.out.println("金额数据有误！");
        }
    }


    /**
     * 在每个大写数字后面插入金额单位
     *
     * @param amountWords 大写金额
     * @return 返回有金额单位的大写金额
     */
    public static String insertAmountUnit(String amountWords) {
        // 1、判断字符串是否为 ""
        if (amountWords == null) {
            return "";
        }

        // 2、定义金额单位数组
        String[] units = {"佰", "拾", "万", "仟", "佰", "拾", "元"};
        //  索引            0     1    2     3    4     5     6

        // 3、定义空字符串变量，用于将大写数字 与 金额单位进行拼接
        String result = "";

        // 4、遍历大写金额，依次获取每个大写数字
        for (int i = 0; i < amountWords.length(); i++) {
            // 每遍历到一个大写数字，接收一下
            char capitalNumber = amountWords.charAt(i);
            // 每遍历到一个大写数字，就拼接一个金额单位
            result = result + capitalNumber + units[i];
        }

        // 5、遍历结束，拼接完成，返回最终大写金额
        return result;
    }


    /**
     * 根据输入的阿拉伯数字金额 转换成 中文大写金额
     *
     * @param money 阿拉伯数字金额
     * @return 返回中文大写金额
     */
    public static String getAmountWords(int money) {
        // 1、定义空字符串变量，用于拼接转换后的中文大写金额
        String amountWords = "";
        while (money != 0) {    // 当money != 0时，循环继续；当money == 0时，循环结束！
            // a.从右往左依次获取到金额的个位数
            /*
                解析：
                    假如输入的是 2135：
                        第一次获取个位数得到的是 5，
                        第二次获取个位数得到的是 3，
                        之后以此类推！
             */
            int ge = money % 10;

            // b.每获取完一个个位数，就根据这个阿拉伯数字得到对应的中文大写数字
            String capitalNumber = getCapitalNumber(ge);

            // c.每得到一个中文大写数字，直接拼接
            /*
                解析：
                第一次循环：
                    当根据数字：5 得到对应的 大写："伍" 后，
                    "" = "伍" + "" ==> "伍"
                第二次循环："伍" = ""
                    当根据数字：3 得到对应的 大写："叁" 后，
                    "伍" = "叁" + "伍" ==> "叁伍";
                之后就以此类推！
             */
            amountWords = capitalNumber + amountWords;

            // d.去掉获取完的个位数，接着获取下一个 个位数
            /*
                解析：当获取完个位数 5 之后，用 2135 / 10 = 213(java的int类型直接取整)，
                下一次取到的个位数就是 3，以此类推！
             */
            money /= 10;
        }

        // 2、循环结束，拼接结束，返回转换后的大写金额
        return amountWords;
    }


    /**
     * 根据单个阿拉伯数字获取对应的中文大写数字
     *
     * @param number 阿拉伯数字
     * @return 返回中文大写金额
     */
    public static String getCapitalNumber(int number) {
        // 1、定义中文大写数字的数组
        String[] amountWords = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        // 索引                   0     1    2     3     4    5     6    7     8     9

        // 2、返回阿拉伯数字对应的中文大写数字
        return amountWords[number];
    }


    /**
     * 从键盘录入一个数字金额
     *
     * @return 返回录入的数字金额
     */
    public static int inputMoney() {
        // 1、定义变量，用于接收一个数字金额
        int money;

        // 2、创建键盘录入对象，用于录入数字金额
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入一个金额(阿拉伯数字)：");
            money = sc.nextInt();

            // 3、判断这个数字是否 大于等于0 并且 小于等于7位
            if (money >= 0 && money <= 9999999) {
                // 是，则跳出循环
                break;
            } else {
                // 不是，则提示，并让用户重新输入金额
                System.out.println("金额无效！");
            }
        }

        // 3、循环结束，说明金额在有效范围！返回金额
        return money;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111
      • 112
      • 113
      • 114
      • 115
      • 116
      • 117
      • 118
      • 119
      • 120
      • 121
      • 122
      • 123
      • 124
      • 125
      • 126
      • 127
      • 128
      • 129
      • 130
      • 131
      • 132
      • 133
      • 134
      • 135
      • 136
      • 137
      • 138
      • 139
      • 140
      • 141
      • 142
      • 143
      • 144
      • 145
      • 146
      • 147
      • 148
      • 149
      • 150
      • 151
      • 152
      • 153
      • 154
      • 155
      • 156
      • 157
      • 158
      • 159
      • 160
      • 161
      • 162
      • 163
      • 164
      • 165
      • 166
      • 167
      • 168
      请您输入一个金额(阿拉伯数字)：
2135
金额为：2135
转换数字为大写后：贰壹叁伍
空位补零后：零零零贰壹叁伍
插入金额单位后：零佰零拾零万贰仟壹佰叁拾伍元

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      请您输入一个金额(阿拉伯数字)：
-11
金额无效！
请您输入一个金额(阿拉伯数字)：
99999990
金额无效！
请您输入一个金额(阿拉伯数字)：
9999999
金额为：9999999
转换数字为大写后：玖玖玖玖玖玖玖
空位补零后：玖玖玖玖玖玖玖
插入金额单位后：玖佰玖拾玖万玖仟玖佰玖拾玖元

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      请您输入一个金额(阿拉伯数字)：
sdfs地红烧冬瓜 、。，，&&88、
金额数据有误！

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
    7、手机号屏蔽

    • 需求：

      • 原手机号：13112349468

      • 屏蔽后：

        131****9468

        • 1

        在这里插入图片描述

    • 分析：

      • 使用String类的方法(API)：substring(int beginIndex, int endIndex)：
        • 截取前三位
        • 作用：从开始索引截取到结束索引。
        • 注意点：包头不包尾，包左不包右。
      • 使用String类的方法(API)：substring(int beginIndex)：
        • 截取后四位
        • 作用：截取到末尾
      • 最后使用前三位 + 四个"*" + 后四位。

    • 实现：

      package com.app.demo21_string_test;

import java.util.Scanner;

/*
    字符串练习：屏蔽手机号
        需求：
            原手机号码：13112349468
            屏蔽后的手机号：131****9468
 */
public class StringDemo7 {
    public static void main(String[] args) {
        // 1、从键盘录入一个手机号并进行中间四位的屏蔽操作
        String phoneNumber = getBlockPhoneNumber();
        System.out.println("屏蔽后的手机号码是：" + phoneNumber);
    }


    /**
     * 获取屏蔽后的手机号码
     *
     * @return      返回屏蔽后的手机号码
     */
    public static String getBlockPhoneNumber() {
        // 1、创建键盘录入对象，用于从键盘录入手机号码
        Scanner sc = new Scanner(System.in);

        // 2、定义空字符串变量，用于记录屏蔽后的手机号码
        String result = "";

        while (true) {
            // 3、从键盘录入一个手机号码
            System.out.println("请您输入您的手机号码(11位)：");
            String phoneNumber = sc.next();
            System.out.println("您输入的手机号码是：" + phoneNumber);

            // 4、判断手机号码是否为 11位 并且 手机号码是否不为0开头
            if (phoneNumber.length() == 11 && phoneNumber.charAt(0) != 0) {
                // 5、获取手机号码的前三位
                String start = phoneNumber.substring(0, 3);
                String end = phoneNumber.substring(7);
                // 6、将手机号的前三位 + **** + 后四位，完成屏蔽操作
                result = result + start + "****" + end;
                // 7、屏蔽完成，跳出循环
                break;
            }else {
                System.out.println("您输入的手机号码是无效的！");
            }
        }

        // 8、循环结束，屏蔽完成，返回屏蔽后的手机号码
        return result;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      请您输入您的手机号码(11位)：
181993322333
手机号码是11位的！
请您输入您的手机号码(11位)：
13112349648
您输入的手机号码是：13112349648
屏蔽后的手机号码是：131****9648

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
    8、身份证信息查看

    在这里插入图片描述

    • 身份证号规则：

      • 1、2位：省份
      • 3、4位：城市
      • 5、6位：区县
      • 7~14位：出生年、月、日
      • 15、16位：所在地派出所
      • 17位：性别（奇数男性，偶数女性）
      • 18位：个人信息码（随机产生）

    • 需求：

      • 用户从键盘录入身份证号，从中获取到他的个人信息：
        • 出生年月日：XXXX年X月X日
        • 性别为：男/女

    • 分析：

      • 需要接收用户录入的身份证号（18位）。
      • 需要截取年份部分：7~11位。
      • 需要截取月份部分：11~13位。
      • 需要截取日部分：13~15位。
      • 需要将年份、月份、日，拼接成年月日信息。
      • 需要截取性别部分：17位
        • 判断该数是奇数还是偶数：
          • 是奇数，则性别为男；
          • 否则，性别为女。

    • 实现：

      package com.app.demo21_string_test;

import java.util.Scanner;

/*
    字符串练习：身份证信息查看
        需求：
            用户从键盘录入身份证号，从中获取他的出生年月日、性别信息
 */
public class StringDemo8 {
    public static void main(String[] args) {
        // 1、从身份证号中获取个人信息
        String info = getByIdInfo();
        System.out.println("个人信息：\n" + info);
    }

    /**
     * 从身份证号中获取个人信息
     *
     * @return      返回获取到的个人信息
     */
    public static String getByIdInfo() {
        // 1、定义空字符串变量，用于记录获取到的个人信息
        String info = "";

        // 2、创建键盘录入对象，用于从键盘录入身份证号码
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入您的身份证号码(18位)：");
            String id = sc.next();

            // 3、判断录入的身份证号码是否为18位
            if (id.length() == 18) {
                // 是
                // a.截取年份信息
                String year = id.substring(6, 10);
                // b.截取月份信息
                String month = id.substring(10, 12);
                // c.截取日信息
                String day = id.substring(12, 14);

                // d.方式一：截取性别信息，并转换为int类型
//                int gender = Integer.valueOf(id.substring(16, 17));

                // 方式二：截取性别信息，并利用ASCII码表将字符转换为int类型
                char gender = id.charAt(16);
                /*
                    思路解析：
                    ASCII码表：
                        1、字符 '0~9' 对应的码分别是：48、49、50、51、52、53、54、55、56、57
                        2、假如截取到的第16位的字符是 '8'：
                            使用字符 '8' 对应的码 56 减去 字符 '0' 对应的码 48：56 - 48 = 8;
                        3、假如截取到的第16位的字符是 '3'：
                            使用字符 '3' 对应的码 51 减去 字符 '0' 对应的码 48：51 - 48 = 3;
                 */
                // 此时gender表示：'0~9'的某个字符
                int num = gender - 48;

                // 定义空变量，用于记录性别信息
                String newGender = "";
                // 判断奇偶性
                if (num % 2 == 1) {
                    // 是奇数，则性别为男
                    newGender = "男";
                }else {
                    // 是偶数，则性别为女
                    newGender = "女";
                }

                // e.拼接所有获取到的个人信息
                info = info + "出生年月日：" + year + "年" + month + "月" + day + "日" + "\n"
                        + "性别为：" + newGender;

                // f.拼接完成，跳出循环
                break;
            }else {
                // 不是
                System.out.println("该身份证号码不存在！");
            }
        }

        // 3、返回获取到的个人信息
        return info;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      请您输入您的身份证号码(18位)：
450111197205054878
个人信息：
出生年月日：1972年05月05日
性别为：男

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      请您输入您的身份证号码(18位)：
4501122004122398785
该身份证号码不存在！
请您输入您的身份证号码(18位)：
450112200412239848
个人信息：
出生年月日：2004年12月23日
性别为：女

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
    9、敏感词替换

    • 替换前：

      在这里插入图片描述

    • 替换后：

      在这里插入图片描述

    • 需求：

      • 从键盘录入一句想说的话，对一些敏感词进行替换操作。

    • 分析：

      • 需要接收游戏玩家输入的话（字符串）。
      • 需要定义一个敏感词数组，用于存储一些常用敏感词。
      • 需要依次得到玩家输入的每个字符。
      • 需要将玩家输入的每个字符 与 敏感词数组中的每个字符进行比较：
        • 相等，说明该玩家某个字符是敏感字符，将替换成 “*” 符号后输出。
          • 需要使用到String类的方法(API)：replace(旧值, 新值)，进行替换。
        • 不相等，说明该玩家发言正常，正常输出。

    • 实现：

      package com.app.demo21_string_test;

import java.util.Scanner;

/*
    字符串练习：敏感词替换
        需求：
            玩家输入一句想说的话，如果有敏感词就替换成 “*”
            例如：
                替换前：我TMD你妈个
                替换后：我*****个
 */
public class StringDemo9 {
    public static void main(String[] args) {
        // 1、玩家输入想说的话
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入一句想说的话：");
        String text = sc.nextLine();

        // 2、对玩家说的话进行敏感词替换
        String newText = wordsReplace(text);
        System.out.println(newText);
    }

    /**
     * 敏感词替换
     *
     * @param text 字符串
     * @return 返回替换后的字符串
     */
    public static String wordsReplace(String text) {
        // 1、判断text是否为null
        if (text == null) {
            return "";
        }

        // 2、定义敏感词库，存储一些常用的敏感词
        String[] arr = {"TMD", "CNM", "你妈", "你是狗"};

        // 3、遍历敏感词库，依次获取每个敏感词
        for (int i = 0; i < arr.length; i++) {
            // 每获取到一个敏感词，接收一下
            String str = arr[i];

            // 如果玩家输入的文本中有出现该敏感词，就替换成 ***
            text = text.replace(str, "***");
        }

        return text;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      请您输入一句想说的话：
你玩得真的太菜了！TMD，CNM，你是狗吗？你妈的
你玩得真的太菜了！***，***，***吗？***的

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6

    二、较难字符串练习

    1、转换罗马数字

    • 需求：

      • 从键盘录入一个字符串。
      • 要求：
        • 1、长度为小于等于9
        • 2、只能是数字
        • 3、将内容变成罗马数字
      • 下面是阿拉伯数字和罗马数字的对比关系：
        • I - 1、II - 2、III - 3、IV - 4、V - 5、VI - 6、VII - 7、VIII - 8、IX - 9
      • 注意点：
        • 1、罗马数字里面是没有0的
        • 2、如果键盘录入的数字包含0，可以变成 “”(长度为0的字符串)

    • 分析：

      • 需要从键盘录入一个字符串。
      • 需要对这个字符串进行校验：
        • 1、长度为小于等于9
        • 2、只能是数字
        • 如果不满足以上条件，就重新录入字符串，直到符合条件才能进一步操作。
      • 需要依次获取字符串的每个字符：
        • 根据获取到的阿拉伯数字字符得到对应的罗马数字：
          • 查表法方式：
            • 利用ASCII码表的规律来将获取到的字符转换为int类型
            • 然后根据转换后的阿拉伯数字获取对应的罗马数字
          • switch匹配方式：
            • 利用switch直接匹配
      • 需要将转换后的数字输出到控制台

    • 实现：

      package com.app.demo21_string_test;

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

/*
    字符串练习：转换罗马数字
        需求：
            从键盘录入一个字符串。
            要求：
                1、长度为小于等于9
                2、只能是数字
                3、将内容变成罗马数字
            下面是阿拉伯数字和罗马数字的对比关系：
                I - 1、II - 2、III - 3、IV - 4、V - 5、VI - 6、VII - 7、VIII - 8、IX - 9
            注意点：
                1、罗马数字里面是没有0的
                2、如果键盘录入的数字包含0，可以变成 ""(长度为0的字符串)
 */
public class StringDemo10 {
    public static void main(String[] args) {
        // 1、从键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        String numbers; // 定义变量接收输入的字符串
        while (true) {
            System.out.println("请您输入一串阿拉伯数字：");
            numbers = sc.next();

            // 2、检验数字字符串是否符合要求
            boolean flag = checkNumbers(numbers);
            if (flag) {
                // 符合条件，校验通过，跳出循环
                break;
            } else {
                // 不符合条件
                System.out.println("您输入的字符串不符合条件~ 请重新输入！");
            }
        }

        // 2、校验通过后
        // 查表法方式：利用ASCII码表根据字符串的每个阿拉伯数字字符 获取相应的 罗马数字字符串
        StringJoiner asciiLuoMaNumbers = getASCIILuoMaNumbers(numbers);
        System.out.println(asciiLuoMaNumbers);

        System.out.println("------------------------------------");

        // switch匹配方式：根据字符串的每个阿拉伯数字字符 获取相应的 罗马数字字符串
        StringJoiner luoMaNumbers = getLuoMaNumbers(numbers);
        System.out.println(luoMaNumbers);
    }


    /**
     * switch匹配方式：根据字符串的每个阿拉伯数字字符获取相应的罗马数字字符串
     *
     * @param numbers   阿拉伯数字字符串
     * @return          返回罗马数字字符串
     */
    public static StringJoiner getLuoMaNumbers(String numbers) {
        // 1、判断numbers是否为null
        if (numbers == null) {
            return null;
        }

        // 2、创建StringJoiner对象，用于拼接空格隔开的罗马数字字符串
        StringJoiner sj = new StringJoiner(" ");

        // 3、遍历numbers，依次获取到每个阿拉伯数字字符
        // 定义字符变量，用于接收每次获取到的数字字符
        for (int i = 0; i < numbers.length(); i++) {
            char c = numbers.charAt(i);
            // 4、根据获取到的数字字符 匹配拼接 罗马数字字符串
            switch (c) {
                case '0' -> sj.add("");
                case '1' -> sj.add("I");
                case '2' -> sj.add("II");
                case '3' -> sj.add("III");
                case '4' -> sj.add("IV");
                case '5' -> sj.add("V");
                case '6' -> sj.add("VI");
                case '7' -> sj.add("VII");
                case '8' -> sj.add("VIII");
                case '9' -> sj.add("IX");
                default -> sj.add("");
            }
        }

        return sj;
    }


    /**
     * 查表法方式：利用ASCII码表根据字符串的每个阿拉伯数字字符获取相应的罗马数字字符串
     *
     * @param numbers 阿拉伯数字字符串
     * @return        返回罗马数字字符串
     */
    public static StringJoiner getASCIILuoMaNumbers(String numbers) {
        // 1、判断numbers是否为null
        if (numbers == null) {
            return null;
        }

        // 2、定义罗马数字字符串数组
        // 注意点：罗马数字是没有0的，用 "" 代替
        String[] luoMaNumbers = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};

        // 3、创建StringJoiner对象，用于拼接空格隔开的罗马数字
        StringJoiner sj = new StringJoiner(" ");

        // 4、遍历numbers，依次获取到每个阿拉伯数字字符
        for (int i = 0; i < numbers.length(); i++) {
            // 每获取到一个阿拉伯数字字符，接收一下
            char c = numbers.charAt(i);
            // 利用ASCII码表将获取到的数字字符 抓换成 int类型数字
            int number = c - 48;
            sj.add(luoMaNumbers[number]);
        }

        // 5、遍历结束，拼接完成，返回罗马数字字符串
        return sj;
    }


    /**
     * 检验数字字符串是否符合要求
     *
     * @param numbers 数字字符串
     * @return 符合要求返回true，不符合返回false
     */
    public static boolean checkNumbers(String numbers) {
        // 1、长度不能大于9
        if (numbers.length() > 9) {
            // 不符合条件，返回false
            return false;
        }

        // 2、只能是数字(利用ASCII码表)
        // 依次获取字符串numbers的每个字符
        for (int i = 0; i < numbers.length(); i++) {
            // 每得到一个字符，接收一下
            char c = numbers.charAt(i);
            // 判断该字符是否已经超过数字字符的范围
            if (c < '0' || c > '9') {
                // 是，不符合条件，返回false
                return false;
            }
        }

        // 3、程序走到这里，说明前面的校验都用不上，说明该字符串符合条件，返回true
        return true;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111
      • 112
      • 113
      • 114
      • 115
      • 116
      • 117
      • 118
      • 119
      • 120
      • 121
      • 122
      • 123
      • 124
      • 125
      • 126
      • 127
      • 128
      • 129
      • 130
      • 131
      • 132
      • 133
      • 134
      • 135
      • 136
      • 137
      • 138
      • 139
      • 140
      • 141
      • 142
      • 143
      • 144
      • 145
      • 146
      • 147
      • 148
      • 149
      • 150
      • 151
      • 152
      • 153
      请您输入一串阿拉伯数字：
123456a
您输入的字符串不符合条件~ 请重新输入！
请您输入一串阿拉伯数字：
0123456789
您输入的字符串不符合条件~ 请重新输入！
请您输入一串阿拉伯数字：
123456789
I II III IV V VI VII VIII IX
------------------------------------
I II III IV V VI VII VIII IX

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      请您输入一串阿拉伯数字：
022331
 II II III III I
------------------------------------
 II II III III I

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      请您输入一串阿拉伯数字：
298810
II IX VIII VIII I 
------------------------------------
II IX VIII VIII I 

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
    2、调整字符串

    • 需求：

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

    • 分析：

      • 需要定义两个字符串：A和B
      • 需要实现字符串的旋转功能（将最左侧的字符 弄到 最右侧）
      • 需要循环不断让字符串A旋转：
        • 判断字符串A在旋转若干次后，是否与字符串B相等：
          • 相等，说明字符串A变成了字符串B，则返回true
      • 如果循环结束了，仍然不能相等，说明字符串A无法变成字符串B，则返回false

    • 实现：

      package com.app.demo21_string_test;

import java.util.Scanner;

/*
    字符串练习：调整字符串
        需求：
            给定两个字符串：A 和 B。
            A的旋转操作就是A最左边的字符移动到最右边。
            例如：
                若 A = 'abcde'，在移动一次之后结果就是 'bcdea'。
            如果在若干次调整操作之后，A 能变成 B，那么返回true。
            如果不能匹配成功，则返回false。
        套路：
            如果以后我们遇到要修改字符串的内容的时候
            可以有两个办法：
                1、用subString进行截取，把最左边的字符截取出来拼接到最右边去
                2、把字符串先变成一个字符数组，然后调整字符数组里面的数据，最后把字符数组变成字符串
 */
public class StringDemo11 {
    public static void main(String[] args) {
        // 1、需要从键盘录入两个字符串 A和B
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入字符串A：");
        String strA = sc.next();
        System.out.println("请您输入字符串B：");
        String strB = sc.next();

        System.out.println("原字符串A：" + strA);
        System.out.println("原字符串B：" + strB);

        // 4、使用套路1让字符串A开始旋转
        boolean flag1 = check1(strA, strB);
        System.out.println("使用旋转方式1将字符串A在旋转若干次后，是否能与字符串B相等：" + flag1);

        System.out.println("------------------------");

        // 5、使用套路2让字符串A开始旋转
        boolean flag2 = check2(strA, strB);
        System.out.println("使用旋转方式2将字符串A在旋转若干次后，是否能与字符串B相等：" + flag2);
    }


    /**
     * 实现使用旋转方式二：将字符串A循环旋转后，与字符串B做比较
     *
     * @param strA 字符串A
     * @param strB 字符串B
     * @return 旋转若干次后如果相等，返回true，否则返回false
     */
    public static boolean check2(String strA, String strB) {
        // 1、循环旋转字符串A
        for (int i = 0; i < strA.length(); i++) {
            // 2、每循环一次，就旋转一次字符串A
            strA = rotate2(strA);

            // 3、判断每次旋转后的字符串A是否与字符串B相等
            if (strA.equals(strB)) {
                return true;
            }
        }

        // 3、循环结束，说明旋转后的所有情况都比较完毕了，仍然不相等。返回false
        return false;
    }


    /**
     * 实现使用旋转方式一：将字符串A循环旋转后，与字符串B做比较
     *
     * @param strA 字符串A
     * @param strB 字符串B
     * @return 旋转若干次后如果相等，则返回true，否则返回false
     */
    public static boolean check1(String strA, String strB) {
        // 1、循环旋转字符串A
        for (int i = 0; i < strA.length(); i++) {
            // 2、每循环一次，就旋转一次字符串A
            strA = rotate1(strA);

            // 3、判断每次旋转后的字符串A是否与字符串B相等
            if (strA.equals(strB)) {
                // 相等，返回true
                return true;
            }
        }

        // 3、循环结束，说明旋转后的所有情况都比较完毕了，仍然不相等。返回false
        return false;
    }


    /**
     * 旋转方式二：
     *      把字符串先变成一个字符数组，然后调整字符数组里面的数据，最后把字符数组变成字符串。
     * 使用旋转方式二来实现旋转字符串的功能：
     *
     * @param str 被旋转的字符串
     * @return 返回旋转后的字符串
     */
    public static String rotate2(String str) {
        // 1、判断字符串str是否为null
        if (str == null) {
            return "";
        }

        // 2、把字符串str变成一个字符数组
        char[] chars = str.toCharArray();

        // 3、取出字符数组0索引的字符
        char first = chars[0];

        // 4、从索引1开始遍历字符数组，依次将剩余的字符往前一位移动
        for (int i = 1; i < chars.length; i++) {
            chars[i - 1] = chars[i];
        }

        // 5、循环结束，说明调整完成，将字符数组0索引的字符放到最后一位
        chars[chars.length - 1] = first;

        // 6、把字符数组变成字符串
        String newStr = new String(chars);

        // 7、返回旋转后的字符串
        return newStr;
    }


    /**
     * 旋转方式一：
     *      用subString进行截取，把最左边的字符截取出来拼接到最右边去
     * 使用旋转方式一来实现旋转字符串的功能：
     *
     * @param str 被旋转的字符串
     * @return 返回旋转后的字符串
     */
    public static String rotate1(String str) {
        // 1、判断字符串str是否为null
        if (str == null) {
            return "";
        }

        // 2、截取字符串的第一个位置的字符
        char first = str.charAt(0);

        // 3、截取字符串剩下的所有字符
        String end = str.substring(1);

        // 4、将第一个位置的字符 拼接到最右侧
        String newStr = end + first;

        return newStr;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111
      • 112
      • 113
      • 114
      • 115
      • 116
      • 117
      • 118
      • 119
      • 120
      • 121
      • 122
      • 123
      • 124
      • 125
      • 126
      • 127
      • 128
      • 129
      • 130
      • 131
      • 132
      • 133
      • 134
      • 135
      • 136
      • 137
      • 138
      • 139
      • 140
      • 141
      • 142
      • 143
      • 144
      • 145
      • 146
      • 147
      • 148
      • 149
      • 150
      • 151
      • 152
      • 153
      • 154
      请您输入字符串A：
abcde
请您输入字符串B：
cdeab
原字符串A：abcde
原字符串B：cdeab
使用旋转方式1将字符串A在旋转若干次后，是否能与字符串B相等：true
------------------------
使用旋转方式2将字符串A在旋转若干次后，是否能与字符串B相等：true

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      请您输入字符串A：
123123
请您输入字符串B：
cdeab
原字符串A：123123
原字符串B：cdeab
使用旋转方式1将字符串A在旋转若干次后，是否能与字符串B相等：false
------------------------
使用旋转方式2将字符串A在旋转若干次后，是否能与字符串B相等：false

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
    3、打乱字符串内容

    • 需求：

      • 从键盘录入任意的字符串后，打乱该字符串每个字符的顺序并输出到控制台。
      • 例如：
        • 输入的字符串是：123abc
        • 随机打乱后：b1c23a

    • 分析：

      • 需要键盘录入一个字符串
      • 套路：
        • 1、用subString截取后打乱
        • 2、将字符串变成字符数组，打乱后再变回字符串（推荐使用，比较方便）

    • 实现：

      package com.app.demo21_string_test;

import java.util.Random;
import java.util.Scanner;

/*
    字符串练习：打乱字符串内容
        需求：从键盘录入任意的字符串后，打乱该字符串每个字符的顺序并输出到控制台。
        例如：
            输入的字符串是：123abc
            随机打乱后：b1c23a
 */
public class StringDemo12 {
    public static void main(String[] args) {
        // 1、从键盘录入一个任意的字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入一句想说的话：");
        String str = sc.nextLine();

        // 2、调用套路1打乱方法，将字符串打乱后输出
        String newStr = stringShuffle(str);
        System.out.println("打乱后：" + newStr);
    }

    /**
     * 实现打乱字符串内容的功能
     *
     * @param str 字符串
     * @return 返回打乱后的字符串
     */
    public static String stringShuffle(String str) {
        // 1、判断字符串是否为null
        if (str == null) {
            return "";
        }

        // 2、将字符串变成字符数组
        char[] chars = str.toCharArray();

        // 3、创建随机数对象，用于随机生成一个索引
        Random rd = new Random();

        // 4、遍历chars，依次获取每个字符
        for (int i = 0; i < chars.length; i++) {
            // a.每获取到一个字符，用临时变量接收一下
            char temp = chars[i];
            // b.每循环一次，就生成一个随机索引
            int randomIndex = rd.nextInt(chars.length);
            // c.当前获取到的字符 与 随机索引到的字符进行位置交换
            chars[i] = chars[randomIndex];
            chars[randomIndex] = temp;
        }

        // 5、循环结束，说明每个字符都已经 与 随机字符交换完位置了
        // 将字符数组变成字符串
        String newStr = new String(chars);

        // 6、将打乱后的字符串返回
        return newStr;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      请您输入一句想说的话：
今天晚上我请你吃饭！
打乱后：天吃我饭请你上晚今！

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
    4、生成验证码

    • 需求：

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

    • 分析：

      • 需要把所有的大写、小写字母放到数组中
      • 需要随机生成四位大写或小写字母的字符
      • 需要随机生成一位0~9的数字
      • 需要拼接成5位的验证码
      • 需要将拼接好的5位验证码打乱顺序

    • 实现：

      package com.app.demo21_string_test;

import java.util.Random;

/*
    字符串练习：生成验证码
        需求：
            内容：可以是小写字母，也可以是大写字母，还可以是数字。
            规则：
                长度为5
                四位是字母，一位数字
                其中数字只有1位，但是可以出现在任意的位置
 */
public class StringDemo13 {
    public static void main(String[] args) {
        // 调用随机生成验证码的方法，生成验证码
        String code = createCode(5);
        System.out.println("验证码：" + code);
    }


    /**
     * 实现生成验证码的功能
     *
     * @param number    验证码个数
     * @return          返回生成好的验证码
     */
    public static String createCode(int number) {
        // 1、验证码的个数最低不能低于5个
        if (number < 5) {
            return "验证码个数不能低于5个";
        }

        // 2、把所有的大写、小写字母存储到数组中
        char[] chars = new char[52]; // 大写小写各26个

        // 3、将所有的大写、小写字母依次存储到数组中
        for (int i = 0; i < chars.length; i++) {
            // a.当索引小于等于25时
            if (i <= 25) {
                // 说明添加的是小写字母
                // 依次将小写字母的ASCII码 转换成字符类型后，添加进数组中
                chars[i] = (char) (97 + i);
            }else { // b.当索引大于25
                // 说明小写字母已经添加完成，索引i已经等于26了
                // 依次将大写字母的ASCII码 转换成字符类型后，添加进数组中
                chars[i] = (char) (65 + i - 26);    // 先65+26=91，再91-26=65
            }
        }

        // 4、循环结束，说明数组中已经存储好了所有的大写、小写字母
        // 定义空字符串变量，用于拼接随机生成的验证码
        String code = "";


        // 创建随机数对象，用于随机生成一个索引
        Random rd = new Random();

        // 5、随机生成 number-1 位字母的验证码
        // number - 1: 假如number = 5，那就生成 5-1=4，四位随机字母
        for (int i = 0; i < number - 1; i++) {
            // 每循环一次，就随机生成一个新索引
            int randomIndex = rd.nextInt(chars.length);
            // 随机生成一个大写或小写字母拼接成 number-1 位字母
            code += chars[randomIndex];
        }

        // 6、循环结束，说明字母拼接完成
        // 随机生成1位数字拼接到最右侧
        int randomNumber = rd.nextInt(10);
        code += randomNumber;

        // 7、验证码拼接完成，开始打乱顺序
        // 将验证码字符串 变成 字符数组
        char[] codeArr = code.toCharArray();
        // 遍历验证码数组，依次获取每个字符
        for (int i = 0; i < codeArr.length; i++) {
            // 每遍历一次，就生成一个随机索引位置
            int randomIndex = rd.nextInt(codeArr.length);

            // 循环让当前获取到的字符 与 随机索引位置的字符进行位置交换
            // 用临时变量接收一下每次获取到的字符
            char temp = codeArr[i];
            codeArr[i] = codeArr[randomIndex];
            codeArr[randomIndex] = temp;
        }

        // 8、循环结束，说明验证码数组的所有字符位置已经打乱，将字符数组变回字符串
        String newCode = new String(codeArr);

        // 9、返回打乱后的验证码字符串
        return newCode;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      验证码：JM4zY

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      验证码：p5Isi

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
    5、字符串乘积

    • 需求：

      • 从键盘输入两个以字符串形式表示的非负整数：num1和num2，返回两个非负整数的乘积；
      • 它们的乘积也表示为字符串形式。

    • 分析：

      • 需要键盘录入两个字符串形式的正整数：num1、num2
      • 需要将两个字符串形式的正整数转换成整数类型来计算
      • 需要实现计算两个正整数乘积的功能
      • 需要最后转换成字符串形式返回它们的乘积

    • 实现：

      package com.app.demo21_string_test;

import java.util.Scanner;

/*
    字符串练习：字符串乘积
        需求：
            从键盘输入两个以字符串形式表示的非负整数：num1和num2，返回两个非负整数的乘积；
            它们的乘积也表示为字符串形式。
 */
public class StringDemo14 {
    public static void main(String[] args) {
        // 1、从键盘录入两个正整数
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入第一个正整数：");
            String num1 = sc.next();
            System.out.println("请您输入第二个正整数：");
            String num2 = sc.next();

            // 2、计算两个数的乘积
            String result = multiply(num1, num2);
            if (result == null) {
                System.out.println("您输入的不是正整数！");
            }else {
                System.out.println(num1 + "*" + num2 + "=" + result);
                break;
            }
        }
    }


    /**
     * 计算两个数的乘积
     *
     * @param num1 第一个数
     * @param num2 第二个数
     * @return 返回两个数的乘积
     */
    public static String multiply(String num1, String num2) {
        // 1、将num1和num2从字符串类型转换成int类型
        // a.定义变量，用于接收转换成int类型的num1
        int newNum1 = convertType(num1);
        int newNum2 = convertType(num2);

        // b.判断两个数是否小于0
        if (newNum1 < 0 || newNum2 < 0) {
            // 是
            return null;
        }

        // 2、计算两个数的乘积
        int result = newNum1 * newNum2;

        // 3、将计算结果转换成字符串类型
        String strResult = "" + result;

        // 4、将字符串类型的结果返回给调用处
        return strResult;
    }


    /**
     * 将字符串类型的数字转换成int类型的数字
     *
     * @param num   字符串类型数字
     * @return      返回整数类型的数字
     */
    public static int convertType(String num) {
        // a.定义变量，用于接收转化成int类型的num
        int newNum = 0;

        // b.遍历字符串num1，依次获取每个字符
        for (int i = 0; i < num.length(); i++) {
            // 12345
            // 每获取到一个字符，接收一下
            char c = num.charAt(i);
            // 利用ASCII码表将字符c转换成int类型的数字
            /*
                ASCII码表：
                字符0~9的ascii码为：48、49、50、51、52、53、54、55、56、57
             */
            /*
                解析：
                    假如num1=12345
                    第一次循环：
                        newNum = newNum * 10 + c - 48 ==> 0 = 0 * 10 + 49 - 48 = 1
                    第二次循环：
                        newNum = newNum * 10 + c - 48 ==> 1 = 1 * 10 + 50 - 48 = 12
                    第三次循环：
                        newNum = newNum * 10 + c - 48 ==> 12 = 12 * 10 + 51 - 48 = 123
                    第四次循环：
                        newNum = newNum * 10 + c - 48 ==> 123 = 123 * 10 + 52 - 48 = 1234
                    第五次循环：
                        newNum = newNum * 10 + c - 48 ==> 1234 = 1234 * 10 + 51 - 48 = 12345
                    循环结束后，最终newNum就等于int类型的12345
             */
            newNum = newNum * 10 + c - 48;
        }

        // c.循环结束，说明类型转换完成，返回转换成int类型后的数字
        return newNum;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      请您输入第一个正整数：
-100
请您输入第二个正整数：
10
您输入的不是正整数！
请您输入第一个正整数：
98
请您输入第二个正整数：
-1
您输入的不是正整数！
请您输入第一个正整数：
100
请您输入第二个正整数：
9
100*9=900

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
    6、单词长度判断

    • 需求：

      • 从键盘录入一个字符串，由若干个单词组成，单词前后用一些空格隔开。
      • 返回字符串中最后一个单词的长度。
      • 单词是指仅由字母组成、不包含任何空格字符的最大子字符串。
      • 示例：
        • 输入：Hello World，输出：5
        • 解释：最后一个单词是“World”，长度为5

    • 分析：

      • 需要从键盘录入一个英文的字符串
      • 需要校验这个字符串是不是英文版的
      • 需要一个字符串数组，以空格作为分割符，依次分割每个单词存入数组中
      • 需要取出该数组中的最后一个单词
      • 需要返回最后一个单词的长度

    • 实现：

      package com.app.demo21_string_test;

import java.util.Scanner;

/*
    字符串练习：单词长度判断
        需求：
            从键盘录入一个字符串，由若干个单词组成，单词前后用一些空格隔开。
            返回字符串中最后一个单词的长度。
            单词是指仅由字母组成、不包含任何空格字符的最大子字符串。
            示例：
              输入：Hello World，输出：5
              解释：最后一个单词是“World”，长度为5
 */
public class StringDemo15 {
    public static void main(String[] args) {
        // 1、从键盘录入一个字符串，由若干个单词组成
        Scanner sc = new Scanner(System.in);
        String englishStr;
        while (true) {
            System.out.println("请您输入一句想说的话(英文版：每个单词用空格隔开)：");
            englishStr = sc.nextLine();
            // 2、校验该字符串是否为英文版
            boolean flag = check(englishStr);
            if (flag) {
                // 是英文版
                break;
            }else {
                System.out.println("您输入的不是英文版！");
            }
        }

        // 2、获取最后一个单词的长度
        int length = getWordLength(englishStr);
        System.out.println("长度为：" + length);
    }


    /**
     * 获取最后一个单词的长度
     *
     * @param str   英文字符串
     * @return      返回最后一个单词的长度
     */
    public static int getWordLength(String str) {
        // 1、定义一个字符串单词数组，将英文字符串以空格作为分割符将每个单词存入数组中
        String[] words = str.split(" ");

        // 2、直接取出单词数组中的最后一个单词
        String endWord = words[words.length - 1];

        // 3、将最后一个单词的长度返回
        System.out.println("您这句话中的最后一个单词为：" + endWord);
        return endWord.length();
    }


    /**
     * 校验该字符串是否为英文版
     *
     * @param str     字符串
     * @return        是英文版的返回true，不是返回false
     */
    public static boolean check(String str) {
        // 1、遍历str字符串，依次获取到每个字符
        for (int i = 0; i < str.length(); i++) {
            // 每获取到一个字符。接收一下
            char c = str.charAt(i);
            // 判断该字符是不是英文
            if (c >= 'a' && c <= 'z') {
                return true;
            } else if (c >= 'A' && c <= 'Z') {
                return true;
            }
        }

        // 2、遍历结束，所有情况都比较完了，说明不是英文或空格，返回false
        return false;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      请您输入一句想说的话(英文版：每个单词用空格隔开)：
我是你的 爸爸
您输入的不是英文版！
请您输入一句想说的话(英文版：每个单词用空格隔开)：
I is are your father
您这句话中的最后一个单词为：father
长度为：6

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
  • 相关阅读:
    Windows 基于Visual Studio 开发Qt 6 注意事项
    我的创作纪念日
    Maven打包知识点
    Eureka服务注册中心
    PyQt5 设置窗口背景
    Hadoop中的MapReduce框架原理、Job提交流程源码断点在哪断并且介绍相关源码、切片与MapTask并行度决定机制、MapTask并行度决定机制
    QFrame类学习笔记
    HTML网页大作业代码【免费代码已上传】
    YOLOv5涨点必备！改进损失函数EIoU,SIoU,AlphaIoU,FocalEIoU,Wise-IoU
    C++prime读书笔记（二）C++标准库
  • 原文地址：https://blog.csdn.net/yelitoudu/article/details/127810738