苦学Java笔记（day10）

最新推荐文章于 2024-05-13 19:51:02 发布

小燕子的后花园

最新推荐文章于 2024-05-13 19:51:02 发布

阅读量586

点赞数 7

文章标签： java 笔记

本文链接：https://blog.csdn.net/m0_70783969/article/details/138053021

版权

文章目录

一、API
二、字符串

一、API

Application Programming Interface：应用程序编程接口
简单理解：API就是别人已经写好的东西，我们不需要自己编写，直接使用即可。
Java API：指的是JDK中提供的各种功能的Java类
API帮助文档：帮助开发人员更好地使用API和查询API的一个工具
这些类将底层的实现封装起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。
将来还会学习其他知识，还会有很多的API。
已经学过的API：
Scanner 键盘录入
Random 随机数

二、字符串

字符串和任意数据类型相加，做的都是拼接操作，生成一个新的字符串

1.字符串相关的API

（1）String

String概述

java.lang包下，是Java的核心包，使用时不需要导包
字符串的内容是不会发生改变的，它的对象在创建后不能被更改

String name = "尼古拉斯·阿玮";
String schoolName = "黑马程序员";
System.out.println(name + schoolName);//字符串拼接产生一个新的字符串

String name = "尼古拉斯·阿玮";
name = "三连加投币·阿玮";
//将一个新的字符串赋值给了name字符串，并没有改变“尼古拉斯·阿玮”里面的内容
//一共产生了2个字符串

创建String对象

①直接赋值

String name = "尼古拉斯·阿玮";

②new

构造方法	说明
public String()	创建空白字符串（“”），不含任何内容（不常用）
public String(String original)	根据传入的字符串，创建字符串对象（不常用）
public String(char[] chs)	根据字符数组，创建字符串对象（运用于修改字符串内容）
public String(byte[] chs)	根据字节数组，创建字符串对象（将传输的字节信息（看不懂）转换成字符串（看得懂））

char[] chs = {'a','b','c','d'};
String s1 = new String(chs);
System.out.println(s1);//"abcd"

byte[] bytes = {97,98,99,100};
String s2 = new String(bytes);
System.out.println(s2);//"abcd"

内存原理

①直接赋值（更节约内存）

String Table（串池）

只有直接赋值的字符串在存储在串池中
JDK7以前，在方法区中
JDK7开始，从方法区挪到堆内存当中

public class StringDemo {
	publci static void main(String[] args){
		String s1 = "abc";//直接赋值时，系统会检查串池中是否存在该字符串，不存在，则创建新的，并将该字符串的地址存储到该变量（s1）中
		String s2 = "abc";//如果存在，则复用（将串池中该字符串的地址赋值给该变量（s2）
	}
}

②new

public class StringDemo{
	public static void main(String[] args){
		char[] chs = {'a','b','c'};在堆中创建一个字符数组
		String s1 = new String(chs);//在堆中创建一个字符串，内容为“abc”，并将地址值赋给栈中的s1
		String s2 = new String(chs);//虽然堆中已经有了字符串“abc”，但不会复用，还是会在堆中创建一个新的字符串，并将该地址值赋值给栈中变量s2（会浪费内存空间）
	}
}

字符串比较

”=“比的是什么

如果是基本数据类型，比的是数据值；
如果是引用数据类型，比的是地址值。

int a = 10;
int b = 20;
System.out.println(a == b);//true

String s1 = new String ("abc");
String s2 = new String("abc");
System.out.println(s1 == s2);//false

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);//true

String s1 = new String ("abc");
String s2 = "abc";
System.out.println(s1 == s2);//一个是堆中，一个是串池 -> false

①equals

完全一样结果才是true，否则为false

String s1 = new String("abc");
String s2 = "abc";
System.out.println(s1.equals(s2));//true

②equalsIgnoreCase

忽略（英文字母的）大小写的比较（如：验证码）

String s1 = new String("abc");
String s2 = "Abc";
System.out.println(s1.equalsIgnoreCase(s2));//true

String s1 = sc.next();//IDEA看源码：Ctrl+B键盘录入最终得到的字符串是new出来的（堆）
String s2 = "abc";直接赋值（栈）
System.out.println(s1 == s2);//false

结论：
以后只要想比较字符串的内容，就必须要用String里面的方法（equals or equalsIgnoreCase）

字符串练习

①用户登录

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

