【Java基础03】Java变量2

1. 基本数据类型

数据类型	关键字	内存占用	取值范围
整数	byte	1	负的2的7次方 ~ 2的7次方-1(-128~127)
	short	2	负的2的15次方 ~ 2的15次方-1(-32768~32767)
	int	4	负的2的31次方 ~ 2的31次方-1
	long	8	负的2的63次方 ~ 2的63次方-1
浮点数	float	4	1.401298e-45 ~ 3.402823e+38
	double	8	4.9000000e-324 ~ 1.797693e+308
字符	char	2	0-65535
布尔	boolean	1	true，false

public class Main {public static void main(String[] args) {//bytebyte b = 10;System.out.println(b) ;//10//shortshort s=20;System.out.println(s) ; //20//intint i=30;System.out.println(i) ; //30// long//如果要定义long类型的变量//在数据值的后面需要加一个L作为后缀//L可以是大写的， 也可以是小写的。//建议:使用大写。long n = 9999999999L;System.out.println(n);}
}

public class Main {public static void main(String[] args) {float f =10.1F;System.out.println(f) ;//doubledouble d = 20.2 ;System.out.println(d) ;//charchar c='中';System.out.println(c) ;//boolean//true falseboolean o = true ;System.out.println(o) ;}
}

整数和小数取值范围大小关系：double > float > long > int > short > byte
long类型变量：需要加入L标识(大小写都可以)
float类型变量：需要加入F标识(大小写都可以)

2.引用数据类型

类、 接口类型、 数组类型、 枚举类型、 注解类型、 字符串型
例：String类型就是引用类型
引用数据类型，变量中存的是地址（因为都是在堆中new出来的，使用的是其他空间里的数据)
例子：System.out.println(s1); //POINT 其实s1保存的也是地址，因为String重写了这个sout方法，所以输出的不是地址

关于Java引用和c++引用、c指针的区别：

1. 间接访问数据
   三者都通过一个“中间值”间接操作目标对象或数据。

   • C 指针：直接存储内存地址（如 0x7FFF...）。
   • C++ 引用：是已存在对象的别名（底层可能通过指针实现，但对开发者透明）。
   • Java 引用：是 JVM 管理的逻辑地址（可能是句柄或压缩指针）。

2. 传递效率
   三者均可避免直接拷贝大对象，提升数据传递效率。

c/c++中需要一个指针来指向数组，但是java直接定义成了引用（这点类似于python）

1. 函数参数传递**

• C 指针：需显式传递地址，允许修改原始数据。

  void increment(int* p) { (*p)++; } int a = 10; increment(&a); // a 变为 11

• C++ 引用：语法更简洁，直接操作原始对象。

  void increment(int& r) { r++; } int a = 10; increment(a); // a 变为 11

• Java 引用：传递对象引用，但基本类型通过值传递。

  void increment(Integer[] arr) { arr[0]++; } Integer[] arr = {10}; increment(arr); // arr[0] 变为 11

另外注意：数组名本身不是指针，它只是能在某些场合隐式转换成指针使用。

printf("%p\n", arr);     // 输出的是首元素的地址，是因为此时arr被当&arr[0]处理了

2.1 数组

2.1.1 数组介绍

指的是一种容器，可以同来存储同种数据类型的多个值。

但是数组容器在存储数据的时候，需要结合隐式转换考虑。
例如：int类型的数组容器 boolean (×)， byte(√)， short(√)， int(√)，double(×))
double类型的数组容器( byte(√)， short(√) ，int(√) ，long(√)， float(√) ，double(√))
建议：容器的类，和存储的数据类型保持一致。

2.1.2 数组的定义与静态初始化

数据类型 [] 数组名 = new 数据类型[] {元素1,元素2，元素3... };
或
数据类型 [] 数组名 = {元素1,元素2，元素3... };

new：就是给数组在内存中开辟了一个空间。

这里是静态初始化，数组一旦确定长度，长度不可发生改变。

