javase复习day10（String，StringBuilder，StringJioner及其相关练习）

未命名冀

已于 2024-08-27 09:59:40 修改

阅读量417

点赞数 8

分类专栏： javase复习文章标签： java

于 2024-08-26 23:34:04 首次发布

本文链接：https://blog.csdn.net/m0_72625929/article/details/141551652

版权

javase复习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

API

查询API：JDK-API帮助文档。

Jdk-21的api帮助文档（中文版）

字符串 String

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

String是java定义好的一个类。定义在java.long包下使用时不需要导包。

java程序中所有字符串文字都被视为此类的对象。

创建String对象的两种方式：

    public static void main(String[] args) {
        String s1 = "我的得到";
        System.out.println(s1);

        //使用new的方式获取字符串对象
        //空参构造获取空字符串
        String s2 = new String();
        System.out.println(s2+"!");

        //
        String s3 = new String("脱裤子放屁");
        System.out.println(s3);

        //传递一个字符数组，根据字符数组的内容在创建一个String对象
        //需求：需要修改字符串内容。
        //ABC -> {'A','B','C'}->{'Q','B','C'}->QBC
        char[] chs = {'a','b','c','e'};
        String s4 = new String(chs);
        System.out.println(s4);

        //传递一个字节数组，根据内容创建一个新String对象
        //应用场景：在网络传输中的数据都是字节信息，一般需要将字节信息进行转换，转成字符串
        byte[] bytes= {97,98,99,100,101};
        String s5 = new String(bytes);
        System.out.println(s5);
        
    }

内存情况：

字符串比较

字符串比较：

Boole equals（String）完全一样才是true，否则为false.
Boole equalslgnoreCase(String) 忽略大小写比较。

    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");
        String s3 = new String("Abc");

        boolean b = s1 == s2;
        System.out.println(b);//false

        boolean equals = s1.equals(s2);
        System.out.println(equals);//true

        boolean b1 = s2.equalsIgnoreCase(s3);
        System.out.println(b1);//true


    }

键盘录入得到的字符串是new出来的。

练习一：

    public static void main(String[] args) {
        //设置用户名和密码
        String username = "heima001";
        String password = "123456";
        boolean flag = true;
        for (int i = 0; i < 3; i++) {
            //录入用户输入的信息
            Scanner sc = new Scanner(System.in);
            //用户名
            System.out.println("请输入用户名");
            String name = sc.next();
            //密码
            System.out.println("请输入密码");
            String pass = sc.next();
            if (username.equals(name)&&password.equals(pass)){
                System.out.println("恭喜登录成功");
                flag = false;
                break;
            }else {
                System.out.println("账号或密码错误");
                System.out.println("还有"+(2-i) +"次机会");
            }
        }
        if (flag){
            System.out.println("登录机会已用完，账号被锁定");
        }
    }

练习二：

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
        String next = sc.next();
        //定意一个String对象
//        String s1 = "我更热加大手拉车";
        int length = next.length();
        for (int i = 0; i < length; i++) {
            System.out.println(next.charAt(i));
        }
    }

练习三：

应该不需要放入char数组中（可以运行但是绕路）错误：

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
        String next = sc.next();
        //string 的长度
        int length = next.length();
        //定义一个char数组来存放字符串的字符
        char[] chars = new char[length];
        for (int i = 0; i < length; i++) {
           chars[i] = next.charAt(i);
        }
        //对字符数组进行分类
        int Acount = 0;
        int acount = 0;
        int ncount = 0;
        for (int i = 0; i < chars.length; i++) {
            char aChar = chars[i];
            if (49<=(byte)aChar&&(byte)aChar<=57){
                //为数字
                ncount++;
            } else if (65<=(byte)aChar&&(byte)aChar<=90) {
                //大写字母
                Acount++;
            } else if (97<=(byte)aChar&&(byte)aChar<=122) {
                //小写字母
                acount++;
            }
        }
        System.out.println("数字"+ncount);
        System.out.println("大写字母"+Acount);
        System.out.println("小写字母"+acount);
    }