import java.util.Scanner;
public class StringDemo1{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String username = "heima";
        String password = "1234";
        int count = 3;
        System.out.println("请输入用户名");
        if((sc.next()).equals(username)){
            while(count > 0){
                System.out.println("请输入密码");
                if((sc.next()).equals(password)){
                    System.out.println("登陆成功");
                    break;
                } else {
                    count--;
                    System.out.println("输入错误，还有" + count +"次机会");
                }
            }
            if(count == 0){
                System.out.println("机会已用完，登录失败");
            }
        } else {
            System.out.println("用户名输入错误");
        }

    }
}

IDEA语句包裹：Ctrl+Alt+T

import java.util.Scanner;
public class Demo1{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String rightUsername = "heima";
        String rightPassword = "1234";
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入用户名");
            String username = sc.next();
            System.out.println("请输入密码");
            String password = sc.next();
            if(username.equals(rightUsername) && password.equals(rightPassword)){
                System.out.println("登陆成功");
                break;
            }else{
                if(i == 2){
                    System.out.println("三次机会已用完，账号已被锁定");
                } else{
                    System.out.println("登录失败，用户名或密码错误，还有" + ( 2 - i ) + "次机会");
                }
            }
        }
    }
}

②遍历字符串

需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
public char charAt(index)//根据索引返回字符
public int length()//返回字符串的长度
数组的长度（是一个属性）：数组名.length
字符串的长度（是一个方法）：字符串对象.length()

import java.util.Scanner;
public  class StringDemo2{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
        String s = sc.next();
        for(int i = 0;i < s.length();i++){//s.length.fori + 回车
            System.out.print(s.charAt(i) + " ");
        }
    }
}

③统计字符次数

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

import java.util.Scanner;
public class StringDemo3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入待统计的字符串");
        String s = sc.next();
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        for(int i = 0;i < s.length();i++){
            if(s.charAt(i) >= 'A' && s.charAt(i) <= 'Z'){//char在计算时，会提升为int（查询ASCII码表）
                bigCount++;
            } else if(s.charAt(i) >= 'a' && s.charAt(i) <= 'z'){
                smallCount++;
            }else if(s.charAt(i) >= '0' && s.charAt(i) <= '9'){
                numberCount++;
            }
        }
        System.out.println("输入的字符串中大写字母有" + bigCount + "个");
        System.out.println("输入的字符串中小写字母有" + smallCount + "个");
        System.out.println("输入的字符串中数字有" + numberCount + "个");
    }
}

④拼接字符串

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

//不使用方法
public class StringDemo4{
	public static void main(String[] args){
		int [] arr = {1,2,3};
		String s ="[";
		for(int i = 0;i < arr.length;i++){
			if(i == arr.length - 1){
				s = s + arr[i] + "]";
			} else {
				s = s + arr[i] + ",";
			}
		}
		System.out.println(s);
	}
}

//定义一个方法
public class Demo2{
	public static void main(String[] args){
		int [] arr = {1,2,3};
		System.out.println(contage(arr));
	}
	public static String contage(int [] arr){
		if(arr == null){
			return "";
		} 
		if(arr.length == 0){//int [] arr = new int [0];数组的长度可以为0
			return "[]";
		}
		String s ="[";
		for(int i = 0;i < arr.length;i++){
			if(i == arr.length - 1){
				s = s + arr[i] ;
			} else {
				s = s + arr[i] + ",";
			}
		}
		s = s + "]";
		return s;
	}
}

⑤字符串反转

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

import java.util.Scanner;
public class StringDemo5{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入待反转的字符串");
        String s = sc.next();
        System.out.println(reverse(s));
    }
    public static String reverse(String s){
        String result = "";
        for(int i = s.length() - 1;i >= 0;i--){//s.length()forr + 回车
            result += s.charAt(i);
        }
        return result;
    }
}

⑥金额转换

import java.util.Scanner;
public class StringDemo6{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int number;
        int money;
        String[] array = {"元","拾","佰","仟","万","拾","佰"};
        String s ="";
        while(true){
        	System.out.println("请输入金额");
     	   	money = sc.nextInt();
     	   	if(money >= 0 && money <= 9999999){
     	   		break;
     	   	}else{
     	   		System.out.println("金额无效");
     	   	}
        }
        for(int i = 0;i < 7;i++){
            number = money % 10;
            money /= 10;
            s = getCapitalNumber(number) + array[i] + s;//每一位上的数字个数和单位的个数相同，可以用同一个索引。也可以利用一个循环，将每一位上数字的大写与单位在同一行输出，但是不好，并没有得到数字转换成大写中文的字符串
        }
        System.out.println(s);
    }
    public static String getCapitalNumber(int number){
        String[] arr = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};//查表法
        return arr[number];
    }
}

