Day10-字符串

AIains

已于 2023-10-18 16:56:55 修改

阅读量800

点赞数 1

分类专栏：黑马程序员Java基础学习笔记文章标签：学习 java

于 2022-09-25 22:27:41 首次发布

本文链接：https://blog.csdn.net/aiains/article/details/125814398

版权

黑马程序员Java基础学习笔记专栏收录该内容

17 篇文章 35 订阅

订阅专栏

1、API和API帮助文档

API：应用程序接口。

简单理解：API就是别人已经写好的东西，我们不需要自己编写，直接使用即可。

JavaAPI：指的就是JDK中提供的各种功能的Java类。这些类将底层的实现封装了起来，我们不需要这些类是如何实现的，只需要学习这些类是如何使用的即可。

API帮助文档：帮助开发人员更好的使用API和查询API的一个工具。

2、String概述（字符串知识点1）

1、String概述：Java.long.String类代表字符串，Java程序中的所有字符串文字(例如“abc”)都为此类的对象。表示字符串的类，定义了很多操作字符串的方法。

2、String的注意点：字符串的内容是不会发生改变的，它的对象在创建后不能被更改。

3、String是Java定义好的一个类。在Java.long包中，所以使用的时候不需要导包。(Java.long包是Java的核心包)

3、String构造方法代码实现和和内存分析

1、创建String对象的两种方式。

（1）、直接赋值。

例如：String name = "小明";

（2）、new一个。

举例如下：

package StringDemo1;

public class StringDemo1 {
    public static void main(String[] args) {
        //1、使用直接赋值的方式获取一个字符串对象
        String s1 = "abc";
        System.out.println(s1);     //abc

        //2、使用new的方式来获取一个字符串对象
        //2.1、空参构造：可以获取一个空白的字符串对象。
        String s2 = new String();
        System.out.println("@"+s2+"!");     //@!

        //2.2、传递一个字符串，根据传递的字符串内容再创建一个新的字符串对象
        String s3 = new String("abc");
        System.out.println(s3);     //abc

        //2.3、传递一个字符数组，根据字符数组的内容再创建一个新的字符串对象
        //使用场景：我要修改字符串的内容。   abc   Qbc
        //abc --> {'a','b','c'} --> {'Q','b','c'} --> Qbc
        char[] chs = {'a','b','c','d'};
        String s4 = new String(chs);
        System.out.println(s4);     //abcd

        //2.4、传递一个字节数组，根据字节数组的内容再创建一个新的字符串对象
        //使用场景：以后在网络当中传输的数据其实都是字节信息。
        //我们一般要把字节信息进行转换，转换成字符串，此时就要用到这个构造了。
        byte[] bytes = {97,98};     //97、98在ASCLL码表中的对应值为a、b
        String s5 = new String(bytes);
        System.out.println(s5);     //ab
    }
}

2、创建String对象的两种方式的内存分析。

4、字符串的比较

1、==号比的到底是什么？

1、基本数据类型
int a = 10;
int b = 20;
System.out.println(a == b);    //false

基本数据类型比较的是数据值

2、引用数据类型
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2);    //false
引用数据类型比较的是地址值

2、字符串比较

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

String c1 = new String("abc");    //记录堆里面的地址值
String c2 = "abc";    //记录串池中的地址值
System.out.println(c1 == c2);    //false

3、字符串比较调用方法

boolean equals方法(要比较的字符串)        完全一样结果才是true，否则为false
Boolean equalsIgnoreCase(要比较的字符串)    忽略大小写的比较

package sss;

import java.util.Scanner;