正确写法：

public class Demo6_2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
        String next = sc.next();
        //string 的长度
        int length = next.length();
        //对字符数组进行分类
        int Acount = 0;
        int acount = 0;
        int ncount = 0;
        //定义一个char数组来存放字符串的字符
        for (int i = 0; i < length; i++) {
            char c = next.charAt(i);
            if (c>='0'&&c<='9'){
                //为数字
                ncount++;
            } else if (c>='A'&&c<='Z') {
                //大写字母
                Acount++;
            } else if (c>='a'&&c<='z') {
                //小写字母
                acount++;
            }
        }
        System.out.println("数字"+ncount);
        System.out.println("大写字母"+Acount);
        System.out.println("小写字母"+acount);
    }
}

练习四：

public class Demo7 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        String s1 = splicing(arr);
        System.out.println(s1);
    }
    public static String splicing(int[] arr){
        //对数组进行校验
        if (arr == null){
            return "";
        }
        if (arr.length == 0){
            return "[]";
        }

        //定义一个空字符串来与int相加转换为String类型
        String s1 = "";
        for (int i = 0; i < arr.length; i++) {
            //第一个前面需要中括号 [
            if (i==0){
                s1 = s1+"["+arr[i]+",";
            } else if (i== arr.length - 1) {
                //最后一位
                s1 = s1+arr[i]+"]";
            }else {
                //普通情况
                s1 = s1 + arr[i]+",";
            }
        }
        return s1;
    }
}

练习五：

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

    }

    public static void rollback(String s){
        //将其转换成char数组
        char[] chars = new char[s.length()];
        for (int i = 0; i < s.length(); i++) {
            chars[i] = s.charAt(i);
        }
        //进行反转，只需要遍历的时候从后往前遍历即可
        for (int i = chars.length-1; i >=0; i--) {
            System.out.print(chars[i]+" ");
        }
    }
}

有返回值：

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

    }

    public static String rollback(String s){

        //用于接受反转后的字符串
        String result = "";
        for (int i = s.length() -1; i >=0; i--) {
            result += s.charAt(i);
        }
        return result;
    }
}

练习六：

自己写的（有瑕疵但是可以的到结果）：

public class Demo9 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int number;
        //进行校验
        while (true){
            System.out.println("请输入要转换的数字");
           number = sc.nextInt();
            if (number>=0&&number<=9999999){
                break;
            }else {
                System.out.println("输入的数据无效");
            }
        }
        char[] invert = Invert(number);
        //插入单位
        String insert = insert(invert);
        System.out.println(insert);
    }
//转换数字方法
    public static char[] Invert(int number){
        //定义数组存储
        char[] numbers = {'零','壹','贰','叁','肆','伍','陆','柒','捌','玖','拾','佰','阡'};
        char[] nb = new  char[7];
//        char[] nb = {'零','零','零','零','零','零','零'};\
        //先将零补满之后再修改已知的值
        for (int i = 0; i < nb.length; i++) {
            nb[i] = '零';
        }
        //用于指示应该在哪个位置写入数据
        int count = nb.length-1;
        //将数字拆解赋值。
        while (number != 0){
            int i = number % 10;
            number = number/10;
            nb[count] =  numbers[i];
            count--;
        }
        return nb;
    }
    public static String insert(char[] arr){
        //定义数组存储,将各个位数的单位都定义好
        char[] numbers = {'零','佰','贰','拾','肆','万','陆','仟','捌','佰','拾','拾','阡','元'};

        String number = "";
        //用于记录哪一位已经加入String中了
        int count = 0;
        for (int i = 0; i < numbers.length; i++) {
            if (i%2==0){
                //将大写的数加入字符串
                number +=arr[count];
                count++;
            }else {
                //奇数位
                //将单位加入字符串
                number += numbers[i];
            }
        }
//        System.out.println(number);
        return number;
    }
}

优化后的（将每次添加的时候，将数据和单位一同添加）：

