《JAVA-字符串》

原创于 2025-01-04 09:45:35 发布 · 1.1k 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#java #python #开发语言

文章目录

《JAVA-字符串》

《JAVA-字符串》

1.String概述

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

2.String构造方法代码实现和内存分析

创建String对象的两种方法

    public static void main(String[] args) {
        //方法1：直接赋值
        String s1 = "abc";

        //方法2：使用new方式来获取一个字符串对象

        //2.1调用空参构造，获取一个空白的字符串对象（一般不用）
        String s2 = new String();

        //2.2调用有参构造，根据传递的字符串再创建一个新的字符串对象（一般也不会使用）

        String s3 = new String("abc");

        //2.3调用有参构造，传递一个字符数组，根据字符数组的内容创建一个字符串
        //应用场景：用于修改字符串的内容，
        //（先把字符串变为字符数组，改变字符数组内容后，再通过一下方法将字符数组变为字符串）
        char[] chars = {'a', 'b', 'c'};
        String s4 = new String(chars);

        //2.4调用有参构造，传递一个字节数组根据字节数组的内容创建一个字符串；
        byte[] bytes = {97, 98, 99, 100};
        String s5 = new String(bytes);
    }
}

String对象内存分析
当使用双引号直接赋值时，系统会检查改字符串在串池中是否存在
不存在：创建新的字符串
存在：复用
优点：使用直接赋值的方式最简单，而且可以节约内存。
使用new关键创建字符串对象分析

3.字符串的比较

（a==b）如果a，b还基本类型比较的是数据值，如果a，b是引用数据类型比较的是地址值；
boolean equals方法(要比较的字符串) ：完全一样结果才是true，否则为false
boolean equalslgnoreCase(要比较的字符串) ：忽略大小写的比较

4.练习-用户登录

需求:
1.已知正确的用户名和密码；
2.请用程序实现模拟用户登录；
3.总共给三次机会，登录之后，给出相应的提示；

public class StringDemo02 {
    public static void main(String[] args) {

        //1创建正确的用户名和密码
        String username = "huawei";
        String password = "123456";

        //2.请用程序实现模拟用户登录;
        Scanner sc = new Scanner(System.in);

        for (int i = 0; i < 3; i++) {
            System.out.println("请输入用户名：");
            String s1 = sc.next();
            System.out.println("请输入密码：");
            String s2 = sc.next();

            //3.比较用户名和密码系统中存储的是否一致
            if (s1.equals(username) && s2.equals(password)) {
                System.out.println("登陆成功");
                break;
            } else {
                if (i == 2) {
                    System.out.println("您的账号被锁定，请联系管理员");
                } else {
                    System.out.println("登录失败，用户名或密码错误，您还有" + (2 - i) + "机会");
                }
            }
        }
    }
}

5.练习-遍历字符串和统计字符个数

需求1:键盘录入一个字符串，使用程序实现在控制台遍历该字符串；
public int length() {return value.length;} 获得字符串的长度。
public char charAt(int index) {…} 根据索引返回字符。

public class StringDemo02 {
    public static void main(String[] args) {
        //1创建正确的用户名和密码
        String username = "huawei";
        String password = "123456";

        //2.请用程序实现模拟用户登录;
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入用户名：");
            String s1 = sc.next();
            System.out.println("请输入密码：");
            String s2 = sc.next();

            //3.比较用户名和密码系统中存储的是否一致,并给出相应提示。
            if (s1.equals(username) && s2.equals(password)) {
                System.out.println("登陆成功");
                break;
            } else {
                if (i == 2) {
                    System.out.println("您的账号被锁定，请联系管理员");
                } else {
                    System.out.println("登录失败，用户名或密码错误，您还有" + (2 - i) + "机会");
                }
            }
        }
    }
}

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

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

        //2.统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
        //遍历字符串并的到每一个字符
        int bigCount = 0;
        int smallCount = 0;
        int intCount = 0;
        for (int i = 0; i < s1.length(); i++) {
            char cha = s1.charAt(i);
            if (cha>'A'&&cha<'Z'){
                bigCount++;
            }else if (cha>'a'&&cha<'z'){
                smallCount++;
            } else if (cha>'0'&&cha<'9') {
                intCount++;
            }
        }
        System.out.println("大写字母的个数为：" + bigCount);
        System.out.println("小写字母的个数为：" + smallCount);
        System.out.println("数字的个数为：" + intCount);
    }
}

