JAVA基础-Day3-黑马跟课题目（String类、StringBuilder类、StringJoiner类）

太虚

已于 2024-02-01 12:51:28 修改

阅读量451

点赞数 14

文章标签： java 开发语言

于 2024-01-31 00:56:52 首次发布

本文链接：https://blog.csdn.net/2302_76949164/article/details/135944193

版权

一、String类题目

零、笔记部分

【String类相关API方法见链接（https://blog.csdn.net/2302_76949164/article/details/135960635?spm=1001.2014.3001.5501）】

String类型

基本数据类型比的是数据值，引用数据类型比的是地址值
字符串比较：一定不能用“==”
1.equals
2.equalsIgnoreCase忽略大小写

1.字符串遍历
charAt()根据索引返回字符结合for循环

2.字符串截取
String substring(int beiginIndex,int endindex)
包头不包尾，包左不包右
只有返回值才是截取的小串
String substring(int endindex)
截取到最后一位

3.字符串替换
String replace(旧值，新值)

StringBuilder类型

相当于一个字符串的容器
与String不同，StringBuilder类型的字符串可以改变
1.添加
append()
2.反转
reverse()
3.转换为String
toString()

字符串拼接和反转会用StringBuilder

StringJoiner类型

在字符串按格式拼接时，
StringJoiner比StringBuilder更简洁，操作效率也更高

构造方法
public StringJoiner(间隔符号)指定拼接时的间隔符号
public StringJoiner（间隔符号，开始符号，结束符号）
1.添加
add(),里面的内容要求是字符串类型
2.转换为字符串
toString()

一、模拟实现用户登录

import java.util.*;
public class StringDemo1 {
    public static void main(String[] args) {
        //模拟实现用户登录
        //1.定义正确的用户账户密码
        Scanner in=new Scanner(System.in);
        String rightUsername="Flyao";
        String rightPassword="123456789";

        //2.输入用户名密码,同时比较正确，给三次机会
        int sum=3;
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入账号：");
            String username=in.next();
            System.out.println("请输入密码：");
            String password=in.next();
            if(username.equals(rightUsername)&&password.equals(rightPassword)) {
                System.out.println("登陆成功");
                return;
            }
            sum--;
            if(sum==0)
                break;
            System.out.println("登录失败，密码错误，你还有"+sum+"次机会");
        }
        System.out.println("你已经用光了三次登录机会，账号自动注销");
}}

二、简单实现功能

1.定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回

import java.util.*;
public class StringDemo2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
         String a=in.nextLine();
        int Uppercount=0;
        int Lowcount=0;
        int numbercount=0;
        for (int i = 0; i < a.length(); i++) {
            char c=a.charAt(i);
            if(c>='a' && c<='z')
                Lowcount++;
            else if(c>='A' && c<='Z')
                Uppercount++;
            else if(c>'0'&& c<'9')
                numbercount++;
        }
        System.out.println("大写字母个数："+Uppercount);
        System.out.println("小写字母个数："+Lowcount);
        System.out.println("数字个数："+numbercount);
}}

2.定义一个方法，实现字符串反转


    public static String AddString(int[] arr)
    {
        //判断空
        if(arr==null)
            return "";
        String a="[";
        for (int i = 0; i < arr.length; i++) {
            a+=arr[i];
            if(i<arr.length-1)
                a+=',';
        }
        return a+']';

    }

3.键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数

public static String reverse(String a )
    {
        if(a==null)
            return null;
        String b="";
        for (int i = 0; i < a.length(); i++) {
            b+=a.charAt(a.length()-1-i);
        }
        return b;
    }

三、金额转换：把数字转换为汉字带单位

import java.util.*;
public class StringDemo3 {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        //金额转换：把数字转换为汉字带单位
        //1.制定规则：哪个数字对应哪个汉字
        //输入字符串，转换为字符数组
        String money="零壹贰叁肆伍陆柒捌玖";
        String unit="元拾佰仟万拾佰";
        char[] mon=money.toCharArray();
        char[] uni=unit.toCharArray();
        //此时汉字对应数组序号

        //2.输入金额数，按先后顺序在其后加入单位
        int count=0,cou=0;
        int m=in.nextInt();
        int x=m;//存一下金额
        String endmoney="";
        while(count<7)
        {
            //先把数字转换为汉字
            endmoney+=uni[count];
            endmoney+=mon[x%10];
            count++;//计数器保证七个单位
            if(x!=0)
                cou++;//存一下金额位数
            x/=10;
        }
        String endmoney1="";
        for (int i = endmoney.length()-1; i >= 0; i--) {
            endmoney1+=endmoney.charAt(i);//把逆序转为顺序
        }
        System.out.println(endmoney1);
    }
}