public class StringDome {
    public static void main(String[] args) {
        //1.1、创建两个字符串对象
        String s1 = new String("abc");
        String s2 = "Abc";

        //1.2、==号比较
        //基本数据类型：比的是数据值
        //引用数据类型：比的是地址值
        System.out.println(s1 == s2);   //false

        //1.3、比较字符串对象中的内容是否相等
        boolean result1 = s1.equals(s2);
        System.out.println(result1);    //false

        //1.4、比较字符串对象中的内容是否相等，忽略大小写
        boolean result2 = s1.equalsIgnoreCase(s2);
        System.out.println(result2);    //true


        //2.1假设我现在键盘录入一个abc
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str1 = sc.next();    //abc  是new出来的。
        //2.2代码中再定义一个字符串abc
        String str2 = "abc";
        //2.3 用==比较，这两者是否一样？
        System.out.println(str1 == str2);   //false

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

}

5、练习-用户登录

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

package sss;

import java.util.Scanner;

public class StringDome {
    public static void main(String[] args) {
        //1、定义两个变量记录正确的用户名和密码
        String rightname = "susu";
        String rightpassword = "123456";
        int n = 3;  //三次登录机会,n的值可以根据条件修改，没有写死
        Scanner sc = new Scanner(System.in);

        for (int i=0; i<n ;i++) {
            //模拟用户输入
            System.out.println("请输入用户名");
            String username = sc.next();
            System.out.println("请输入密码");
            String userpassword = sc.next();
            //对比账户和密码
            if( rightname.equals(username) && rightpassword.equals(userpassword) ){
                System.out.println("登陆成功");
                break;  //登陆成功后，直接跳出循环
            } else {
                if((n-1 -i)==0){
                    System.out.println("账户被锁定，请联系客服人员");
                } else{
                    System.out.printf("账号或密码错误,");
                    System.out.println("您还有"+ (n-1 -i) +"次机会");
                }
            }
        }
    }
}

6、练习-遍历字符串和统计字符个数

案例1：遍历字符串

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

补充知识：
public char charAt(int index);    根据索引返回字符，index是索引
public int length();    返回此字符串的长度
数组长度：数组名.length
字符串长度：字符串对象.length()

package sss;

import java.util.Scanner;

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

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();

        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            System.out.println(c);
        }
    }
}

案例2：统计字符次数

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

package sss;

import java.util.Scanner;

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

        int bigCount=0;
        int smallCount=0;
        int numberCount=0;

        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if(c>='A' && c<='Z'){
                bigCount++;
            } else if(c>='a' && c<='z'){
                smallCount++;
            } else if(c>='0' && c<='9'){
                numberCount++;
            }
        }

        System.out.println("大写字符有"+bigCount+"个");
        System.out.println("小写字符有"+smallCount+"个");
        System.out.println("数字字符有"+numberCount+"个");
    }
}

7、练习-字符串拼接和反转

案例1：拼接字符串

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

数组为 int[] arr = {1,2,3};

执行方法后的输出结果为：[1,2,3]

package sss;

public class StringDome {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        String str =arrToString(arr);
        System.out.println(str);
        
    }
    /**定义一个方法
     * 我要干嘛？    遍历数组，把数组拼接成一个字符串
     * 需要什么才能完成？    数组
     * 是否需要返回值？     需要
     */
    public static String arrToString(int[] arr){
        if(arr == null){
            return "";  //字符串的值为null的时候返回空
        }
        if(arr.length == 0){
            return "[]";    //字符串长度为0的时候，返回[]
        }

        String result = "[";    //设置字符串的初始值
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length - 1){
                result = result + arr[i];
            } else{
                result = result + arr[i] + ",";
            }
        }
        result = result+"]";
        return result;
    }

}

案例2：字符串反转

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

package sss;

public class StringDome {
    public static void main(String[] args) {
        String s = reverser("abc");
        System.out.println(s);
    }
    /**定义一个方法
     * 我要干嘛？    遍历数组，把数组拼接成一个字符串
     * 需要什么才能完成？    数组
     * 是否需要返回值？     需要
     */
    public static String reverser(String str){
        String result = "";
        //i.forr可实现倒着循环
        for (int i = str.length() - 1; i >= 0; i--) {
            char c = str.charAt(i);
            result =result + c;     //字符串拼接
        }
        return result;
    }
}