总结，以上练习需要掌握字符串的遍历和比较，以及个数统计思想

6.练习-字符串拼接和反转

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

public class StringDemo05 {
    public static void main(String[] args) {
        //创建一个数组
        int[] arr = {1, 2, 3};
        String s = arrToString(arr);
        System.out.println(s);
    }
    //定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回调用该方法，并在控制台输出结果。
    /*
    1.我要干嘛？把int数组中的数据按照指定的格式拼接成一个字符串
    2.我需要什么？需要int数组
    3.干完以后是否需要把结果返回？ 需要返回拼接后的字符串
     */

    public static String arrToString(int[] arr) {

        //1.判断数组元素是否为空
        if (arr == null) {
            return "";
        }

        //2.判断数组长度是否为0
        if (arr.length == 0) {
            return "[]";
        }

        //如果数组通过以上2步，说明数组既不是null，也不是长度为0
        //3.遍历数组元素，并拼接

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

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

public class StringDemo06 {
    public static void main(String[] args) {
        //键盘录入一个字符串；
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String s = sc.next();
        //代用字符串反转方法；
        String s1 = reverseArray(s);
        System.out.println(s1);
    }
    //定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果例如，键盘录入 abc，输出结果cba
    /*
    1.我要干嘛？把字符串反转
    2.我需要什么？需要字符串
    3.我结果需要返回调用处吗？需要返回反转后的字符串
     */
    public static String reverseArray(String s) {
        String newArr = "";
        for (int i = s.length() - 1; i >= 0; i--) {
            newArr = newArr + s.charAt(i);
        }
        return newArr;
    }
}

总结：以上练习需要掌握字符串反向遍历，以及字符串拼接方法，并掌握string.forr字符串反向遍历的快捷方式。

7.练习-金额转换

在这里插入图片描述

public class StringDemo07 {
    public static void main(String[] args) {
        //键盘录入一个小写整数金额,并判断金额是否有效
        Scanner scanner = new Scanner(System.in);
        int money;
        while (true) {
            System.out.println("请输入金额：");
            money = scanner.nextInt();
            if (money >= 0 && money <= 9999999){
                break;
            }else {
                System.out.println("金额无效");
            }
        }

        //2.把小写金额变为大写
        String moneyStr ="";
        while (true){
            int ge = money % 10;
            money = money / 10;
            if (ge == 0 ){
                break;
            }
            moneyStr = getCapitalNumber(ge) + moneyStr;
        }

        //3.把不足7为数的，用零补齐
        int count = 7 - moneyStr.length();
        for (int i = 0; i < count; i++) {
            moneyStr = "零" + moneyStr;
        }

        //4.插入单位,完成最终结果；
        String capitalMoney = "";
        String[] arr = {"佰","拾","万","仟","佰","拾","元"};
        for (int i = 0; i < moneyStr.length(); i++) {
            char c = moneyStr.charAt(i);
            capitalMoney = capitalMoney + c + arr[i];
        }
        System.out.println(capitalMoney);
    }

    //2.定义一个方法把小写金额转换为大写金额
    public static String getCapitalNumber(int number){
        String[] capitals = {"零","壹","贰","叁","肆","伍","陆","柒","扒","玖"};
        return capitals[number];
    }
}

8.练习-手机号屏蔽、身份证信息查看、敏感词替换

练习1.手机号屏蔽

public class StringDemo08 {
    public static void main(String[] args) {
        String number = "18866677521";
        //使用substring（）方法截取字符串
        String start = number.substring(0, 3);
        String end = number.substring(7);
        //将字符串进行拼接
        String result = start + "****" + end;
        System.out.println(result);//188****7521
    }
}

==总结：==以上练习重点需要掌握substring（）方法，截取字符串，截取规则是包左不包右。
练习2.身份证信息查看

public class StringDemo09 {
    public static void main(String[] args) {
        String id = "370502198904165618";
        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+  "日");

        char gender = id.charAt(16);
        //利用ASCII码表将char类型数字转换为int类型数字；
        int num = gender - 48;
        if (num % 2 == 0){
            System.out.println("性别为：女");
        }else {
            System.out.println("性别为：男");
        }
        
        /*运行结果如下：
        人物信息为:
        出生年月日：1989年04月16日
        性别为：男
         */
    }
}

总结：通过以上练习继续数量substring（）方法，还需要掌握如何利用ASCII码表将char类型数字转换为int类型数字；
练习3.敏感词替换

public class StringDemo10 {
    public static void main(String[] args) {
        String talk = "你玩的真好，以后不要再玩了，TMD,CNM";
        String[] arr = {"TMD","SB","CNM","MLGB"};
        //使用replace（）方法把对话中的敏感词替换为***
        for (int i = 0; i < arr.length; i++) {
            talk = talk.replace(arr[i], "***");
        }
        System.out.println(talk);
    }
}

总结：通过以上练习需要掌握字符串的replace（）方法；

9.StringBuilder的基本操作

StringBuilder 可以看成是一个容器，创建之后里面的内容是可变的。
作用:提高字符串的操作效率
构造方法：
- public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容；
- public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象；
常用成员方法：
- public StringBuilder append (任意类型)：添加数据，并返回对象本身
- public StringBuilder reverse()：反转容器中的内容
- public int length()：返回长度(字符出现的个数)
- public String toString()：通过toString()就可以实现把StringBuilder转换为String
StringBuilder的基本操作代码示例：

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