四、手机号隐私化

例如：13753946834 -> 137****6834(此号是随便输的，不要拨打)

import java.util.*;
public class StringDemo4 {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        //1.获取一个手机号码
        String phonenum=in.next();

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

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

        String number=start+"****"+end;
        System.out.println(number);

}
}

五、由身份证号码提取个人信息

由身份证号码提取出生年月日和性别，对应：7-14位出生日期；17位奇数为男、偶数为女

import java.util.*;
public class StringDemo4 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext())//增加一个循环输入，方便输入输出
        {
            String humancard=in.next();//输入身份证号码
            if(!identify(humancard))//身份证号码判断正误
                continue;
            //生日信息引用
            String birthday=findBirthday(humancard);
            System.out.println("个人信息："+"\n"+"出生年月日:");
            System.out.println(birthday);
            //输出性别信息
            printSex(humancard);
        }

}
    public static boolean identify(String humancard)
    {//根据输入的身份证号码够不够18位来判断正误
        if(humancard.length()!=18 )
        {
            System.out.println("身份证号码输入错误，请重新输入");
            return false;
        }
        return true;
    }
    public static String findBirthday(String humancard)
    {//根据身份证号7-14位制定出生年月日信息字符串
        //提取生日数字
        String birth=humancard.substring(6,14);
        //提取年
        String year=birth.substring(0,4);
        //提取月
        String month=birth.substring(4,6);
        //增加一个对月份的十位数是否为0的判断
        if(birth.substring(4,5).equals("0"))
            month=birth.substring(5,6);
        //提取日
        String day=birth.substring(6,8);
        //增加一个对日期的十位数是否为0的判断
        if(birth.substring(6,7).equals("0"))
            day=birth.substring(7,8);
        //整合
        String birthday=year+"年"+month+"月"+day+"日";
        return birthday;
    }
    public static void printSex(String humancard)
    {//根据身份证号第17位奇偶情况判断性别
        //提取性别数字
        char sex=humancard.charAt(16);
        //char类型转int进行运算
        if((int)sex %2 ==1)
            System.out.println("性别：男");
        else
            System.out.println("性别：女");
    }
}

六、敏感词替换

仿照王者荣耀评论机制，一个简单的敏感词替换，把敏感词替换为“***”

此处脏字脏话均为题目需要，与本人无关

import java.util.Scanner;

public class StringDemo5 {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        //敏感词替换，把脏字替换为***
        while(in.hasNextLine())
        {
            //1.获取说的话
            String talk=in.nextLine();
            //2.定义一个敏感词库
            String[] dirty={"TMD","tmd","cnm","CNM",
                    "妈","ma","mlgb","MLGB",
                    "cao","SB"};
            //3.循环检测并依次取代敏感词
            for (int i = 0; i < dirty.length; i++) {
                talk=talk.replace(dirty[i],"***");
            }
            System.out.println(talk);
        }
    }
}

二、StringBuilder类题目

一、基础功能试用

import java.util.Scanner;

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

        //2.添加元素
        sb.append(1);
        sb.append(2.3);
        sb.append(true);
        sb.append("我爱你");
        //2.1链式编程
        //sb.append(1).append(2.3).append(true).append("我爱你");

        //3.反转
        sb.reverse();

        //4.获取长度
        System.out.println("sb长度为："+sb.length());

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

        //5.变回String类型
        String str=sb.toString();
        System.out.println("str的值为："+str);
    }
}

二、对称字符串检验方法

对称字符串：写一个方法，判断字符串是不是对称的

public static boolean isMirror(String a)
    {//检验字符串是不是对称的，不用循环
        if(a==null)
            return false;
        StringBuilder sb=new StringBuilder(a);
        String sb1=sb.reverse().toString();
        //试错好几次，调试后发现：
        //StringBuilder是自带返回值的，与String不同
        //sb.reverse()调用之后，sb自己就已经变成反转后的结果了
        //这说明String类型字符串不可以自变，StringBuilder可以自变
        //因此比较之前，要把sb再转换成String类型
        if(sb1.equals(a))
            return true;
        return false;
    }

三、拼接字符串方法

拼接字符串，定义一个方法，把int数组中的数据按指定格式拼接成一个字符串输出结果为：[1,2,3]

public static String AppendS(int[] a)
    {//用StringBuilder自带的append方法拼接字符串写起来很爽
        //只要最后再转换回String类型就可以
        if(a==null)//要判断a是否存在
            return null;
        StringBuilder sb=new StringBuilder("[");
        for (int i = 0; i < a.length; i++) {
            if(i<a.length-1)
                sb.append(a[i]).append(',');
            else
                sb.append(a[i]);
        }
        sb.append(']');
        String s=sb.toString();
        return s;
    }