⑦手机号屏蔽

import java.util.Scanner;
public class StringDemo7{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号");
        String phoneN = sc.next();
        String s = "";
        for(int i = 0; i < 3;i++){
            s += phoneN.charAt(i);
        }
        for(int i = 3;i < 7;i++){
            s += "*";
        }
        for(int i = 7;i <11;i++){
            s += phoneN.charAt(i);
        }
        System.out.println("屏蔽后的电话号码为" + s);
    }
}

substring

String substring(int beginIndex,int endIndex) 截取
注意点：包头不包尾，包左不包右
只有返回值才是截取的小串，不对原串作改变

phoneNumber.substring(0,3);
System.out.println(phoneNumber);//仍是原来输入的完整电话号码，要想得到截取后的字符串，用一个字符串接收返回值，打印该字符串

String substring(int beginIndex) 截取到末尾

import java.util.Scanner;
public class Demo3{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号");
        String phoneN = sc.next();
        String s = "";
            s += phoneN.substring(0,3);;
        for(int i = 3;i < 7;i++){
            s += "*";
        }
        s += phoneN.substring(7);//截取到末尾
        System.out.println("屏蔽后的电话号码为" + s);
    }
}

⑧身份证信息查看⑨

7～14位：出生年、月、日
17位：性别（奇数男性，偶数女性）
人物信息位：
出生年月日：XXXX年X月X日
性别位：男/女

import java.util.Scanner;
public class StringDemo8{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String birthday ="";
        String gender;
        System.out.println("请输入身份证号码");
        String id = sc.next();
        birthday = birthday + id.substring(6,10) + "年" + id.substring(10,12) + "月" + id.substring(12,14) + "日";
        if((id.charAt(16) - '0') % 2 == 0){//字符变成数字
            gender = "女";
        } else {
            gender = "男";
        }
        System.out.println("出生年月日：" + birthday);
        System.out.println("性别：" + gender);
    }
}

⑨敏感词替换

repalce

String replace(旧值,新值) 替换
注意点：只有返回值才是替换之后的结果

import java.util.Scanner;
public class StringDemo9{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String[] arr = {"TMD","CNM","SB","MLGB"};//定义一个敏感词库
        System.out.println("请输入内容");
        String s = sc.next();
        for(int i = 0;i < arr.length;i++){//循环替换
        	s = s.replace(arr[i],"***");//有，就替换；没有，就不替换
        }
        System.out.println("替换后：" +  s);
    }
}

（2）StringBuilder

StringBuilder可以看成是一个容器，创建之后里面的内容是可变的
作用：提高字符串的操作效率

public class Test{
	public static void main(String[] args){
		String s = "";
		for(int i = 0;i < 1000000;i++){
			s = s + "abc";//会产生很多没用的字符串
		}
		System.out.println(s);//很慢
	}
}

public class Test{
	public static void main(String[] args){
		StringBuilder sb = new StringBuilder("");;
		for(int i = 0;i < 1000000;i++){
			sb.append("abc");
		}
		System.out.println(sb);
	}
}

StringBuilder构造方法

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

方法名	说明
public StringBuilder()	创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象

StringBuilder成员方法

方法名	说明
public StringBuilder append(任意类型)	添加数据，并返回对象本身
public StringBuilder reverse()	反转容器中的内容（容器内的内容可以变化）
public int length()	返回长度（字符出现的个数）
public String toString()	通过toString()就可以实现把StringBuilder转换为String

链式编程

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

int len = getString().substring(1).replace('A','Q').length();
System.out.println(len);

sb.append("aaa");
sb.append("bbb");
sb.append("ccc");

链式编程（返回值还是一个StringBuilder，可以继续用append添加）

sb.append("aaa").append("bbb").append("ccc");

对称字符串

需求：键盘接收一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是
对称字符串：123321、111
非对称字符串：123123

import java.util.Scanner;
public class StringBuilderDemo1{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入待判断的字符串");
        String str = sc.next();
        String original = str;
        StringBuilder sb = new StringBuilder(str);
        String result = sb.reverse().toString();
        if(result.equals(original)){
            System.out.println("是");
        } else {
            System.out.println("不是");
        }
    }
}

使用场景

①字符串拼接

②字符串反转

拼接字符串（用StringBuilder更快）

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