        //2.添加数据
        sb.append("a");
        sb.append("b");
        sb.append("c");
        sb.append("d");
        sb.append("e");
        sb.append("f");
        sb.append("g");

        //3.反转容器中的内容
        sb.reverse();

        //4.返回长度(字符出现的个数)
        int length = sb.length();
        System.out.println(length);

        //5.通过toString()就可以实现把StringBuilder转换为String
        String str = sb.toString();
        System.out.println(str);
    }

总结:通过以上练习需要掌握StringBuilder的基本操作：创建、添加、反转、返回长度、转换为String类型等。

练习1：判断输入的字符串是否为对称字符串

public class StringBuilderDemo02 {
    //判断输入的字符串是否为对称字符串
    //思路：将输入的字符串进行反转，将反转后的字符串的原字符串比较，如果相同则为对称字符串
    public static void main(String[] args) {
        //1.接收键盘录入一个字符串；
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = scanner.next();

        //2.利用StringBuilder（）方法将字符串反转
        StringBuilder sb = new StringBuilder();
        String newStr = sb.append(str).reverse().toString();
        System.out.println(newStr);

        //3.将反转后的字符串和原字符串比较，判断是否为对称字符串
        if (str.equals(newStr)){
            System.out.println("是对称字符串");
        }else {
            System.out.println("不是对称字符串");
        }
    }
}

总结：通过以上练习需要掌握StringBuilder在字符串反转中的应用；
练习2：字符串拼接

public class StringBuilderDemo03 {
    public static void main(String[] args) {
        //创建一个数组
        int[] arr = {1, 2, 3};
        String s = arrToString(arr);
        System.out.println(s);
    }
    
    //定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回调用该方法，并在控制台输出结果。
    public static String arrToString(int[] arr) {
        //1.判断数组元素是否为空
        if (arr == null) {
            return "";
        }
        //2.判断数组长度是否为0
        if (arr.length == 0) {
            return "[]";
        }
        //如果数组通过以上2步，说明数组既不是null，也不是长度为0
        //3.遍历数组元素，使用StringBuilder进行拼接；
        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] + ", ");
            }
        }
        return sb.toString();
    }
}