四、转换罗马数字

键盘录入一个字符串
要求1：长度小于等于9
要求2：只能是数字
将内容变成罗马数字
注意点：
罗马数字里面是没有0的
如果键盘录入的数字包含0，可以变成“ ”（长度为0的字符串）

1.方法一：罗马数组库

1.主函数

import java.util.Scanner;

public class StringBuilderDemo2 {
    public static void main(String[] args) {
        Scanner in =new Scanner(System.in);
        String[] roma={"","I"," II "," III "," IV "," V "," VI "," VII "," VIII "," IX "};
        while(in.hasNext())
        {
            System.out.println("请输入一串纯数字");
            String number=in.nextLine();
            if(number.length()>9)//长度小于等于9
                continue;
            if(!isDigit(number))//纯数字
                continue;
            else
            {
                StringBuilder sb=new StringBuilder();
                for (int i = 0; i < number.length(); i++) {
                    sb.append(roma[number.charAt(i)-48]);
                    //字符串拼接，调用数组，数组的下标是输入字符串的遍历-48（ascll码）
                }
                String s=sb.toString();
                System.out.println(s);
            }
        }


    }
    
}

2.方法：检验是否为纯数字

public static boolean isDigit(String number)
    {//检验是否为纯数字
        for (int i = 0; i < number.length(); i++) {
            if(number.charAt(i)<48 || number.charAt(i)>57)
            {
                System.out.println("输入非纯数字，错误");
                return false;
            }
        }
        return true;
    }

2.方法二：switch方法新写法

1.主函数

import java.util.Scanner;
public class StringBuilderDemo2 {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        while(in.hasNext())
        {
            System.out.println("请输入符合要求的纯数字");
            String number=in.nextLine();
            if(number.length()>9 || !isDigit(number))
            {
                System.out.println("不符合要求，请重新输入");
                continue;
            }
            else
            {
                StringBuilder roma=new StringBuilder();
                for (int i = 0; i < number.length(); i++) {
                    roma.append(Romaword(number.charAt(i)));
                }
                System.out.println("转换罗马数字为：");
                System.out.println(roma);
            }
        }
    }
    
}

2.方法：罗马数字库

public static String Romaword(char a)
    {//罗马数字库
        String s=switch(a)
        {
            case '0'->"";
            case '1'->" I ";
            case '2'->" II ";
            case '3'->" III ";
            case '4'->" IV ";
            case '5'->" V ";
            case '6'->" VI ";
            case '7'->" VII ";
            case '8'->" VIII ";
            case '9'->" IX ";
            default -> "";
        };
        return s;
    }

3.方法：检验是否为纯数字

public static boolean isDigit(String number)
    {//检验是否为纯数字
        for (int i = 0; i < number.length(); i++) {
            if(number.charAt(i)<48 || number.charAt(i)>57)
            {
                System.out.println("输入非纯数字，错误");
                return false;
            }
        }
        return true;
    }

五、打乱字符串

输入任意一串字符串，打乱并输出它

1.主函数

import java.util.*;
public class StringBuilderDemo4 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        //输入一串字符串
        System.out.println("输入你的话");
        String sentence=in.nextLine();
        //把字符串拆分成字符数组
        char[] sen=sentence.toCharArray();
        //输出结果
        System.out.println("打乱后是这样的：");
        System.out.println(Newsen(sen));//键盘输入字符串，打乱之
    }
}

2.方法 :打乱字符串

public static String Newsen(char[] sen)
    {//产生打乱字符串的方法
        StringBuilder newsen=new StringBuilder();
        Random r=new Random();
        //把字符数组里的元素随机拼接到新的空字符串里
        for (int i = 0; ; i++) {//for循环的长度是不知道的，完全随机
            //因为完全随机，因此不可避免出现重复元素，要制定判断方法进行规避
            if(sen.length== newsen.length())
                break;//循环结束条件
            int ran=r.nextInt(sen.length);
            //随机数作为字符数组的下标
            //元素是否重复的判断方法，元素为int就用-1，char就用0
            if(sen[ran]==0)
                continue;
            newsen.append(sen[ran]);
            //拼接完以后给这个数组元素赋空，下一次就不会再重复拼接了
            sen[ran]=0;
        }
        String a=newsen.toString();
        return a;
    }

六、调整比较字符串

给定a、b两个字符串，a的最左边元素不断移到最右面，若是能与b相等，就输出相等，否则就是八竿子打不着