8、较难练习-金额转换

分析：

package sss;

import java.sql.SQLOutput;
import java.util.Scanner;
public class StringDome {
    public static void main(String[] args) {

        //1、获取键盘输入
        Scanner sc = new Scanner(System.in);
        int money;
        while(true){
            System.out.println("请录入一个整数");
            money = sc.nextInt();
            if(money>=0 && money<=9999999){
                break;
            } else{
                System.out.println("金额无效");
            }
        }

        //2、得到money里面每位上的数字，并转化成大写
        /*int len = (money+"").length();     //求输入的数字的长度
        System.out.println("金额长度为："+len);*/
        //定义一个变量来表示钱的大写
        String moneyStr = "";
        while(true){
            int ge = money%10;
            String capitalNumber = getCapitalNumber(ge);
            moneyStr =  capitalNumber + moneyStr;

            money = money/10;
            //如果money每一位上的数字都被获取到了，则money记录的值就为0，此时循环结束
            if(money==0){
                break;
            }
        }
        //System.out.print(moneyStr);  //打印对应的大写

        //3、在前面补零，补齐7位
        int count = 7 - moneyStr.length();
        for (int i = 0; i < count; i++) {
            moneyStr = "零" + moneyStr;
        }
        //System.out.println(moneyStr);   //打印补零后的结果

        //4、插入单位
        //定义一个数组表示单位
        String[] arr = {"佰","拾","万","仟","佰","拾","元"};
        //               零   零   零   二   三   四   五
        //遍历moneyStr,依次获得 零   零   零   二   三   四   五
        //然后把arr的单位插入进去
        String result = "";
        for (int i = 0; i < moneyStr.length(); i++) {
            char c = moneyStr.charAt(i);
            result = result + c + arr[i];
            //System.out.print(c);
            //打印一下单位
            //System.out.print(arr[i]);
        }

        //5、打印结果
        System.out.println(result);
    }

    //定义一个方法，把数字变成大写中文
    public static String getCapitalNumber(int number){
        String[] arr = {"零","一","二","三","四","五","六","七","八","九"};
        return arr[number];
    }
}

9、练习-手机号屏蔽-身份证号码信息查看-游戏骂人敏感词替换

补充知识：

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

String substring(int beginIndex)    截取到末尾

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

案例1：手机号屏蔽。

package sss;

import java.sql.SQLOutput;
import java.util.Scanner;
public class StringDome {
    public static void main(String[] args) {
        //1、获取一个手机号码
        String phoneNumber = "12345678911";

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

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

        //4、拼接
        String result = star + "****" + end;
        
        //5、打印结果
        System.out.println(result);
    }
}

案例2：身份证信息查看

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

7~14位表示出生年月日，17位表示性别（奇数为男生，偶数为女生），已知身份证号码，打印出生年月日和性别。

package sss;

import java.sql.SQLOutput;
import java.util.Scanner;
public class StringDome {
    public static void main(String[] args) {
        //1、定义一个字符串记录身份证号码
        String id = "123456202207276789";

        //2、获取出生年月日
        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 + "日");

        //3、获取性别
        /**利用ASCII码表进行转换，将字符转换为数字
         * '0'   ----->  48
         * '1'   ----->  49
         * '2'   ----->  50
         * '3'   ----->  51
         * ASCII码号比数字值大48
         */
        char gender = id.charAt(16);
        int num = gender- 48;   //将字符转化为数字
        System.out.print("性别为：");
        if(num%2==0){
            System.out.println("女");
        } else{
            System.out.println("男");
        }
    }
}

案例3：敏感词替换

package sss;

public class StringDome {
    public static void main(String[] args) {
        //1、获取说的话
        String talk = "你玩的真好，TMD";

        //2、把里面的敏感词TMD，替换成***
        String result = talk.replace("TMD","***");

        //3、打印结果
        System.out.println(result);
    }
}

package sss;