总结：通过以上练习需要掌握StringBuilder字符串拼接的使用场景；

10.StringJoiner类

11.字符串相关类的底层原理

12.练习：将阿拉伯数字转换为罗马数字

键盘录入一个字符串；
要求1.字符串长度小于等于9;
要求2.组成字符串的字符只能是数字,
将内容转换为罗马数字；

public class StringDemo1 {
    public static void main(String[] args) {
        //1.键盘录入一个字符串
        String str;
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入一个字符串：");
            str = sc.next();
            //2.校验字符串知否满足规则
            boolean flag = checkStr(str);
            if (flag) {
                break;
            } else {
                System.out.println("您输入的字符串不合法，请重新输入");
            }
        }
        //3.将字符串中的数字转换为罗马数字
        //可以使用“查表法” 1-Ⅰ 2-Ⅱ 3-Ⅲ 4-Ⅳ 5-Ⅴ 6-Ⅵ 7-Ⅶ 8-Ⅷ 9-Ⅸ
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            int number = c - 48;
            String s = changeLuoMa(number);
            sb.append(s);
        }
        String string = sb.toString();
        System.out.println(string);
    }

    //方法1：设计一个方法输入一个数字（1-9），返回一个对应的罗马数字
    public static String changeLuoMa(int number) {
        String[] arr = {"", "Ⅰ", "Ⅱ", "Ⅲ", "Ⅳ", "Ⅴ", "Ⅵ", "Ⅶ", "Ⅷ", "Ⅸ"};
        return arr[number];
    }

    //方法2：设计一个字符串校验的方法
    public static boolean checkStr(String str) {
        //要求1.字符串长度小于等于9
        if (str.length() <= 9) {
            for (int i = 0; i < str.length(); i++) {
                //要求2.组成字符串的字符只能是数字
                if (str.charAt(i) < '0' || str.charAt(i) > '9') {
                    return false;
                }
            }
        }
        return true;
    }
}

总结：通过以上练习需要熟悉字符串的遍历、使用StringBuilder类拼接字符串、字符数字转换为int数字的方法、以及利用查表法将普通数字转换为罗马数字的思路；

以上案例可以使用switch选择结构代替查表法，代码改造如下：

public class StringDemo11 {
    public static void main(String[] args) {
        //1.键盘录入一个字符串
        String str;
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入一个字符串：");
            str = sc.next();
            //2.校验字符串知否满足规则
            boolean flag = checkStr(str);
            if (flag) {
                break;
            } else {
                System.out.println("您输入的字符串不合法，请重新输入");
            }
        }
        //3.将字符串中的数字转换为罗马数字
        //可以使用“查表法” 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);
        }
        String string = sb.toString();
        System.out.println(string);
    }

    //方法1：设计一个方法输入一个数字（1-9），返回一个对应的罗马数字
    public static String changeLuoMa(char number) {
        String str;
        switch (number){
            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 = "Ⅸ";
                break;
            default:
                str = "";
        }
        return str;
    }
    //方法2：设计一个字符串校验的方法
    public static boolean checkStr(String str) {
        //要求1.字符串长度小于等于9
        if (str.length() <= 9) {
            for (int i = 0; i < str.length(); i++) {
                //要求2.组成字符串的字符只能是数字
                if (str.charAt(i) < '0' || str.charAt(i) > '9') {
                    return false;
                }
            }
        }
        return true;
    }
}

总结：通过以上练习熟练掌握switch选择结构的用法和应用场景。

13.练习：调整字符串的内容并比较

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

方案1：用substring进行截取，把左边的字符截取出来拼接到右侧去
代码实现：

public class StringDemo12 {
    public static void main(String[] args) {
        //1.定义两个字符串
        String str_A = "abcde";
        String str_B = "cdeab";

        //2.旋转字符串，并判断是否和字符串B一致
        boolean b = check_str(str_A, str_B);
        System.out.println(b);

    }