int[] agesArr = new int[]{18,19,20,21,22};
int[] agesArr = {18,19,20,21,22};String[] namesArr = new String[]{"zhangsan","lisi","wangwu"};
String[] namesArr = {"zhangsan","lisi","wangwu"};

注意：打印数组的时候，实际出现的是数组的地址值。

int[] arr = {1,2,3,4,5};
System.out.println(arr);//[I@6d03e736//[ ：表示现在打印的是一个数组。
//I：表示现在打印的数组是int类型的。
//@：仅仅是一个间隔符号而已。
//6d03e736：就是数组在内存中真正的地址值。（十六进制的）
//但是，我们习惯性会把[I@6d03e736这个整体称之为数组的地址值。

2.1.3 数组元素访问

public class Main {public static void main(String[] args) {// 1. 访问数组元素int[] arr1 = new int[]{11,12,13,14};int[] arr2 = {11,12,13,14};System.out.println(arr1[2]);//13//2.把数据存储到数组当中//格式:数组名[索引] =具体数据/变量;//细节:一旦覆盖之后，原来的数据就不存在了。arr1[2]=100;System.out.println(arr1[2]);//100}
}

2.1.4 数组遍历

就是把数组里面所有的内容一个一个全部取出来。

数组的长度：数组名.length;

public class Main {public static void main(String[] args) {int[] arr1 = new int[]{11,12,13,14};for (int i = 0;i< arr1.length;i++){System.out.println(arr1[i]);}}
}

2.1.5 数组动态初始化

初始化时只指定数组长度，由系统为数组分配初始值。

格式：数据类型[] 数组名 = new 数据类型[数组长度];

import java.util.Scanner;
public class Main {public static void main(String[] args) {//格式: //数据类型[]数组名= new数据类型[数组的长度]; //在创建的时候，由我们自己指定数组的长度，由虚拟机给出默认的初始化值String[] arr = new String[50];//添加学生arr[0] = "zhangsan";arr[1] = "lisi";//获取System.out.println(arr[0]);//zhangsanSystem.out.println(arr[1]);//lisiSystem.out.println(arr[2]);//打印出来的是默认初始化值null//数组默认初始化值的规律//整数类型:默认初始化值0//小数类型:默认初始化值0.0//字符类型:默认初始化值' /u0000'空格//布尔类型:默认初始化值false//引用数据类型:默认初始化值null}
}

数组两种初始化的区别：
静态初始化：手动指定数组的元素，系统会根据元素的个数，计算出数组的长度。
动态初始化：手动指定数组长度，由系统给出默认初始化值。
只明确元素个数，但是不明确具体的数据，推荐使用动态初始化。
已经明确了要操作的所有数据，推荐使用静态初始化。

2.1.6 数组内存图

栈 方法运行时使用的内存，比如main方法运行，进入方法栈中执行
堆 存储对象或者数组，new来创建的，都存储在堆内存
方法区 存储可以运行的class文件
本地方法栈 JVM在 使用操作系统功能的时候使用，和我们开发无关
寄存器 给CPU使用，和我们开发无关
具体可以看视频，这里不整理了

2.1.7 数组常见操作

求最值、求和、统计个数（计数器思想）、交换数据、打乱数据

2.2 二维数组

2.2.1 二维数组定义

当我们需要把数据分组管理的时候，就需要用到二维数组

格式：数据类型 [][] 数组名 = new 数据类型[][] {{元素1,元素2},{元素1,元素2}};
简化格式：数据类型[][]数组名= {{元素1,元素2}, {元素1,元素2}};

public class Main {public static void main(String[] args) {//静态初始化  可以长度不等int [][] arr= new int[][]{{1,2,3},{4,5,6,7,8,9}};int [][] arr1= {{1,2,3},{4,5,6,7,8,9}};//以后建议这样定义int [][] arr2={{1,2,3},{4,5,6,7,8,9}};//2.获取元素System.out.println(arr2[0]);//[I@7ef20235 现在获取的是第一个一维数组 还是地址。System.out.println(arr2[0][0]);//1}
}

public class Main {public static void main(String[] args) {//静态初始化  可以长度不等int [][] arr= new int[][]{{1,2,3},{4,5,6,7,8,9}};int [][] arr1= {{1,2,3},{4,5,6,7,8,9}};//以后建议这样定义int [][] arr2={{1,2,3},{4,5,6,7,8,9}};//3、二维数组遍历for (int i = 0; i < arr2.length ; i++) {//i:表示二维数组中的每一个索引//arr3[i]:表示二维数组中的每一一个元素 (一维数组)for(int j=0;j < arr2[i].length ; j++){//j:表示一维数组中的每一个元素System.out.println(arr2[i][j]);}}}
}

2.2.2 二维数组的动态初始化

• 格式: 数据类型[][]数组名= new数据类型[m][n];
• m表示这个二维数组，可以存放多少个一维数组
• n表示每一个一维数组，可以存放多少个元素

2.2.3 二维数组内存管理

见视频

3.字符串

3.1 API

API：应用程序编程接口

• java中的API：指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

将来还会学习其他知识，还会有很多的API。

已经学习过的API：
Scanner 键盘输入
Random 随机数

String

3.2 创建String对象的两种方式（有底层原理未学）

//Java 程序中所有的双引号字符串，都是 String 类的对象
public class StringDemo1 {public static void main(String[] args) {//1.直接赋值String s1 = "abc";System.out.println(s1); //POINT 其实s1保存的也是地址，因为String重写了这个sout方法，所以输出的不是地址//2.使用new的方式创建字符串对象//空参构造：可以获取一个空白的字符串对象String s2 = new String();System.out.println("@"+s2+"!");//传递一个字符串，根据传递的字符串内容再创建一个新的字符串对象String s3 = new String("abc"); //这种方式比较鸡肋， new String可以不写，只要知道这种方式存在就可以了System.out.println(s3);//传递一个字符数组，根据传递的字符数组内容再创建一个新的字符串对象//需求：修改字符串的内容 abc->Qbc//先变为字符数组，数组是可以变化的  abc-->{'a','b','c'}-->{'Q','b','c'}char[] chs = {'a','b','c'};System.out.println("char"+chs);//这里输出就是地址了String s4 = new String(chs);System.out.println(s4); // abcd//传递一个字节数组，根据传递的字节数组内容再创建一个新的字符串对象 byte//应用场景：网络中传输的数据其实都是字节信息，一般要把字节信息进行转换，转成字符串，这个时候就需要这个构造byte[] bytes = {97,98,99,100}; //查到对应的ascii字母String s5 = new String(bytes);System.out.println(s5); //abcd}
}

3.3 一些案例

1.字符串遍历

charAt(int index)根据索引返回字符
字符串长度：字符串对象.length()

注意这里不能直接 stringName[]，和数组不一样

public class Main {public static void main(String[] args) {String s1 = "abcdefg";for(int i = 0; i < s1.length(); i++){System.out.println(s1.charAt(i));}}
}

import org.w3c.dom.ls.LSInput;import java.util.Random;
import java.util.Scanner;public class Main {public static void main(String[] args) {//1.Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串");String str = sc.next();//2.统计---计数器思想//定义三个计数器int bigCount = 0;int smallCount = 0;int numberCount = 0;for (int i = 0; i < str.length(); i++) {//i依次表示字符串中的每一个索引char c = str.charAt(i) ;if(c >= 'a' && c <= 'z'){//char类型的变量在参与计算的时候自动类型提升为int查询ascii码表smallCount++;}else if(c >= 'A' && c <= 'Z'){bigCount++;}else if(c >='0'&& c <= '9'){numberCount++;}}//输出System.out.println("小写字母有: " + smallCount + " 个");System.out.println("大写字母有: " + bigCount +" 个");System.out.println("数字字母有: " + numberCount +" 个");}
}

2.字符串拼接、反转

point! 当 + 号的操作数中有一个是字符串时，其他非字符串类型的操作数会被自动转换为字符串

package string;import java.util.Arrays;/*
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
并在控制台输出结果。例如，数组为 int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
*/
/*
定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
*/
public class StringTest3 {public static void main(String[] args) {int[] arr = {1,2,3};String s = arrayToS(arr);String s1 = Arrays.toString(arr); //作用就是下面写的这段代码System.out.println(s);System.out.println(s1);String s2 = reverseString(s1);System.out.println(s2);}public static String arrayToS (int[] arr){if(arr == null){ //point!int[] arr = new int[0]长度为0的数组没有意义，不能存数据return "";}if(arr.length == 0){return "[]";}String result = "[";//运行到这里说明数组有意义for (int i = 0; i < arr.length; i++) {if(i == arr.length - 1){result += arr[i];}else{result += arr[i] + ", "; //point!当 + 号的操作数中有一个是字符串时，其他非字符串类型的操作数会被自动转换为字符串}}return result + "]";}public static String reverseString (String str){String result = "";for(int i = str.length() - 1; i >= 0; i--){result += str.charAt(i);}return result;}
}

3.字符串比较

System.out.println("str1.equals(str2)");

4.金额转换

package string;import java.util.Scanner;public class StringTest4 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请录入一个金额"); //输入sout就行int money = sc.nextInt();while (true) {if(money >= 0 && money <= 9999999) {break;}else{System.out.println("金额无效");}}String moneyStr = "";//2.得到money里面的每一位数字，再转成中文while(true) {//从右往左获取数据int ge = money % 10; //得到个位money = money / 10; //去掉右边第一位String capitalNumber = getCapitalNumber(ge);moneyStr = capitalNumber + moneyStr; //这样新的就加在左边了System.out.println(capitalNumber);if(money == 0){break;}}System.out.println(moneyStr);//3.在前面补0，补齐7位int count = 7-moneyStr.length();for (int i = 0; i < count; i++) {moneyStr= "零" + moneyStr;}System.out.println(moneyStr);//4.加上个十百千万String[] arr = {"佰","拾","万","仟","佰","拾","元"};String allStr = "";for (int i = 0; i<=6  ; i++) {char ch = moneyStr.charAt(i);allStr = allStr + ch + arr[i];}System.out.println(allStr);// 第二种方法System.out.println("请录入一个金额");int money2 = sc.nextInt();String two = "";for (int i = 0; i <= 6; i++) {int wei = money2 % 10;money2 = money2 / 10;String capitalNumber = getCapitalNumber(wei);String unit = getUnit(i);two = capitalNumber + unit + two;}System.out.println(two);}public static String getCapitalNumber(int number) {String[] arr = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};return arr[number];}public static String getUnit(int number) {  // point! 这个对位思维特别重要String[] arr = {"元","拾","佰","仟","万","拾","佰"};return arr[number];}
}

5. 字符串截取

• String substring(int beginIndex, int endIndex)截取
  注意点:包头不包尾，包左不包右 只有返回值才是截取的小串
• String substring(int beginIndex)截取到末尾
• StringName.replace("要替换的","用什么替换")

package string;/*以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
最终效果为：`131****9468`*/import java.util.Scanner;public class StringTest5 {public static void main(String[] args) {//1.获取一个手机号码Scanner sc = new Scanner(System.in);System.out.println("请输入电话号码：");String phoneNumber = sc.next();String star = phoneNumber.substring(0, 3);String end = phoneNumber.substring(7); //从第七位开始但是不包括7（从0开始计数）String result = star +"xxxx" + end;System.out.println(result);// 敏感词替换String talk = "你好厉害，nbd";String result2 = talk.replace("nbd","xxx");System.out.println(result2);//敏感词替换2String[] arr = {"ndb","sd","ee"};//String result3 = "";for (int i = 0; i < arr.length; i++) {talk = talk.replace(arr[i],"xxx"); //可以是自己}System.out.println(talk);}
}

3.4 StringBuilder

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

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

3.4.1 StringBuilder构造方法

无参构造方法
创建一个初始容量为空的StringBuilder对象
StringBuilder sb = new StringBuilder();

指定初始容量的构造方法
创建一个指定初始容量50的StringBuilder对象
StringBuilder sb = new StringBuilder(50);

基于字符串的构造方法
创建一个包含指定字符串内容的StringBuilder对象
StringBuilder sb = new StringBuilder(“Hello”);

3.4.1 StringBuilder常用方法

下面案例都有说明具体代码写法：

package string;public class StringBuilder1 {public static void main(String[] args) {//1.创建对象StringBuilder sb = new StringBuilder();StringBuilder sb1 = new StringBuilder("abc");//2.添加元素sb.append(1);sb.append(2.3);sb.append(true);//2.反转元素sb.reverse(); //容器内部（也就是字符串本身）直接反转。字符串本身不可以反转，只有返回值可以，是一个新的字符串。//3.获取长度int len = sb.length();System.out.println(len);//4.toStringStringBuilder sb2 = new StringBuilder();sb2.append("abc");sb2.append("def");//链式编程sb2.append("aaa").append("bbb");  //可以直接添加//再把StringBuilder变为字符串String str = sb2.toString();System.out.println(str);// 打印//StringBuilder是java已经写好的类//java底层做了一些处理，让打印对象不是地址值而是属性值System.out.println(sb);System.out.println(sb1);}
}

StringBuilder的常见使用场景

1.字符串的拼接
2.字符串的反转

package string;import java.util.Scanner;public class StringBuilderTest1 {//使用StringBuilder的场景//1.字符串的拼接//2.字符串的反转public static void main(String[] args) {//判断字符串是否是对称的//1. 对称Scanner sc = new Scanner(System.in); //创建Scanner对象System.out.println("请输入字符串");String str = sc.next();//2.反转键盘录入的字符串StringBuilder sb = new StringBuilder(str);  //或者append(str)sb.reverse();if (sb.toString().equals(str)) {  //注意==比较的是地址值 //equals是string的方法，所以得先toStringSystem.out.println("是对称字符串");} else{System.out.println("不是对称字符串");}//拼接字符串//把数组拼接为字符串//1.定义数组int[] arr = {1,2,3};//2.调用方法把数组变成字符串String result = ArrToString(arr);System.out.println(result);}public static String ArrToString(int[] arr){  //point 这个方法不能嵌套在main方法中！！StringBuilder sb1 = new StringBuilder();sb1.append("[");for (int i = 0; i < arr.length; i++) {if(i == arr.length - 1){sb1.append(arr[i]);}else {sb1.append(arr[i]).append(",");}}sb1.append("]");String str1 = sb1.toString();return str1;}
}

3.5 StringJoiner

能指定开始、结束以及分隔符号

3.4.1 StringJoiner构造方法

3.4.3 StringJoiner成员方法

• 构造方法：StringJoiner没有空参构造，只有指定间隔符号/间隔符号，开始符号，结束符号

• 成员方法：StringJoiner也有add，length和toString的成员方法

package string;import java.util.StringJoiner;public class StringJoiner1 {  //不要和util的类同名，创建对象时会误会public static void main(String[] args) {//构造方法：StringJoiner没有空参构造，只有指定间隔符号/间隔符号，开始符号，结束符号//成员方法：StringJoiner也有add，length和toString的成员方法//1.创建对象，指定间隔符号StringJoiner sj = new StringJoiner(",");sj.add("abc").add("bbb");   //里面不能是数字，只能是字符串System.out.println(sj);System.out.println(sj.toString());//2.创建对象，指定间隔符号，开始结束符号StringJoiner sj1 = new StringJoiner(",","[","]");sj1.add("abc").add("bbb").add("ccc").add("ddd");System.out.println(sj1);//长度int len = sj1.length();  //注意这里的长度表示的是字符的个数！！System.out.println(len);//转为字符串System.out.println(sj1.toString());}
}

3.6 字符串的原理（还没有学）

3.7 字符串综合练习

3.7.1 罗马数字转换

核心思想：
查表法：数字和数据产生对应关系
方法一：定义一个数组，让索引和罗马产生一个对应关系

package string;import java.util.Scanner;
import java.util.StringJoiner;public class StringAllTest1Case1 {public static void main(String[] args) {/*键盘录入一个字符串，要求1:长度为小于等于9要求2:只能是数字将内容变成罗马数字下面是阿拉伯数字跟罗马数字的对比关系:I -1、II-2、III-3、 IV-4、V-5、VI-6、VII-7、VIII-8、IX-9注意点:罗马数字里面是没有0的如果键盘录入的数字包含0，可以变成""(长度为0的字符串)*/System.out.println('0');//1.键盘录入一个字符串Scanner sc = new Scanner(System.in);String str;  //声明在外面，里面也就能用while (true) {System.out.println("请输入字符串");str = sc.next();//2.校验字符串是否满足规则（拆分题目，这是第一个）boolean flag = checkStr(str);if(flag) {break;}else{System.out.println("当前字符串不符合规则，重新输入");continue;}}StringBuilder sb = new StringBuilder();StringJoiner sj = new StringJoiner(",","[","]");//将内容变成罗马数字//查表法：数字和数据产生对应关系for (int i = 0; i < str.length(); i++) {char c = str.charAt(i);int number = c - '0';  //或者c-48String s = ChangeLuoMa(number);sb.append(s);sj.add(s);}System.out.println(sb); // println(Object x) 会自动调用 x.toString() 来获取字符串形式。System.out.println(sj);}public static String ChangeLuoMa(int num) {//定义一个数组，让索引和罗马产生一个对应关系String[] arr = {"","I","II","III","IV","V","VI","VII","VIII","IX"};return arr[num];}public static boolean checkStr(String str) {//要求1:长度为小于等于9if(str.length() > 9){return false;}//要求2:只能是数字for (int i = 0; i < str.length(); i++) { //快捷方式 str.length().forichar c = str.charAt(i);if (c<'0' || c>'9') {return false;}}// 判断完所有的字符，才认为符合规则return true;}
}

方法二：使用switch

package string;import java.util.Scanner;
import java.util.StringJoiner;public class StringAllTest1Case2 {public static void main(String[] args) {/*键盘录入一个字符串，要求1:长度为小于等于9要求2:只能是数字将内容变成罗马数字下面是阿拉伯数字跟罗马数字的对比关系:I -1、II-2、III-3、 IV-4、V-5、VI-6、VII-7、VIII-8、IX-9注意点:罗马数字里面是没有0的如果键盘录入的数字包含0，可以变成""(长度为0的字符串)*/System.out.println('0');//1.键盘录入一个字符串Scanner sc = new Scanner(System.in);String str;  //声明在外面，里面也就能用while (true) {System.out.println("请输入字符串");str = sc.next();//2.校验字符串是否满足规则（拆分题目，这是第一个）boolean flag = checkStr(str);if(flag) {break;}else{System.out.println("当前字符串不符合规则，重新输入");continue;}}StringBuilder sb = new StringBuilder();StringJoiner sj = new StringJoiner(",","[","]");//将内容变成罗马数字//查表法：数字和数据产生对应关系for (int i = 0; i < str.length(); i++) {char c = str.charAt(i);String s = ChangeLuoMa(c);//int number = c - '0';  //或者c-48//String s = ChangeLuoMa(number);sb.append(s);sj.add(s);}System.out.println(sb); // println(Object x) 会自动调用 x.toString() 来获取字符串形式。System.out.println(sj);}public static String ChangeLuoMa(char number) {//1.定义一个数组，让索引和罗马产生一个对应关系//String[] arr = {"","I","II","III","IV","V","VI","VII","VIII","IX"};//return arr[num];// 2.使用switch//String str;//switch (number) {//    case '0' -> str = "";//    case '1' -> str = "I";//    case '2' -> str = "II";//    case '3' -> str = "III";//    case '4' -> str = "IV";//    case '5' -> str = "V";//    case '6' -> str = "VI";//    case '7' -> str = "VII";//    case '8' -> str = "VIII";//    case '9' -> str = "IX";//    default -> str = "";//}//3. 使用便捷的switchString str = switch (number){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 str;}public static boolean checkStr(String str) {//要求1:长度为小于等于9if(str.length() > 9){return false;}//要求2:只能是数字for (int i = 0; i < str.length(); i++) { //快捷方式 str.length().forichar c = str.charAt(i);if (c<'0' || c>'9') {return false;}}// 判断完所有的字符，才认为符合规则return true;}
}

3.7.2 调整字符串的内容并比较

套路：
如果看到要修改字符串中的内容，有两个办法

1. 使用subString进行截取，把左边的字符截取出来拼接到右侧

2. 把字符串先变为一个字符数组，然后调整字符数组里面的数据，最后再把字符数组变为字符串

方法一：使用substring进行截取

package string;public class StringAllTest2Case1 {/* ** 调整字符串给定两个字符串, A和B。A的旋转操作就是将A最左边的字符移动到最右边。例如,若A= ‘abcde’,在移动一次之后结果就是’bcdea’如果在若干次调整操作之后，A能变成B,那么返回True。如果不能匹配成功，则返回false*/public static void main(String[] args) {// 1.输入或者直接定义两个字符串//Scanner sc = new Scanner(System.in);//System.out.println("请输入字符串a");//String strA = sc.next();//System.out.println("请输入字符串b");//String strB = sc.next();String strA = "abc";String strB = "bca";    //abc和cba是无法通过左旋互相得到的、、、//1. 旋转字符串//2.比较字符串boolean result = check(strA, strB);System.out.println(result);}public static boolean check(String strA, String strB) {for (int i = 0; i < strA.length(); i++) { //限制旋转次数strA = rotate(strA);System.out.println(strA);if(strA.equals(strB)) { //一步一步比，不要想着都弄完了再比return true;}}return false;}public static String rotate(String str) {//套路：//如果看到要修改字符串中的内容，有两个办法//1.使用subString进行截取，把左边的字符截取出来拼接到右侧//2.把字符串先变为一个字符数组，然后调整字符数组里面的数据，最后再把字符数组变为字符串//截取思路1//获取最左侧的字符//char first = str.charAt(0);////获取剩余的字符//String end = str.substring(1);//return end+first;//截取思路2StringBuilder sb = new StringBuilder();sb.append(str.substring(1)).append(str.substring(0,1));return sb.toString();}
}

方法二：使用字符数组
str.toCharArray()可以将字符串str "ABC" 变为 ['A','B','C']

package string;public class StringAllTest2Case2 {public static void main(String[] args) {// 1.输入或者直接定义两个字符串//Scanner sc = new Scanner(System.in);//System.out.println("请输入字符串a");//String strA = sc.next();//System.out.println("请输入字符串b");//String strB = sc.next();String strA = "abcde";String strB = "cdeab";    //abc和cba是无法通过左旋互相得到的、、、boolean result = check(strA, strB);System.out.println(result);}public static boolean check(String strA, String strB) {for (int i = 0; i < strA.length(); i++) {strA = rotate(strA);if (strB.equals(strA)) {return true;}}return false;}public static String rotate(String str){//套路：//如果看到要修改字符串中的内容，有两个办法//2.把字符串先变为一个字符数组，然后调整字符数组里面的数据，最后再把字符数组变为字符串//"ABC"  ['A','B','C']  new String(字符数组)这样也可以得到新的字符串char[] arr = str.toCharArray();//拿到0索引的字符char first = arr[0];//把剩余的字符往前挪一个位置for (int i = 1; i < arr.length; i++) {arr[i-1] = arr[i];}arr[arr.length-1] = first;//利用字符数组创建一个字符串对象return new String(arr);}
}