public class StringBuilderDemo2{
	public static void main(String[] args){
		int [] arr = {1,2,3};
		printArr(arr);
	}
	public static void printArr(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]).append(",");
			}
		}
		String s = sb.append("]").toString();
		System.out.println(s);
	}
}

（3）StringJonier

StringJoiner跟StringBilder一样，也可以看成是一个容器，创建之后里面的内容是可变的。
作用：提高字符串的操作效率，而且代码编写特别简洁，但是目前市场上很少有人用（JDK8才出现）。

import java.util.StringJoiner;
public class Text {
    public static void main(String[] args){
        int [] arr = {1,2,3};
        StringJoiner sj = new StringJoiner(",","[","]");
        for(int i = 0;i < arr.length;i++){
            sj.add(arr[i] + "");
        }
        System.out.println(sj);
    }
}

StringJoiner的构造方法

方法名	说明
public StringJoiner(间隔符号)	创建一个StringJoiner对象，指定拼接时的间隔符号
public StringJoiner(间隔符号,开始符号,结束符号)	创建一个StringJoiner对象，指定拼接时的间隔符号、开始符号、结束符号

StringJoiner的成员方法

方法名	说明
public StringJoiner add(添加的内容)	添加数据，并返回对象本身
public int length()	返回长度（所有字符的总个数）
public String toString	返回一个字符串（该字符就是拼接之后的结果）

2.字符串原理

（1）字符串拼接的底层原理

①等号右边没有变量

触发字符串的优化机制，在编译的时候就已经是最终的结果了。

②等号右边有变量

JDK8以前

底层会先创建一个StringBuilder对象，再用append拼接，最后利用toString转成字符串，而toString底层是new了一个字符串对象。

public class Text{
	public static void main(String[] args){
		//相当于：
		//new StringBuilder().append(s1).append("b").toString();
		String s1 = "a";
		String s2 = s1 + "b";
	}
}

IDEA看源码：Ctrl+B

JDK8以后

先预估最终字符串的长度，创建一个数组，将每个字符串存入数组中，再将数组转化成字符串

结论

如果有很多字符串变量拼接，不要直接+。底层会创建多个对象，浪费时间，浪费性能，建议用：StringBuilder或StringJoiner。

常见面试题

public class Text{
	public static void main(String[] args){
		String s1 = "abc";//串池中的地址值
		String s2 ="ab";
		String s3 = s2 + "c";
		System.out.println(s1 == s3);//false
		/*等号右边有变量：
		JDK8以前：使用StringBuilder中的toString，也即new出来的
		JDK8以后：创建一个数组，再将数组转化成字符串，也是new了一个数组*/
	}
}

public class Text{
	public static void main(String[] args){
		String s1 = "abc";
		String s2 = "a" + "b" + "c";//等号右边没有变量，触发字符串的优化机制，将"a" + "b" + "c"直接拼接为“abc”，复用串池中的“abc”的地址值
		System.out.println(s1 == s2);//true
	}
}

（2）StringBuilder源码分析

StringBuilder在刚开始创建的时候，底层会创建一个字节数组，默认容量是16
容量：最多能装多少 sb.capacity() 容量
长度：实际装了多少 sb.length() 长度
如果添加的元素超过了16，就会扩容：创建一个新的数组：16*2 + 2 = 34
如果添加的元素超出默认扩容的34，扩容之后还不够，以实际长度为准。
IDEA看源码：按住Ctrl不松，用鼠标左键点击

3.综合练习

（1）转换罗马数字

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

//查表法
import java.util.Scanner;
public class TextDemo1{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String [] arr = {"","Ⅰ","Ⅱ","Ⅲ","Ⅳ","Ⅴ","Ⅵ","Ⅶ","Ⅷ","Ⅸ"};
        String s;
        while(true){
            System.out.println("请输入阿拉伯数字");
            s = sc.next();
            if(checkStr(s)){
                break;
            }else {
                System.out.println("输入内容不符合要求");
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            sb.append(arr[i]);
        }
        System.out.println(sb.toString());
    }
    public static boolean checkStr(String str){
        if(str.length() > 9){
            return false;
        } else {
            for(int i = 0;i < str.length();i++){
                if(str.charAt(i) < '0' ||  str.charAt(i) > '9'){
                    return false;
                }
            }
        }
        return true;
    }
}

IDEA：Alt+回车，切割变量