    //方法2：判断字符串A经过不断旋转后是否能够和字符串B相同
    public static boolean check_str(String str_A, String str_B){
        for (int i = 0; i < str_A.length(); i++) {
            str_A  = rotate_Str(str_A);
            if (str_A.equals(str_B)){
                return true;
            }
        }
        return false;
    }

    //方法1：将一个字符串进行一次字符旋转
    public static String rotate_Str(String str){
        //套路:
        //如果我们看到要修改字符串的内容
        //可以有两个办法:
        //1.用substring进行截取，把左边的字符截取出来拼接到右侧去
        //2.可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串。
        char chat_start = str.charAt(0);
        String str_leave = str.substring(1);
        return  str_leave + chat_start;
    }
}

方案2：可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串。

public class StringDemo13 {
    public static void main(String[] args) {
        //1.定义两个字符串
        String str_A = "abcde";
        String str_B = "cdeab";

        //2.旋转字符串，并判断是否和字符串B一致
        boolean b = check_str(str_A, str_B);
        System.out.println(b);

    }

    //方法2：判断字符串A经过不断旋转后是否能够和字符串B相同
    public static boolean check_str(String str_A, String str_B) {
        for (int i = 0; i < str_A.length(); i++) {
            str_A = rotate_Str(str_A);
            if (str_A.equals(str_B)) {
                return true;
            }
        }
        return false;
    }

    //方法1：将一个字符串进行一次字符旋转
    //方案2.可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串。
    public static String rotate_Str(String str) {
        //1.将字符串变为字符数组
        char[] charArray = str.toCharArray();
        //2.拿到字符数组的第一个元素
        char first_char = charArray[0];
        //3.将其他元素向前挪动一个位置
        for (int i = 1; i < charArray.length; i++) {
            charArray[i - 1] = charArray[i];
        }
        //4.把第一个元素放到最后的索引位置
        charArray[charArray.length-1] = first_char;
        //把祖字符数组变成一个字符串并返回
        return new String(charArray);
    }
}

14.练习：自主练习

14.1键盘录入字符串，打乱里面的内容

public class StringDemo14 {
    public static void main(String[] args) {
        //题目要求：键盘录入字符串，打乱里面的内容
        //1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();

        //2.打乱字符串里面的内容
        //2.1将字符串转换为字符数组
        char[] charArray = str.toCharArray();
        //2.2设计一个方法把字符数组里的内容打乱
        char[] chars = disturb_Arr(charArray);
        //2.3利用new String（char[] arr）将字符数组变为字符串
        String newString = new String(chars);
        System.out.println(newString);
    }

    //方法1：打乱字符数组
    public static char[] disturb_Arr(char[] arr){
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            int randomIndex = random.nextInt(arr.length);
            char temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }
        return arr;
    }

    //方法2：打印字符数组
    public static void printArr(char[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
        System.out.print("]");
    }
}

14.2 生成验证码，4位大小写字母1位数字（数字位置随机）

public class StringDemo15 {
    public static void main(String[] args) {

        char[] chars = new char[52];
        for (int i = 0; i < 52; i++) {
            if (i<=25){
                chars[i] = (char)(97 + i);
            }else {
                chars[i] = (char) (65 + i - 26);
            }
        }

        //2.从数组中随机获取4次
        StringBuilder sb = new StringBuilder();
        Random random = new Random();
        for (int i = 0; i < 4; i++) {
            int randomIndex = random.nextInt(chars.length);
            sb.append(chars[randomIndex]);
        }
        System.out.println(sb);

        //3.生成一个0~9之间的随机数拼接到最后
        int i = random.nextInt(10);
        String str = sb.append(i).toString();
        System.out.println(str);

        //4.把生成的验证码先变成一个字符数组
        char[] charArray = str.toCharArray();

        //5.再让最后一个元素跟前面的随机位置的元素进行交换
        int i1 = random.nextInt(charArray.length);
        char temp = charArray[charArray.length-1];
        charArray[charArray.length-1] = charArray[i1];
        charArray[i1] = temp;

        //6.交换完毕之后再变成字符串就可以了。
        String result_str = new String(charArray);
        System.out.println(result_str);
    }
}