public class StringDome {
    public static void main(String[] args) {
        //1、获取说的话
        String talk = "你玩的真好，TMD,SB";
        //定义一个敏感词库
        String[] arr = {"TMD","CNM","SB","MLGB"};
        //循环得到数组中的每一个敏感词，依次进行替换
        for (int i = 0; i < arr.length; i++) {
            talk = talk.replace(arr[i],"***");
        }
        //3、打印结果
        System.out.println(talk);
    }
}

10、StringBuilder的基本操作（字符串知识点2）

1、StringBuilder概述。

StringBuilder可以看成是一个容器，创建之后里面的内容是可变的。

作用：提高字符串的操作效率。

一个可变的操作字符串的容器，可以高效的拼接字符串，还可以将容器里面的内容反转。

2、StringBuilder构造方法。

1、方法名：
public StringBuilder()
说明：创建一个空白可变字符串对象，不含有任何内容。
StringBuilder sb = new StringBuilder();

2、方法名：
public StringBuilder(String str)
说明：根据字符串的内容，来创建可变字符串对象。
StringBuilder sb = new StringBuilder("abc");

3、StringBuilder常用方法。

package GGG;

public class hhh {
    public static void main(String[] args) {
        //1、创建对象
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1);    //打印时无输出
        StringBuilder sb2 = new StringBuilder("abc");
        System.out.println(sb2);    //打印时输出abc
        StringBuilder sb3 = new StringBuilder("abcdef");

        //2、添加元素
        sb2.append(1);
        sb2.append(2.3);
        sb2.append(true);
        System.out.println(sb2);    //添加后输出abc12.3true(容器的属性值，并非字符串)
        
        sb1.append(1).append(2.3).append(true);    //链式编程
        System.out.println(sb1);    //输出为12.3true

        //3、再把StringBuilder变回字符串
        String str = sb2.toString();
        System.out.println(str);    //输出abc12.3true(字符串)

        //3、反转
        sb3.reverse();
        System.out.println(sb3);    //输出fedcba

        //4、获取长度
        int len = sb3.length();
        System.out.println(len);    //6
        
        /**普及：
         * 因为StringBuilder是Java已经写好的类
         * Java在底层对他进行了一些特殊处理
         * 打印对象不是地址值，而是属性值。
         */
    }
}

4、练习题：对称字符串。

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

package GGG;

import java.util.Scanner;

public class hhh {
    public static void main(String[] args) {
        /**使用StringBuilder的场景
         * 1、字符串的拼接
         * 2、字符串的反转
         */
        //1、键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();

        //2、反转键盘录入的字符串
        //创建StringBuilder容器，然后把str的值放进容器，反转容器中的字符串，
        //将容器中的字符串转化为现实中的字符串，然后将结果赋值给result
        String result = new StringBuilder().append(str).reverse().toString();

        //3、比较
        if(str.equals(result)){
            System.out.println("对称字符串");
        } else {
            System.out.println("非对称字符串");
        }
    }
}

5、练习题：拼接字符串。

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

例如：数组为int[] arr = {1,2,3};

执行方法后的输出结果为：[1,2,3]

package GGG;

public class hhh {
    public static void main(String[] args) {
        //1、定义数组
        int[] arr = {1,2,3};
        //2、调用方法把数组变成字符串
        String str = arrToString(arr);
        System.out.println(str);
    }

    public static String arrToString(int[] arr){
        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]).append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

11、Stringjoiner（字符串知识点3）

1、StringJoiner概述

StringJoiner跟StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的。

作用：提高字符串的操作效率，而且代码编写特别简洁，但是目前市场上很少有人用。

JDK8出现的一个可变的操作字符串的容器，可以高效，方便的拼接字符串，在拼接的时候，可以指定间隔符号，开始符号，结束符号。

2、StringJoiner的构造方法。

3、StringJoiner的成员方法。

package GGG;

import java.util.StringJoiner;