//switch
import java.util.Scanner;
public class TextDemo1{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String s;
        while(true){
            System.out.println("请输入阿拉伯数字");
            s = sc.next();
            if(checkStr(s)){
                break;
            }else {
                System.out.println("输入内容不符合要求");
            }
        }
        StringBuilder sb = new StringBuilder();
        for(int i = 0;i < s.length();i++){
            sb.append(transformLuoMa(s.charAt(i)));
        }
        System.out.println(sb.toString());
    }
    public static boolean checkStr(String str){
        if(str.length() > 9){
            return false;
        } else {
            for(int i = 0;i < str.length();i++){
                if(str.charAt(i) < '0' ||  str.charAt(i) > '9'){
                    return false;
                }
            }
        }
        return true;
    }
    public static String transformLuoMa(char number){
        String str;
        switch(number){
            case '0' -> str = "";
            case '1' -> str = "Ⅰ";
            case '2' -> str = "Ⅱ";
            case '3' -> str = "Ⅲ";
            case '4' -> str = "Ⅳ";
            case '5' -> str = "Ⅴ";
            case '6' -> str = "Ⅵ";
            case '7' -> str = "Ⅶ";
            case '8' -> str = "Ⅷ";
            case '9' -> str = "Ⅸ";
            default -> str = "";
        }
        //JDK12新特性：
    	/*String str = switch(number){
                case '0' -> "";//把双引号引起的内容赋值给str
                case '1' -> "Ⅰ";
                case '2' -> "Ⅱ";
                case '3' -> "Ⅲ";
                case '4' -> "Ⅳ";
                case '5' -> "Ⅴ";
                case '6' -> "Ⅵ";
                case '7' -> "Ⅶ";
                case '8' -> "Ⅷ";
                case '9' -> "Ⅸ";
                default -> "";
        };//记得要加一个分号！
        */
        return str;
    }
}

（2）调整字符串

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

import java.util.Scanner;
public class TextDemo2{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串A");
        String before = sc.next();
        System.out.println("请输入字符串B");
        String target = sc.next();
        String after = before;
        int i;
        for(i = 0;i < before.length();i++){
            after = adjust(after);
            if(after.equals(target)){
                System.out.println("A经过调整能变成B");
                break;
            }
        }
        if(i == before.length()){
            System.out.println("A经过调整不能变成B");
        }
    }
    public static String adjust(String before){
        StringBuilder after = new StringBuilder();
        char [] arr = new char[before.length()];
        arr[before.length() - 1] =before.charAt(0);
        for(int i = 1;i < before.length();i++){
            arr[i - 1] = before.charAt(i);
        }
        for(int i = 0; i < arr.length;i++){
            after = after.append(arr[i]);
        }
        return after.toString();
    }
}

toCharArray

将字符串变成一个字符数组

import java.util.Scanner;
public class TextDemo2{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串A");
        String before = sc.next();
        System.out.println("请输入字符串B");
        String target = sc.next();
        String after = before;
        int i;
        for(i = 0;i < before.length();i++){
            after = adjust(after);
            if(after.equals(target)){
                System.out.println("A经过调整能变成B");
                break;
            }
        }
        if(i == before.length()){
            System.out.println("A经过调整不能变成B");
        }
    }
    public static String adjust(String before){
        char [] arr = before.toCharArray();
        arr[before.length() - 1] =before.charAt(0);
        for(int i = 1;i < before.length();i++){
            arr[i - 1] = before.charAt(i);
        }
        String result = new String(arr);//把字符数组变成字符串
        return result;
    }
}

import java.util.Scanner;
public class TextDemo2{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串A");
        String before = sc.next();
        System.out.println("请输入字符串B");
        String target = sc.next();
        String after = before;
        int i;
        for(i = 0;i < before.length();i++){
            after = adjust(after);
            if(after.equals(target)){
                System.out.println("A经过调整能变成B");
                break;
            }
        }
        if(i == before.length()){
            System.out.println("A经过调整不能变成B");
        }
    }
    //用substring和charAt，直接返回字符串
    public static String adjust(String before){
        char first = before.charAt(0);
        String end = before.substring(1);
        return end + first;
    }
}

（3）打乱字符串

import java.util.Scanner;
import java.util.Random;
public class TextDemo3{
    public static void main(String[] args){
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要打乱的字符串");
        String before = sc.next();
        char [] arr = before.toCharArray();
        for(int i = 0;i < arr.length;i++){
            int j = r.nextInt(arr.length);
            char tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            //只随机一次，不要写成：
            /*
            char tmp = arr[i];
            arr[i] = arr[r.nextInt(arr.length)];
            arr[r.nextInt(arr.length)] = tmp；
             这样就随机了两次，就不是打乱数组了*/
        }
        String after = new String(arr);
        System.out.println("打乱后字符串变为" + after);
    }
}