public class Demo9 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int number;
        //进行校验
        while (true){
            System.out.println("请输入要转换的数字");
           number = sc.nextInt();
            if (number>=0&&number<=9999999){
                break;
            }else {
                System.out.println("输入的数据无效");
            }
        }
        char[] invert = Invert(number);
        //插入单位
        String insert = insert(invert);
        System.out.println(insert);
    }
//转换数字方法
    public static char[] Invert(int number){
        //定义数组存储
        char[] numbers = {'零','壹','贰','叁','肆','伍','陆','柒','捌','玖','拾','佰','阡'};
        char[] nb = new  char[7];
//        char[] nb = {'零','零','零','零','零','零','零'};\
        //先将零补满之后再修改已知的值
        for (int i = 0; i < nb.length; i++) {
            nb[i] = '零';
        }
        //用于指示应该在哪个位置写入数据
        int count = nb.length-1;
        //将数字拆解赋值。
        while (number != 0){
            int i = number % 10;
            number = number/10;
            nb[count] =  numbers[i];
            count--;
        }
        return nb;
    }
    public static String insert(char[] arr){
        //定义数组存储,将各个位数的单位都定义好
        char[] numbers = {'佰','拾','万','仟','佰','拾','元'};
        String number = "";
        //用于记录哪一位已经加入String中了
        int count = 0;
        for (int i = 0; i < numbers.length; i++) {
                //将大写的数加入字符串
                number +=arr[i];
                count++;
                //将单位加入字符串
                number += numbers[i];
        }
        return number;
    }
}

讲解的：

public class Demo9_2 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int number;
        //进行校验
        while (true) {
            System.out.println("请输入要转换的数字");
            number = sc.nextInt();
            if (number >= 0 && number <= 9999999) {
                break;
            } else {
                System.out.println("输入的数据无效");
            }
        }
        String s = "";
        while (number != 0) {
            int i = number % 10;
            number = number / 10;
            s = invert(i) + s;
        }
        System.out.println(s);
        //补全7位数
        int count = 7 - s.length();
        for (int i = 0; i < count; i++) {
            s = "零" + s;
        }
        System.out.println(s);
        //加入单位
        String insert = insert(s);
        System.out.println(insert);
    }

    //将数字转换为大写
    public static String invert(int n) {
        String s = "";
        //定义数组存储
        char[] numbers = {'零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖', '拾', '佰', '阡'};
        return s + numbers[n];
    }

    //添加单位的方法
    public static String insert(String s) {
        char[] numbers = {'佰', '拾', '万', '仟', '佰', '拾', '元'};
        //存储最后的结果
        String n = "";


        for (int i = 0; i < numbers.length; i++) {
            //将大写的数加入字符串
            n = n + s.charAt(i) + numbers[i];
        }
        return n;
    }
}

练习七：

public class Demo10 {
    public static void main(String[] args) {
        //遮挡手机号
        //获取手机号
        Scanner sc = new Scanner(System.in);
        System.out.println("亲输入手机号");
        String phonrNumber = sc.next();

//         "188";//随机获得
        //获取前三位
        String substring = phonrNumber.substring(0, 3);
        //获取后4位
        String substring1 = phonrNumber.substring(phonrNumber.length()-4);
        //中间拼接
        String n = "****";
        //拼接
        String number = "";
        number = substring+n+substring1;
        System.out.println(number);
    }
}

练习八：

public class Demo11 {
    public static void main(String[] args) {
        String UesrId = "450111197205054878";
        //获取年
        String year = UesrId.substring(6, 10);
        //月
        String month = UesrId.substring(10, 12);
        //日
        String day = UesrId.substring(12, 14);
        //性别
        char gender = UesrId.charAt(16);
        //使用AscII表进行转换
//        '0'-->48
        int i = gender - 48;
        String sex = "";
        //判断奇偶
        if (i%2==0){
            //偶数为女
            sex = "nv";
        }else {
            sex = "男";
        }
        System.out.println("人物信息为：");
        System.out.println("出生年月日："+year+"年"+month+"月"+day+"日");
        System.out.println("性别为："+ sex);
    }
}