public class hhh {
    public static void main(String[] args) {
        //1、创建一个对象，并指定中间的间隔符号
        StringJoiner sj1 = new StringJoiner("---");
        StringJoiner sj2 = new StringJoiner(",","[","]");

        //2、添加元素
        sj1.add("aaa").add("bbb").add("ccc");
        sj2.add("aaa").add("bbb").add("ccc");

        //3、获取长度
        int len = sj2.length();
        System.out.println(len);    //13

        //4、打印结果
        System.out.println(sj1);     //aaa---bbb---ccc
        System.out.println(sj2);     //[aaa,bbb,ccc]

        //5、变成字符串
        String str = sj1.toString();
        System.out.println(str);    //aaa---bbb---ccc
    }
}

12、字符串相关类的底层原理（字符串知识点4）

扩展底层原理1：字符串存储的内存原理。

（1）、直接赋值会复用字符串常量池中的。

（2）、new出来不会复用，而是开辟一个新的空间。

扩展底层原理2：==号比较的到底是什么？

（1）、基本数据类型比较数据值。

（2）、引用数据类型比较地址值。

扩展底层原理3：字符串拼接的底层原理。

扩展底层原理4：StringBuilder提高效率原理图。

扩展底层原理5：StringBuilder源码分析。

13、较难练习-罗马数字的两种写法

练习案例1：转换罗马数字。

需求：键盘录入一个字符串，

要求1：长度小于等于9

要求2：只能是数字

将内容变成罗马数字

解法1：查表法

package GGG;

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

public class hhh {
    public static void main(String[] args) {
        //1、键盘了录入一个字符串
        Scanner sc = new Scanner(System.in);
        String str;
        while (true) {
            System.out.println("请输入一个人字符串");
            str = sc.next();    //输入123456
            //2、校验字符串是否满足规则
            boolean flag = checkStr(str);     //调用方法，对输入进行检测
            if(flag){   //输入符合规范
                break;
            } else {
                System.out.println("请重新输入");
                continue;
            }
        }

        //2、查表法：将内容变成罗马数字
        StringJoiner sb = new StringJoiner("-");     //用于字符串拼接
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);     //根据索引获取字符串每一位上的值
            int number = c - 48;    //将获得的字符串转化为数字
            String s = changeLuoMa(number);     //用数字作为索引，获取对应的罗马数字
            sb.add(s);   //对罗马数字进行拼接操作
        }
        System.out.println(sb);     //打印拼接后的结果I-II-III-IV-V-VI
    }

    //定义方法，把阿拉伯数字转化为罗马数字
    public static String changeLuoMa(int number){
        //定义一个数组，让索引跟罗马数字产生一个对应的关系
        String[] arr = {"","I","II","III","IV","V","VI","VII","VIII","IX"};
        return arr[number];     //number的值为1时，函数返回值为I
    }

    //定义方法，检测输入是否规范
    public static boolean checkStr(String str){
        //要求1：长度为小于等于9
        if(str.length() > 9){
            return false;
        }
        //要求2：只能是数字0~9
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if(c < '0' || c > '9'){
                return false;
            }
        }
        //当所有的检测都通过之后，证明输入符合规范，则返回true
        return true;
    }
}

解法2：switch法

package GGG;

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