（4）生成验证码

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

import java.util.Random;
public class TextDemo4{
    public static void main(String[] args){
        Random r = new Random();
        char [] chs = new char[52];//创建一个数组，里面有大写和小写字母
        //给所创建的字符数组，赋值：大写和小写字母
        for(int i = 0;i < chs.length / 2;i++){

            chs[i] = (char)('a' + i);
        }
        for(int i = chs.length / 2;i < chs.length;i++){
            chs[i] = (char)('A' + i - chs.length / 2);
        }
        String str = "";
        for(int i = 0;i < 4;i++){
            str += chs[r.nextInt(chs.length)];
        }
        str += r.nextInt(10);
        char [] arr = str.toCharArray();
        for(int i = 0;i < arr.length;i++){
            int j = r.nextInt(arr.length);
            char tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
        String result = new String(arr);
        System.out.println("验证码为" + result);
    }
}

import java.util.Random;
public class TextDemo4{
    public static void main(String[] args){
        Random r = new Random();
        char [] chs = new char[52];//创建一个数组，里面有大写和小写字母
        //给所创建的字符数组，赋值：大写和小写字母
        for(int i = 0;i < chs.length / 2;i++){

            chs[i] = (char)('a' + i);
        }
        for(int i = chs.length / 2;i < chs.length;i++){
            chs[i] = (char)('A' + i - chs.length / 2);
        }
        String str = "";
        for(int i = 0;i < 4;i++){
            str += chs[r.nextInt(chs.length)];
        }
        str += r.nextInt(10);
        char [] arr = str.toCharArray();
        int j = r.nextInt(arr.length);
        //不用把所有的字符数组打乱，只需要把最后一位的数字与前面的随机位置的字母交换即可
        char tmp = arr[arr.length - 1];
        arr[arr.length - 1] = arr[j];
        arr[j] = tmp;
        String result = new String(arr);
        System.out.println("验证码为" + result);
    }
}

（5）数字相乘

给定两个以字符串形式表示的非负整数num1和num2，返回num1和num2的乘积，它们的乘积也表示为字符串形式

import java.util.Scanner;
public class TextDemo5{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        String s1 = sc.next();
        System.out.println("请输入第二个整数");
        String s2 = sc.next();
        char[] arr1 = s1.toCharArray();
        char[] arr2 = s2.toCharArray();
        int num1 = 0;
        int num2 = 0;
        int num;
        for(int i = 0;i < arr1.length;i++){
            num1 = num1 * 10 + (int)(arr1[i] - '0');
        }
        for(int i = 0;i < arr2.length;i++){
            num2 = num2* 10 + (int)(arr2[i] - '0');
        }
        num = num1 * num2;
        String result = "";
        while(num > 0){
            char c = (char)(num % 10 + '0');
            result = c + result;
            num /= 10;
        }
        System.out.println("两数乘积为" + result);
    }
}

（6）单词长度

给你一个字符串s，由若干单词组成，单词前后用一些空格字符隔开。
返回字符串中最后一个单词的长度。
单词是指仅由字母组成，不包含任何空格字符的最大子字符串。
示例1：输入：s = “Hello World” 输出：5
解释：最后一个单词是"World",长度为5。
示例2：输入：s = “fly me to the moon” 输出：4
解释：最后一个单词是"moon",长度为4。
示例3：输入：s = “luffy is still joyboy” 输出：6
解释：最后一个单词是"joyboy",长度为6。

import java.util.Scanner;
public class TextDemo6{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入字符串");
		String s = sc.nextLine();
		char [] arr = s.toCharArray();
		int count = 0;
		for(int i = 0;i < arr.length;i++){
			if((arr[i] > 'A' && arr[i] < 'Z') || (arr[i] > 'a' && arr[i] < 'z')){
				count++;
			}else {
				count = 0;
			}
		}
		System.out.println("最后一个单词的长度为" + count);
	}
}

import java.util.Scanner;
public class TextDemo6{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
        String s = sc.nextLine();
        char [] arr = s.toCharArray();
        int count = 0;
        //倒着遍历，遇到空格就停止
        int i = arr.length - 1;
        while(arr[i] != ' '){
            count++;
            i--;
        }
        System.out.println("最后一个单词的长度为" + count);
    }
}