练习九：

public class Demo12 {
    public static void main(String[] args) {
        //输入需要替换的句子
        String talk = "你玩的真好。TMD,CMD。";
        //设置敏感词库
        String[] arr = {"TMD","CMD","CTMD","SB"};

        for (int i = 0; i < arr.length; i++) {
            talk = talk.replace(arr[i],"***");
        }

        System.out.println(talk);
    }
}

StringBuilder

public class StringBuildDemo1 {
    public static void main(String[] args) {
        //创建对象
        StringBuilder sb = new StringBuilder();
        //添加数据
        sb.append(123);
        sb.append("hhh");
        sb.append(12.3);
        System.out.println(sb);
        //反转
        sb.reverse();
        System.out.println(sb);
        //长度
        System.out.println(sb.length());

        //转换为String类型
        String string = sb.toString();
        System.out.println(string);
    }
}

链式编程：

当我们调用一个方法的时候，不需要用变量接受结果，可以继续调用其他的方法。

StringBuilder的使用场景

字符串的拼接
字符串的反转

练习一：

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

        //定义一个StringBuild对象
        StringBuilder sb = new StringBuilder(next);

        //进行反转,之后转为String对象（链式编程）
        String string = sb.reverse().toString();
        if (string.equals(next)){
            //相同,即对称
            System.out.println("是");

        }else {
            System.out.println("不是");
        }
    }
}

练习二：

public class Demo3 {
    public static void main(String[] args) {
        int[] arr ={1,2,3,4};
        String s = arrToString(arr);
        System.out.println(s);

    }
    //定义一个方法
    public static String arrToString(int[] arr){
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < arr.length; i++) {
            if (i== arr.length-1){
                sb.append(arr[i]);
            }else {
                sb.append(arr[i] + ", ");
            }
        }
        String string = sb.append("]").toString();
        return string;
    }
}

StringJoiner

public class Demo4 {
    public static void main(String[] args) {
        StringJoiner sj = new StringJoiner(",","[","]");

        sj.add("www").add("qqq");

        System.out.println(sj.length());

        System.out.println(sj.toString());
        
    }
}

小结：

字符串原理

小结：

练习一：

public class Demo5 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String next = null;
        while (true) {
            System.out.println("请输入字符串");
            next = sc.next();
            boolean verify = verify(next);
            if (verify){
                break;
            }else {
                System.out.println("你输入的字符串不符合规则，不是全部都是数字");
            }
        }
        //定义数组存放罗马数字，将数字与数组下标一一对应
        String[] arr = {"", "Ⅰ", "Ⅱ", "Ⅲ", "Ⅳ", "Ⅴ", "Ⅵ","Ⅶ", "Ⅷ", "Ⅸ"};

        //定义StringBuilder接收数据
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < next.length(); i++) {
            char charAt = next.charAt(i);
            String c = arr[(charAt-48)];
            sb.append(c);
        }
        String string = sb.toString();
        System.out.println(string);
    }
    public static boolean verify(String str){
        if (str.length()>9){
            return false;
        }
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i)<'0'||str.charAt(i)>'9'){
                return false;
            }
        }
        return true;
    }
}

可以使用switch来进行对应。

练习二：

方法一（使用substring方法进行换位）：

public class Demo6 {
    public static void main(String[] args) {
        String a = "abced";
        String b = "ceAab";
        //旋转
        boolean check = check(a, b);
        System.out.println(check);


    }
    public static boolean check(String a,String b){
        for (int i = 0; i < a.length(); i++) {
            a = revolve(a);
            if (a.equals(b)){
                return true;
            }
        }
        return false;
    }

    //旋转操作的方法
    public static String revolve(String str){
        //使用String的截取操作
        String s1 = str.substring(0, 1);
        String s2 = str.substring(1);
        String result = s2+s1;

        return result;
    }
}

方法二（使用字符数组进行换位）：