public class hhh {
    public static void main(String[] args) {
        //1、键盘了录入一个字符串
        Scanner sc = new Scanner(System.in);
        String str;
        while (true) {
            System.out.println("请输入一个人字符串");
            str = sc.next();    //输入123456
            //2、校验字符串是否满足规则
            boolean flag = checkStr(str);     //调用方法，对输入进行检测
            if(flag){   //输入符合规范
                break;
            } else {
                System.out.println("请重新输入");
                continue;
            }
        }

        //2、查表法：将内容变成罗马数字
        StringJoiner sb = new StringJoiner("-");     //用于字符串拼接
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);     //根据索引获取字符串每一位上的值
            String s = changeLuoMa(c);     //用字符作为索引，获取对应的罗马数字
            sb.add(s);   //对罗马数字进行拼接操作
        }
        System.out.println(sb);     //打印拼接后的结果I-II-III-IV-V-VI
    }

    //定义方法，把阿拉伯数字转化为罗马数字
    public static String changeLuoMa(char num){
        //定义一个数组，让索引跟罗马数字产生一个对应的关系
        String s;
        switch(num){
            case '0' : s = ""; break;
            case '1' : s = "I"; break;
            case '2' : s = "II"; break;
            case '3' : s = "III"; break;
            case '4' : s = "IV"; break;
            case '5' : s = "V"; break;
            case '6' : s = "VI"; break;
            case '7' : s = "VII"; break;
            case '8' : s = "VIII"; break;
            case '9' : s = "IX"; break;
            default: s = ""; break;
        }
        return s;     //number的值为1时，函数返回值为I
    }

    //定义方法，检测输入是否规范
    public static boolean checkStr(String str){
        //要求1：长度为小于等于9
        if(str.length() > 9){
            return false;
        }
        //要求2：只能是数字0~9
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if(c < '0' || c > '9'){
                return false;
            }
        }
        //当所有的检测都通过之后，证明输入符合规范，则返回true
        return true;
    }
}

JDK12新特性：JDK版本在12以后，解法2switch中的代码可以写成下面的形式

14、较难练习-调整字符串的内容

练习题：调整字符串。

需求：给定两个字符串，A和B。

A的旋转操作就是将A最左边的字符移动到最右边。

例如：若A='abcde'，在移动一次之后结果就是'bcdea'。

如果在若干次调整操作之后，A能变成B，那么返回True。

如果不能匹配成功，则返回false。

package GGG;

public class hhh {
    public static void main(String[] args) {
        //1、定义两个字符串
        String strA = "abcde";
        String strB = "cdeab";

        //2、调用方法，旋转字符串
        boolean result = check(strA,strB);

        //3、输出结果
        System.out.println(result);
    }

    //定义方法，循环旋转并比较
    public static boolean check(String strA,String strB){
        for (int i = 0; i < strA.length(); i++) {   //循环次数和字符串长度有关系
            strA = rotate(strA);    //将移动后的字符串赋值给strA
            if(strA.equals(strB)){  //将strA与strB作比较
                return true;
            }
        }
        return false;   //当所有情况都比较完毕后，如果还不一样，则输出false
    }

    //定义方法，选择字符串，把左侧的字符移动到右侧
    public static String rotate(String str){
        /**套路
         * 如果我们看到要修改字符串的内容，可以有两个办法：
         * 方法1、用subString进行截取，把左边的字符截取出来拼接到右侧去。
         * 方法2、可以把字符串先变成一个字符数组，然后调整字符数组里面的数据，最后再把字符数组变成字符串。
         */
        /*方法1的代码
        char first = str.charAt(0);     //获取第一个字符
        String end = str.substring(1);  //获取剩余的字符
        String result = end +first;     //拼接操作
        return result;*/

        //方法2的代码：
        char[] arr = str.toCharArray();     //把字符串变为字符数组
        char first = arr[0];    //拿到0索引上的字符
        //把剩余的字符依次往前移动一个位置
        for (int i = 1; i < arr.length; i++) {
            arr[i - 1] = arr[i];
        }
        arr[arr.length - 1] = first;    //把原来0索引上的字符放到最后一个索引

        //利用字符数组创建一个字符串对象
        String result = new String(arr);
        return result;
    }
}

15、后续练习思路分析

案例1：键盘录入任意字符串，打乱里面的内容。

package GGG;

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