1.主函数

import java.util.Scanner;

public class StringBuilderDemo3 {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        System.out.println("请输入字符串a");
        StringBuilder a= new StringBuilder(in.nextLine());
        System.out.println("请输入字符串b");
        StringBuilder b= new StringBuilder(in.nextLine());
        if (isEqual(a,b))
            System.out.println("a调整之后能得到b");
        else
            System.out.println("a和b八竿子打不着关系");
    }
}

2.判断a旋转后能否得到b的方法

public static boolean isEqual(StringBuilder a,StringBuilder b)
    {//一边旋转a,一边判断a和b是否相等
        for (int i = 0; i < a.length()-1; i++) {
            if(a.toString().equals(b.toString()))
            {//String类型的equals与StringBuilders的有本质区别，要用String的
                return true;
            }
            a.append(a.charAt(0)).deleteCharAt(0);
            //链式代码，先拼接字符，每次只拼接最左边的字符，拼完就删掉
        }
        return false;
    }

七、生成验证码

随机生成四位字母加一位数字验证码，数字的位置任意

1.主函数

import java.util.*;
public class StringBuilderDemo4 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        char[] word=new char[52];
        //存入字母库
        word=Word(word);
        //调用方法
        System.out.println(Code(word));
         //生成五位验证码：四位字母（大写字母、小写字母）和一位数字,数字的位置任意
    }
}

2.字母库方法

public static char[] Word(char[] word)
    {//构建字母库
        for (int i = 0; i < 52; i++) {
            if(i<26)
                word[i]=(char)('a'+i);
            else
                word[i]=(char)('A'+i-26);
        }
        return word;
    }

3.生成验证码方法

public static String Code(char[] word)
    {//生成验证码
        Random r=new Random();
        StringBuilder s=new StringBuilder();
        for(int i=0;i<4;i++)
        {//先生成4位随机字母字符串
            int ran=r.nextInt(52);
            s.append(word[ran]);
        }
        //再生成一位数字随机数
        int ran=r.nextInt(10);//数字随机数
        int ran1=r.nextInt(4);//在四位字母串里找任意一个位置
        s.insert(ran1,ran);//插入任意位置，括号里，前是插入的位置，后是插入的内容
        return s.toString();
    }

八、数字字符串求乘积

输入两串纯数字字符串，计算乘积（乘积结果小于int）

1.主函数

import java.util.*;
public class StringBuilderDemo4 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
      System.out.println("请输入A的值：");
        //为方便方法里从高到低遍历，在这里直接把数字字符串逆序
        StringBuilder a1=new StringBuilder(in.next());
        String a=a1.reverse().toString();
        System.out.println("请输入B的值：");
        StringBuilder b1=new StringBuilder(in.next());
        String b=b1.reverse().toString();
        int a2=GetA(a);
        int b2=GetB(b);
        long c=a2*b2;
        System.out.println("A*B="+c);
    }
    
         //输入两串数字字符串，输出其乘积，也以字符串的形式表现。
}

2.方法：A数字字符串转数字

public static int GetA(String a)
    {//把字符串转为字符数组，然后遍历逐个数字组成新的int数
        char[] a1=a.toCharArray();
        int a2=0;
        a2+=(a1[0]-48);
        for (int i = 1; i < a1.length; i++) {
            a2+=(a1[i]-48)*10;
        }
        return a2;
    }

3.方法：B数字字符串转数字

public static int GetB(String b)
    {
        char[] b1=b.toCharArray();
        int b2=0;
        b2+=(b1[0]-48);
        for (int i = 1; i < b1.length; i++) {
            b2+=(b1[i]-48)*10;
        }
        return b2;
    }

九、字符串求最后一个单词

给一个字符串s,由若干单词构成，单词之间由空格隔开，现求最后一个单词的长度,单词里是没有特殊字符的

import java.util.*;
public class StringBuilderDemo4 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
      String s=in.nextLine();
        String[] s1=s.split(" ");//split为新方法，将字符串以括号内为标志分进字符串数组内
        System.out.println(s1[s1.length-1].length());//直接输出
         
}

三、StringJoiner类题目

一、拼接字符串方法（StringBuilder题目三优化）

public static String AppendS1(int[] a)
    {//StringJoiner方法，较之StringBuilder更加高效简洁，增加了代码的阅读效率
        if(a==null)
            return null;
        StringJoiner sj=new StringJoiner(",","[","]");
        for (int i = 0; i < a.length; i++) {
            sj.add(a[i]+"");
        }
        String s = sj.toString();
        return s;
    }