public class Demo6_2 {
    public static void main(String[] args) {
        String a = "abced";
        String b = "cedab";
        //旋转
        boolean check = check(a, b);
        System.out.println(check);


    }
    public static boolean check(String a,String b){
        for (int i = 0; i < a.length(); i++) {
            a = revolve(a);
            if (a.equals(b)){
                return true;
            }
        }
        return false;
    }

    //旋转操作的方法
    public static String revolve(String str){
        //使用字符数组换位值
        char[] charArray = str.toCharArray();
        char temp= charArray[0];
        for (int i = 1; i < charArray.length; i++) {
            charArray[i-1] = charArray[i];
        }
        charArray[charArray.length-1] = temp;
        String result = "";
        for (int i = 0; i < charArray.length; i++) {
            result = result+ charArray[i];
        }
        return result;
    }
}

作业二：

键盘输入任意字符串，打乱里面的内容

public class Work2 {
    public static void main(String[] args) {
        //键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
        String next = sc.next();
        //新建一个random对象
        Random r = new Random();
        //将String对象转化为char数组
        char[] chars = next.toCharArray();

        for (int i = 0; i < chars.length; i++) {
            //获取随机数，将随机数和当前的i互换位置
            int index = r.nextInt(chars.length);
            char temp = chars[i];
            chars[i] = chars[index];
            chars[index] = temp;
        }
        String result = "";
        for (int i = 0; i < chars.length; i++) {
            result = result+ chars[i];
        }
        System.out.println(result);
    }
}

作业三：

生成验证码

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

规则：

长度为5

内容中是四位字母，1位数字。

其中数字只有1位，但是可以出现在任意的位置。

将前面的练习改为方法进行调用：

public class Work3 {
    public static void main(String[] args) {
        String pa = pa();
        //将获得的字符串进行随机操作
        String s = suiJi(pa);
        System.out.println(s);
    }
    //String随机方法
    public static String suiJi(String next){
        //新建一个random对象
        Random r = new Random();
        //将String对象转化为char数组
        char[] chars = next.toCharArray();

        for (int i = 0; i < chars.length; i++) {
            //获取随机数，将随机数和当前的i互换位置
            int index = r.nextInt(chars.length);
            char temp = chars[i];
            chars[i] = chars[index];
            chars[index] = temp;
        }
        String result = "";
        for (int i = 0; i < chars.length; i++) {
            result = result+ chars[i];
        }
        return result;
    }
    //生出验证码的方法
    public static String pa(){
        //生成验证码
        Random r = new Random();
        //生成字符串接收验证码
        String ma = "";
        //根据i判断生成大写还是小写
        for (int j = 0; j < 4; j++) {
            int i = r.nextInt(2)+1;
            if (i==1){
                //生成大写
                char Char =  (char)(r.nextInt(26)+65);
                ma = ma + Char;
            } else if (i==2) {
                //生成小写
                char Char =  (char)(r.nextInt(26)+97);
                ma = ma + Char;
            }
        }
        //加入数字
        int i = r.nextInt(10);
        ma = ma + i;

        return ma;
    }
}

作业四：

请编写程序，由键盘录入一个字符串，统计字符串中英文字母和数字分别有多少个。比如：Hello12345World中字母：10个，数字：5个。

public class Work4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
        String next = sc.next();
        //记录数据
        int Ncount = 0;
        int Acount = 0;
        //将String传变为char数组，在进行判断
        char[] chars = next.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if (AorNumber(chars[i])==1){
                Acount++;
            }else if (AorNumber(chars[i])==2){
                Ncount++;
            }
        }
        System.out.println("字母有 "+Acount);
        System.out.println("数字有 "+Ncount);
    }
    //判断是字母还是数字
    public static int AorNumber(char a){
        if ((a>='A'&&a<='Z')||(a>='a'&&a<='z')){
            //字母 返回 1
            return 1;
        } else if (a>='0'&&a<='9') {
            //数字 返回2
            return 2;
        }else {
            //都不是
            return 3;
        }
    }
}

作业五：