public class hhh {
    public static void main(String[] args) {
        //1、键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();

        //2、打乱里面的内容
        char[] arr = str.toCharArray();

        //3、打乱数组里面的内容
        //从0索引开始，跟一个随即索引进行位置的交换
        //当数组里面的每一个元素都跟一个随即索引进行交换完毕之后，那么内容就打乱了
        Random r = new Random();
        for (int i = 0;i < arr.length;i++) {
            int sui = r.nextInt(arr.length - 1);
            char temp = arr[i];
            arr[i] = arr[sui];
            arr[sui] = temp;
        }

        //4、把字符数组再变回字符串
        String result = new String(arr);
        System.out.println(result);
    }
}

案例2：生成验证码。

需求：可以是小写字母，也可以是大写字母，还可以是数字。

规则：长度为5，4个字母，1个数字。其中数字只有1位，可以出现在任意位置。

package GGG;

import java.util.Random;

public class hhh {
    public static void main(String[] args) {
        String result = "";
        //1、把大写字母和小写字母放到数组当中
        char[] chs = new char[52];    //定义字符型数组，用来存储大小写字母
        for (int i = 0; i < chs.length; i++) {
            if(i<=25){      //i的范围为0~25
                //添加小写字母。ASCLL码表中a对应97
                chs[i]=(char)(97+i);
            } else{     //i的范围为26~52
                //添加大写字母。ASCLL码表中A对应65
                chs[i]=(char)(65 + (i - 26));
            }
        }
        //2、随机抽取四次
        //随机抽取数组中的索引
        Random r = new Random();
        for (int i = 0; i <4 ; i++) {       //多次抽取，要利用循环
            //随机抽取一个元素，将对应的字母赋值给变量randomchar
            int randomchar = r.nextInt(chs.length);
            result = result + chs[randomchar];  //字符串+字符的拼接 结果为字符串
        }
        //3、随机抽取一个数字，赋值给变量randomNumber
        int randomNumber = r.nextInt(10);   //获取一个0~9之间的随机数
        result = result + randomNumber;     //字符串拼接

        //4、打印生成的验证码：字母+数字
        System.out.println(result);

        //5、打乱里面的内容
        char[] arr = result.toCharArray();  //变成字符数组
        Random rs = new Random();
        int sui = rs.nextInt(arr.length - 1);
        //随机索引对应的值与最后的数字调换
        char temp = arr[arr.length-1];
        arr[arr.length-1] = arr[sui];
        arr[sui] = temp;

        //6、把字符数组再变回字符串
        String ss = new String(arr);
        System.out.println(ss);
    }
}

案例3：给定两个以字符串形式表示的非负整数num1和num2，返回两者的乘积，他们的乘积也表示成字符串的形式。

不需要考虑乘积过大之后的结果，认为乘积一定小于int的最大值

package GGG;

/**
 * 给定两个以字符串形式表示的非负整数num1和num2，返回两者的乘积，他们的乘积也表示成字符串的形式
 * 不需要考虑乘积过大之后的结果，认为乘积一定小于int的最大值
 */
public class hhh {
    public static void main(String[] args) {
        String num1 = "11";
        String num2 = "22";
        //把num1和num2变成对应的整数才可以
        //先遍历每一个字符，然后把字符变成数字，然后再把数字做调整
        int num11 = toInt(num1);
        int num22 = toInt(num2);
        //System.out.println(num11*num22);
        String zf = num11*num22 + "";
        System.out.println(zf);
    }
    //定义一个方法，输入一个字符串，把它变成对应的int类型的整数
    public static int  toInt(String a) {
        int sum = 0;
        for (int i = 0; i < a.length(); i++) {
            char c = a.charAt(i);
            int shu = c - 48;
            sum = sum * 10 +shu;
        }
        return sum;
    }

}

案例4：

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

package GGG;

public class hhh {
    public static void main(String[] args) {
        String str = "fly me to the moon";
        String strh = "";
        int count = 0;
        for (int i = str.length() - 1; i > 0; i--) {
            char c = str.charAt(i);
            if(Character.isSpaceChar(c)){
                break;
            } else {
                 strh = c + strh ;
                 count++;
            }
        }
        System.out.println(strh);
        System.out.println(count);
    }
}