请定义一个方法用于判断一个字符串是否是对称的字符串，并在主方法中测试方法。例如："abcba"、"上海自来水来自海上"均为对称字符串

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

        if (qwq(next)) {
            System.out.println("该字符串对称");
        }else {
            System.out.println("该字符串不对称");
        }
    }
    public static boolean qwq(String str){
        //定义StringBuilder对象
        StringBuilder sb = new StringBuilder(str);
        //调用反转方法
        String string = sb.reverse().toString();
        if (string.equals(str)){
            return true;
        }else {
            return false;
        }
    }
}

作业六：

我国的居民身份证号码，由由十七位数字本体码和一位数字校验码组成。请定义方法判断用户输入的身份证号码是否合法，并在主方法中调用方法测试结果。规则为：号码为18位，不能以数字0开头，前17位只可以是数字，最后一位可以是数字或者大写字母X。

public class Work6 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入身份证号");
        String next = sc.next();
        boolean verify = verify(next);
        System.out.println(verify);
    }

    public static boolean verify(String str) {
        //判断是否为18位
        if (str.length() == 18) {
            //判断第一位是否为0开头
            if (!(str.charAt(0) == '0')) {
                //判断前17位是否为数字
                for (int i = 0; i < str.length() - 1; i++) {
                    if (str.charAt(i) >= '0' && str.charAt(i) <= '9') {

                    } else {
                        return false;
                    }
                }
                //判断最后一位
                if ((str.charAt(str.length() - 1) >= '0' && str.charAt(str.length() - 1) <= '9') || (str.charAt(str.length() - 1) == 'X')) {

                } else {
                    return false;
                }
                return true;

            } else {
                return false;
            }
        } else {
            return false;
        }
    }
}

作业七：

定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。

public class work7 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        String pj = pj(arr);
        System.out.println(pj);


    }


    public static String pj(int[] arr){
        //定义一个StringJioner对象
        StringJoiner sj = new StringJoiner(",","[","]");
        for (int i = 0; i < arr.length; i++) {
            //arr[i]+""通过字符串加法将int类型变为String类型
            sj.add(arr[i]+"");
        }
        //sj转为String类型
        String string = sj.toString();
        return string;


    }
}

题目八：

在String类的API中，有如下两个方法：

// 查找参数字符串str在调用方法的字符串中第一次出现的索引，如果不存在，返回-1
public int indexOf(String str)

// 截取字符串，从索引beginIndex（包含）开始到字符串的结尾
public String substring(int beginIndex)

请仔细阅读API中这两个方法的解释，完成如下需求。

现有如下文本："Java语言是面向对象的，Java语言是健壮的，Java语言是安全的，Java是高性能的，Java语言是跨平台的"。请编写程序，统计该文本中"Java"一词出现的次数。

public class Work8 {
    public static void main(String[] args) {
        String str = "Java语言是面向对象的，Java语言是健壮的，Java语言是安全的，Java是高性能的，Java语言是跨平台的Java";
        int wk = wk(str);
        System.out.println(wk);
    }
    public static int wk(String str){
        int count = 0;
        String s = "Java";
        int i = 0;
        while (i != -1) {
            //获取索引并截取
            i = str.indexOf(s);
            if (i == -1){
                //当为-1时即未找到所给的字符串就跳出循环防止多加个数
                break;
            }
            //截取
            str = str.substring(i + s.length());

            count++;
        }
        return count;
    }
}

未命名冀

关注

8
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
javase复习day10（String，StringBuilder，StringJioner及其相关练习）

查询API：JDK-API帮助文档。Jdk-21的api帮助文档（中文版）注意点：字符串的内容不会发生改变，他的对象在创建后不能被改变。 String是java定义好的一个类。定义在java.long包下使用时不需要导包。 java程序中所有字符串文字都被视为此类的对象。创建String对象的两种方式：内存情况：字符串比较：键盘录入得到的字符串是new出来的。练习一：练习二：练习三：应该不需要放入char数组中（可以运
复制链接

扫一扫