javaSE字符串学习笔记

API和API帮助文档

API

API(Application Programming Interface)：应用程序编程接口
简单理解：API酒啊别人已经写好的东西，我们不需要自己编写，直接使用即可。

API这个术语在编程圈中非常常见.我第一次接触API这个词语是在大一下。老师的要求很简单，让我写接口调用API。这个我也是实现了，但是有很多不理解的地方，API是什么，我写的是API，还是别人写的是api。到现在，还是很迷糊。

API就是一段函数、方法。是别人已经写好的，我们负责用就可以。用一段python代码举个例子

ans = fun()

我调用了fun() 函数，那么fun()就是API。

Java中的API

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

简单理解就是JDK给我们提供的API。

API帮助文档

目前，我们已经学习过两个API，分别是Scanner键盘输入的API和Random随机数的API.除此之外，JDK还提供了很多的API，好在这些api不需要刻意去记，都放在了一个文档中，API帮助文档：[Java参考文档].JDK_API_1_6_zh_CN.CHM

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

这个里面汇集了Java已经定义好的各种包。

因为这个里面汇集了大量的Java包，我们想找到其中一个，那就是大海捞针了。因此我们需要搜索

搜索的方式：点击右上角的【显示】——【索引】——就会发现搜索框，搜索然后回车。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

对于这个界面，我们应该学会查看基础的信息

看类所在的包

从上向下看，java.util 表示Random类定义在java.util 下，因此使用时需要导包，
```
import java.util.Random;
```
查看类的描述

第一行就是Random类的描述，此类的实例用于生成伪随机数流。这个类我们已经用过了，不假。

下面还有一个版本JDK1.0表示在JDK1.0的时候就有Random这个类了。即所有JDK这个版本都可以使用这个类、

如果出现一个JDK8的字样，那么这类只有在高于或等于JDK8的时候可以用，低于JDK8不能用。
查看构造方法

既然导入了这个类，那我们肯定是使用这个类实现一些功能。那就得获取这个类的对象。因此构造方法决定了如何创建对象。这个时候出现了如下代码
```
Random r = new Random();
```
这是一个空参构造
查看成员方法

方法名一样，但是参数不一样，重载。

因此也就用了如下代码。
```
res = r.nextInt(10);
```

练习

需求：按照帮助文档的使用步骤学习Scanner类的使用，并实现接收键盘录入一个小数，最后输出在
控制台

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

这些构造方法没有一个是空参的。我们实际上用的是第三个，

        Scanner sc = new Scanner(System.in);

此时括号里就不能是空的了，会报错。原因是没有空参构造。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

他要的是小数，直接看方法摘要。小数是float。找到了。

import java.util.Scanner;public class ScannerDemo1 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入一个小数");double result = sc.nextDouble();System.out.println(result);}
}

老师用的是nextDouble()方法。但是我以为nextFloat()方法也是可以的。因此改动

        float result = sc.nextFloat();

在Java数据类型中float和double都是小数，题目中也没有明确。

字符串

String概述

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！

String str1 = "Hello World!";
String str2 = "你好 世界！";

这里要注意两点，Java的字符串数字类型是String，还有一点字符串有双引号""括起来。

字符串的内容是不会改变的，他的对象在创建后不能被更改。

String name = "张三";
String classroom = "大数据";
System.out.println(name+classroom);

字符串拼接产生一个新的字符串。这段代码很好理解。

String name = "张三";
name = "李四";

对于这段代码，我们的思维肯定是一开始创建一个name的字符串并赋值张三，然后接着把name字符串的值改成李四。

但是在Java中对这段代码有更严谨的描述：一开始创建了一个字符串张三赋值给了name，随后有创建了一个字符串李四，赋值给了name，看上去name的值发生了改变，实际上字符串张三并没有发生改变。从而产生了两个字符串。因此字符串的内容不会发生改变。

创建String对象

创建String对象共有两种方式，第一种方式简单粗暴，直接赋值。第二种方式通过new关键字进行创建。

直接创建代码示例

String str1 = "Hello World!";

接下来是如何通过new创建。

方法名	说明
`public String()`	创建一个空白字符串对象，不含有任何内容
`public String(char[] chs)`	根据字符数组的内容，来创建字符串对象
`public String(byte[] bys)`	根据字节数组的内容，来创建字符串对象
`String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc

以上是Java常用的构造方法。

代码示例

public class StringDome01 {public static void main(String[] args) {// 直接赋值方式String str1 = "abcd";System.out.println(str1);  // abcd// 空参构造String str2 = new String();System.out.println("@"+str2+"!");  // @!// 传递一个字符粗String str3 = new String("abcd");System.out.println(str3);  // abcd// 传递一个字符数组char[] chs = {'a', 'b', 'c', 'd'};String str4 = new String(chs);System.out.println(str4);  // abcd// 传递一个字节数组byte[] bytes = {97, 98, 99, 100};String str5 = new String(bytes);System.out.println(str5);  // abcd}
}

在日常开发中，用的更多的是直接赋值方式，简单快捷。

空参构造，可以看成创建一个空的字符粗。"@"+str2+"!" = @!，因为str2 = ""str2没有

在构造方法中传递一个字符串。这个和直接赋值方法是一样的，反而多了一步。这里讲究效率的话直接使用直接复制方法。

传递一个字符数组，这个就有意思了。字符串对象创建后就不能修改了，但是我们可以修改数组里面的内容。如果把字符串adcd改成efgh。可以更改字符串的内容。

public class StringDome02 {public static void main(String[] args) {// 传递一个字符数组char[] chs = {'a', 'b', 'c', 'd'};String str4 = new String(chs);System.out.println("字符串str4更改前");System.out.println(str4);  // abcdchs[0] = 'e';chs[1] = 'f';chs[2] = 'g';chs[3] = 'h';str4 = new String(chs);System.out.println("字符串str4更改后");System.out.println(str4);  // efgh}
}

传递字节数组，97，98，99，100这四个数字刚好对应abcd的ASCII码，他的转换流程是先查找ASCII码，再进行转换。在开发中多用于网络，网络的信息传递都是字节，因此需要转换成我们能看懂的字符串。

以上解除了五种字符串创建的方式，常用的是直接创建。但直接创建不是因为简单而出名，他还有其他学问。这里需要借助Java的内存模型。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

首先，回忆一下Java的内存模型。这是目前我们已经学习过的Java内存模型。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

现在多了一块串池，因此这部分用于存放字符串，但是只有直接创建的字符串才会放到串池里面。在JDK7以前，串池在方法区里面。JDK7以后，串池挪到了堆内存里面。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

以上是理论学习，接下来分析源码

先说直接赋值方式，代码如下

public class StringDome01 {public static void main(String[] args) {// 直接赋值方式String str1 = "abcd";String str2 = "abcd";}
}

他的内存如图

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

执行这段程序，那么main()方法会先进栈。开始从上到下执行代码。String str1 = "abcd";，在main方法里面开辟一块内存，内存名是str1，内存的数据类型是String。前面提到过String类型是字符串类型，字符串保持在串池里面。在串池里面创建时，首先会看一下串池里面有没有数据"abcd"，第一次创建肯定没有，开辟一小块内存，存放数据"abcd"，这块内存的地址是0x0011,随后返回到栈内存，得知在栈内存中str1保存的数据是串池里面内存地址是0x0011的数据。

接着执行String str2 = "abcd";。和上面步骤一样，在堆内存里面创建内存起名str2。因为是String类型，且还是直接赋值方式，会自动在串池里面找有没有与"abcd"相同的数据，如果有，那就返回"abcd"数据的内存地址。如果没有那就创建数据"abcd"然后返回。

正好在串池里面发现了数据"abcd"，因此就返回了他的内存地址0x0011。从而在栈内存中str2保存的数据是串池里面内存地址是0x0011的数据。

当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在。
不存在：创建新的
存在：复用

接下来看new创建的对象

代码如下

public class StringDome01 {public static void main(String[] args) {char[] chs = {'a', 'b', 'c', 'd'};String str1 = new String(chs);String str2 = new String(chs);}
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

对于这张内存图，看着就复杂多了。

首先我们要知道，new出来的东西要放在堆内存里面。

执行第一行代码char[] chs = {'a', 'b', 'c', 'd'};在栈内存中开辟空间，起名chs并且在堆内存中也是开辟内存存放数组数据，随后返回堆内存中的数组地址0x0011给栈内存中的chs空间。

执行第二行代码String str1 = new String(chs);按照常例，在栈内存中开辟空间，这一次因为是new，所以String类型的数据还需要在堆内存里面开辟框架。这块内存里的内容就是字符数组的内容。随后还是返回堆内存里面的地址0x0022给str1

执行第三行代码String str2 = new String(chs);一切照旧。虽然str2和str1创建的内容是一样的，但是在堆内存里面并没有引用而是创建了两个"abcd"

以上就是直接创建和new创建的区别，从图片上就可以看出来。new创建使用的内存资源多。因此直接使用yyds！

字符串的比较

==号比较方式

比较基本数据类型：比较的是具体的值
比较引用数据类型：比较的是对象地址值

这么看比较难懂，通过代码来解释

public class StringDemo03 {public static void main(String[] args) {String str1 = "abc";String str2 = "abc";String str3 = "def";System.out.println(str1==str2);  // trueSystem.out.println(str1==str3);  // false}
}

先从代码表面看，str1和str1的值都是一样的abc，因此是返回true，str1和str3的值不一样，返回false。单纯这样理解只能半对。上面代码中创建字符串对象用的是直接复制方式，创建的字符串都放在串池里面。如果创建相同的字符串，是复用，那么肯定相同。

public class StringDemo03 {public static void main(String[] args) {String str1 = "abc";String str2 = new String("abc");System.out.println(str1==str2);  // false}
}

看上去str1和str1的值都是一样的abc，返回的结果却是false。直接引用方式创建的字符串放在串池里面，通过new关键字创建的字符串在堆内存里面。虽说这两个字符串都是相同的，但是一个保存在串池里面，一个在堆里面。他们的内存地址完全不同，因此返回false

public class StringDemo03 {public static void main(String[] args) {String str1 = new String("abc");String str2 = new String("abc");System.out.println(str1==str2);  // false}
}

还是返回false，因为通过new出来的字符串在堆内存里面，而且不是相互引用。看上去两个字符串是相同的，但是他们地址不同。

.equals方法的作用

方法名	描述	返回类型
`.equals()`	字符串比较，相同返回true，否则返回false	boolean
`equalsIgnoreCase()`	忽略大小写的字符串比较	boolean

.equals()

public class StringDemo04 {public static void main(String[] args) {String str1 = "abc";String str2 = new String("abc");boolean res = str1.equals(str2);System.out.println(res);  // true}
}

.equalsIgnoreCase()

public class StringDemo04 {public static void main(String[] args) {String str1 = "abc";String str2 = new String("Abc");boolean res = str1.equalsIgnoreCase(str2);System.out.println(res);  // true}
}

.equals()常用于密码验证，而.equalsIgnoreCase()常用于验证码验证

import java.util.Scanner;public class StringDemo05 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);String str1 = sc.next();String str2 = "abc";boolean res = str1.equals(str2);System.out.println(str1 == str2);  // falseSystem.out.println(res);  // true}
}

对于这段代码而言，看似String str1 = sc.next();是一个直接赋值，实际上是new，因此，str1 == str2返回false。

这里就需要看一下sc.next()的源码，选中next快捷键ctrl+B，跟进源码，一直找到与next相关的核心代码。

通过一系列的跟进操作之后，找到了核心代码

    public static String newString(byte[] val, int index, int len) {if (len == 0) {return "";}return new String(Arrays.copyOfRange(val, index, index + len),LATIN1);}

说白了，还是new。

案例

用户登录

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

import java.util.Scanner;public class StringDemo06 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);String rightUsername = "admin";String rightPassword = "abc000";for (int i = 0; i < 3; i++) {System.out.print("请输入用户名: ");String username = sc.next();System.out.print("请输入密码: ");String password = sc.next();if (rightUsername.equals(username) && rightPassword.equals(password)){System.out.print("用户登录成功");break;}else{if(i<3) System.out.println("用户名或密码有误！请重新输入，还有"+ (2 - i) + "次机会。");else System.out.println("用户登录失败，" + username + "已锁定，请联系管理员");}}}
}

先可以进行一次成功的登录代码逻辑后，再加一个for循环就好。

字符串遍历

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

首先介绍两个方法

方法	描述
`public char charAt(int index)`	根据索引返回字符
`public int length()`	返回此字符串的长度

在这里需要注意一下方法.length()的使用方式。

在数组中也有.length的使用，具体用法是arr.length，而在字符串中是str.length()。他们之间的区别在于小括号，是因为在数组中，.length是属性，而字符串中.length()是方法，数学没有小括号，方法需要加小括号。

import java.util.Scanner;public class StringDemo07 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.print("请输入字符: ");String str = sc.next();for (int i = 0; i < str.length(); i++) {char ch = str.charAt(i);System.out.println(ch);}}
}

这个代码的核心是：

for (int i = 0; i < str.length(); i++) {char ch = str.charAt(i);  // 根据索引返回字符System.out.println(ch);}
}

str.charAt(i)是根据索引返回字符串，我们就知道Java的字符串也是有索引的，学过计算机的都知道，索引是从0开的，那么根据这个逻辑，就解释通了。

i < str.length()字符串长度-1就是最后一个索引，所以这里设置成小于，也可以是小于等于i <= str.length()-1

字符串统计

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

import java.util.Scanner;public class StringDemo08 {public static void main(String[] args) {int bigCount = 0;int smallCount = 0;int numberCount = 0;Scanner sc = new Scanner(System.in);// 输入字符串System.out.println("请输入字符串");String text = sc.next();  // HelloWorld!123// 遍历字符串进行统计for (int i = 0; i < text.length(); i++) {char ch = text.charAt(i);// 统计if (ch >= 'a' && ch <= 'z') smallCount++;else if (ch >= 'A' && ch <= 'Z') bigCount++;else if (ch >= '0' && ch <= '9') numberCount++;}System.out.println("字符串统计结果如下：");System.out.println("大写有：" + bigCount + "个");  // 大写有：2个System.out.println("小写有：" + smallCount + "个");  // 小写有：8个System.out.println("数字有：" + numberCount + "个");  // 数字有：3个}
}

这段代码的核心部分是统计部分。这里需要中注意一点的是：char类型在参与运算的时候会升为int类型，因此比较的是ASCII码。

ch >= '0' && ch <= '9'不要写成ch >= 0 && ch <= 9'，因为 String text = sc.next()输入的是字符串类型，因此123也就字符串

字符串拼接

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

并在控制台输出结果。例如，数组为 int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]

public class StringDemo09 {public static void main(String[] args) {int[] arr = {1,2,3,4,5};String result = arrToString(arr);System.out.println(result);}public static String arrToString(int[] arr) {if (arr == null) return "";else if (arr.length == 0)  return "[]";else  {String str = "[";for (int i = 0; i < arr.length; i++) {if (i == arr.length-1) str += arr[i];else str += arr[i] + ", ";}str += "]";return str;}}
}

题目中有要求用方法，Java的数组是 {1,2,3}，需要转换成 [1,2,3]

else  {String str = "[";for (int i = 0; i < arr.length; i++) {if (i == arr.length-1) str += arr[i];else str += arr[i] + ", ";}str += "]";return str;

字符串初始是"["，后面用到了字符串加字符串的知识str += arr[i] + ", "，要注意最后一个元素后面不跟, 因此str += arr[i]，后面还有一个"]"

字符串反转

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

例如，键盘录入 abc，输出结果 cba

import java.util.Scanner;public class StringDemo10 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.print("请输入字符串: ");String str = sc.next();  // helloString res = reverse(str);System.out.print(res);  // olleh}public static String reverse(String str){String res = "";for (int i = str.length()-1; i >= 0; i--) {res += str.charAt(i);}return res;}
}

字符串遍历的循环是“

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

字符串反转

for (int i = str.length()-1; i >= 0; i--) {res += str.charAt(i);
}

金额转换

把2135变成：零佰零拾零万贰仟壹佰叁拾伍元

把789变成：零佰零拾零万零仟柒佰捌拾玖元

import java.util.Scanner;public class StringDemo11 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int money, count;String[] unitArr = {"佰","拾","万","仟","佰","拾","元"};String capitalNumber= "", result = "";// 判断输入是否合法while (true) {System.out.println("请输入金额");money = sc.nextInt();// 合法输入if (money >= 0 && money <= 9999999) break;// 非法输入，重新输入else System.out.println("非法输入，重新输入");}while (money != 0) {int ge = money % 10;money /= 10;capitalNumber = getCapitalNumber(ge) + capitalNumber;}//3.在前面补0，补齐7位count = 7 - capitalNumber.length();for (int i = 0; i < count; i++) {capitalNumber = "零" + capitalNumber;}// 插入单位for (int i = 0; i < unitArr.length; i++) {result += capitalNumber.charAt(i) + unitArr[i];}System.out.println(result);}public static String getCapitalNumber(int num){String[] capitalNumberArr = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};return capitalNumberArr[num];}}

这道题的代码，我们需要认真分析一下。因为看到这道题的时候我也没有思路

先是定义了一个方法，getCapitalNumber得到这个数字的大写，例如getCapitalNumber(1)返回壹。

判断输入的内容有没有问题是一个很好的习惯，

while (money != 0) {int ge = money % 10;money /= 10;capitalNumber = getCapitalNumber(ge) + capitalNumber;
}

这部分的逻辑是数字的小写转大写。用到了数位拆分。取个位用取余%。比如12%10就是个商1余2，取余数，2被取出来了。12/10，是个1，1被取出来，接着取余是1.

capitalNumber = getCapitalNumber(ge) + capitalNumber;

每取出一位数就得到他的大写。然后保存到capitalNumber

capitalNumber变量的初始化是空的，在最开始。假设我们要进行拆分的数字是123、

那么第一次拆分下来的数字应该是3，叁；即"叁" + " "，得到的结果是"叁"

第二次拆分后是2，贰；即"贰" + "叁"，得到的结果是"贰叁"

第三次拆分后是1，壹；即"壹" + "贰叁"，得到的结果是"壹贰叁"

长度已经统一了，因此长度不够的话需要补位。然后是插入单位。

在这里有个细节。

capitalNumber += getCapitalNumber(ge);

在大部分情况下我们都会这样写，用的+=。这样等价于capitalNumber = capitalNumber + getCapitalNumber(ge) ;

那么第一次拆分下来的数字应该是3，叁；即" " + "叁"，得到的结果是"叁"

第二次拆分后是2，贰；即"叁" + "贰"，得到的结果是"叁贰"

第三次拆分后是1，壹；即"贰叁" + "壹"，得到的结果是"叁贰壹"

数位拆分后的结果应该是反过来的，比如1234的数位拆分的结构是：4 3 2 1,得到的大写也应该是肆叁贰壹 。这与我们需要的结果不符，需要的结果是壹贰叁肆。如果需要壹贰叁肆这种形式，那么就需要capitalNumber = getCapitalNumber(ge) + capitalNumber;

手机号屏蔽

需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽

最终效果为：131****9468

方法名	描述
`substring(int beginIndex)`	返回一个新的字符串，它是此字符串的一个子字符串。
`substring(int beginIndex, int endIndex)`	返回一个新字符串，它是此字符串的一个子字符串。

public class StringDemo12 {public static void main(String[] args) {String phoneNumber = "12345678910";String start = phoneNumber.substring(0, 3);  // 前三位String end = phoneNumber.substring(7);  // 后四位String result = start + "****" + end;System.out.println(result);}
}

字符串切片，和python的大同小异。

.substring(0, 3)从字符串的0索引开始到3索引结束，不包括3索引的字符。包左不包右，包头不包尾。

.substring(7)从字符串的7---------索引开始到字符串结束

敏感词替换

需求1：键盘录入一个字符串，如果字符串中包含（TMD），则使用***替换

方法名	描述
`replace(char oldChar, char newChar)`	返回一个新的字符串，它是通过用 `newChar` 替换此字符串中出现的所有 `oldChar` 得到的。

public class StringDemo14 {public static void main(String[] args) {String talk = "后裔你玩什么啊，TMD";String result = talk.replace("TMD", "***");  // 替换System.out.println(talk);  // 后裔你玩什么啊，TMDSystem.out.println(result);  // 后裔你玩什么啊，***}
}

这里用到了字符串替换方法。replace()

import java.util.Scanner;public class StringDemo15 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入要说的话");String talk = sc.next();  // 后裔你玩什么啊，TMD,GDX,ctmd,ZZString[] sensitiveWordsArr = {"TMD","GDX","ctmd","ZZ","lj","FW","nt"};for (int i = 0; i < sensitiveWordsArr.length; i++) {talk = talk.replace(sensitiveWordsArr[i],"***");}System.out.println(talk);  // 后裔你玩什么啊，***,***,***,***}
}

如果有多个敏感词，那么做一个敏感词数组，遍历数组，一一替换。

身份证信息查看

身份证的每一位都是有固定的含义：

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

要求打印内容方式如下：

人物信息为：

出生年月日：XXXX年X月X日

性别为：男/女

public class StringDemo13 {public static void main(String[] args) {String id = "321281202001011234";// 获取年月日7~14String 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 + "日");// 性别char gender = id.charAt(16);int num = gender - 48;if(num % 2 == 0){System.out.println("性别为:女");}else {System.out.println("性别为:男");}}
}

简单理解就是对字符串的切片操作

StringBuilder

先看两段代码

public class StringDemo17 {public static void main(String[] args) {String s = "";for (int i = 0; i < 100000000; i++) {s = s + "abc";}System.out.println(s);}
}

这段代码，里面写了个循环，循环100000000次。程序不报错，也不会出来运行结果。

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

循环同样的次数，这段代码达到了我的要求。

这是老师课程引入的代码，具体为什么，我也不知道。

StringBuilder概述

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

老师举了个例子，字符串拼接

public class StringDemo19 {public static void main(String[] args) {String s1 = "aaa";String s2 = "bbb";String s3 = "ccc";String s4 = "ddd";String s5 = "eee";String s6 = s1 + s2 + s3 + s4 + s5;System.out.println();  // aaabbbcccdddeee}
}

字符串拼接，这段代码的逻辑是先拼接s1 + s2拼接后是aaabbb，紧接着是aaabbb + s3 = aaabbbccc、aaabbbccc + s4 = aaabbbcccddd、aaabbbcccddd + s5 = aaabbbcccdddeee，aaabbbcccdddeee赋值给s6。

然而产生的aaabbb，aaabbbccc ，aaabbbcccddd，aaabbbcccdddeee这些都会单独开辟空间进行存放。其实这些都没用了，最后我们就关心s6的结果。

而StringBuilder就不一样，这是个容器。相当于箱子。完成字符串拼接时会直接吧这堆字符串（s1，s2，s3，s4，s5）放进箱子里，顺其自然也就有了aaabbbcccdddeee

StringBuilder使用

构造方法

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

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

成员方法

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

import java.util.Random;public class StringBuilderDemo01 {public static void main(String[] args) {// 创建对象StringBuilder sb = new StringBuilder();Random r = new Random();System.out.println(sb);System.out.println(r);  // java.util.Random@3b07d329}
}

打印一个对象，会返回对象的地址值，如打印随机数创建的对象r，则返回java.util.Random@3b07d329，但是打印sb并没有返回。

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

import java.util.Random;public class StringBuilderDemo01 {public static void main(String[] args) {// 创建对象StringBuilder sb = new StringBuilder("abc");Random r = new Random();System.out.println(sb);  // abcSystem.out.println(r);  // java.util.Random@3b07d329}
}

在使用含参构造时，会打印容器里的内容。

public class StringBuilderDemo02 {public static void main(String[] args) {// 创建对象StringBuilder sb = new StringBuilder("abc");//添加元素sb.append(1);sb.append(1.2);sb.append(true);sb.append('c');System.out.println(sb);  // abc11.2truec}
}

.append()添加元素，这个方法有很多的重载，可以添加不同类型变量的数据

public class StringBuilderDemo02 {public static void main(String[] args) {// 创建对象StringBuilder sb = new StringBuilder("abc");//反转sb.reverse();System.out.println(sb);  // cba}
}

字符串反转，在这里就会发现StringBuilder对象的好处，不需要String str = 因此也节省内存。

public class StringBuilderDemo02 {public static void main(String[] args) {// 创建对象StringBuilder sb = new StringBuilder("abc");//统计长度int len = sb.length();System.out.println(len);  // 3}
}

输出字符串的长度。

public class StringBuilderDemo03 {public static void main(String[] args) {StringBuilder sb = new StringBuilder("aaa");sb.append("bbb");sb.append("ccc");sb.append("ddd");// 转换成String类型String str = sb.toString();String strNew = str.replace("aaa", "***");System.out.println(sb);  // aaabbbcccdddSystem.out.println(strNew);  // ***bbbcccddd}
}

把StringBuilder 类型的字符串转换成String类型的字符串，这样一来就可以用String的方法进行操作。以防String有的方法而StringBuilder 没有

链式编程

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

import java.util.Scanner;public class StringBuilderDemo04 {public static void main(String[] args) {StringBuilder sb = new StringBuilder();int len = getString().substring(1).replace("a", "z").length();sb.append("aaa").append("bbb").append("ccc").append("ddd");String str = sb.toString();System.out.println(len);  // 2System.out.println(sb);  // aaabbbcccdddSystem.out.println(str);  // aaabbbcccddd}public static String getString(){Scanner sc = new Scanner(System.in);System.out.println("输入字符串");return sc.next();}
}

其中int len = getString().substring(1).replace("a", "z").length();和sb.append("aaa").append("bbb").append("ccc").append("ddd");就是链式编程。链式编程的思想还是很常用的。

案例

对称字符串

需求：

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

import java.util.Scanner;public class StringBuilderDemo对称字符串 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入字符串");String str = sc.next();String strReverse = new StringBuilder(str).reverse().toString();  // 创建对象，反转，转换if(str.equals(strReverse)) System.out.println(str + "是对称字符串");else System.out.println(str + "不是是对称字符串");}
}

这段代码的逻辑很简单。在这里我想复制一份我写错的代码，我一开始写的。

// 错误的
import java.util.Scanner;public class StringBuilderDemo对称字符串 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入字符串");StringBuilder sb = new StringBuilder(sc.next());if(sb == sb.reverse()) System.out.println(sb + "是对称字符串");else System.out.println(sb + "不是是对称字符串");}
}

这段代码很简洁，我把链式编程运用到了极致。运行出来了，111是对称字符串、3221是对称字符串。看了运行结果，不对，

if(sb == sb.reverse()) System.out.println(sb + "是对称字符串");

这就是个错误，这是Java不是python。

反转的时候用StringBuilder，对比的时候还是要回到String的.equals()方法。

拼接字符串

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

调用该方法，并在控制台输出结果。

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

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

public class StringBuilderDemo字符串拼接 {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5};String str = arrTpString(arr);System.out.println(str);}public static String arrTpString(int[] arr) {StringBuilder sb = new StringBuilder().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();}
}

这道题很面熟的，做过。逻辑是一样的。只不过用的是StringBuilder。

StringBuilder的用途大部分是反转和字符串拼接，其他的操作StringBuilder也没有。

StringJoiner

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

看完了视频这个更方便，但是很少人用。

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

调用该方法，并在控制台输出结果。

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

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

还是这道题，第三次见。

import java.util.StringJoiner;public class StringJoinerDemo01 {public static void main(String[] args) {//1.定义数组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);}}

代码变短了，当然这和没有写方法不是一回事。

构造方法

方法名	描述
`public StringJoiner(间隔符号)`	创建StringJoiner对象，指定拼接时的间隔符号
`public StringJoiner(间隔符号, 开始符号, 结束符号)`	创建StringJoiner对象，指定拼接时的间隔符号，开始符号，结束符号

import java.util.StringJoiner;public class StringJoinerDemo02 {public static void main(String[] args) {StringJoiner sj = new StringJoiner("-");sj.add("aaa").add("bbb").add("ccc");System.out.println(sj);  // aaa-bbb-ccc}
}

使用无参构造方法

import java.util.StringJoiner;public class StringJoinerDemo03 {public static void main(String[] args) {StringJoiner sj = new StringJoiner(",", "[", "]");sj.add("aaa").add("bbb").add("ccc");System.out.println(sj);  // [aaa,bbb,ccc]}
}

含参构造

字符串原理

字符串拼接的底层原理

字符串拼接分两种情况，先看第一种情况

public class StringDemo20 {public static void main(String[] args) {String str = "a" + "b" + "c";System.out.println(str);  // abc }
}

拼接的时候没有变量，都是字符串。触发字符串优化机制。在编译的时候就已经是最终结果了。

这种情况是字符串的拼接过程中没有其余变量参与，在编译结束后，结果也就出来了。

首先我们会写Java文件，在写Java文件的时候会是这么一行语句： String str = "a" + "b" + "c";根据Java的执行逻辑，写完Java文件后，会进行编译。在编译完成之后 String str = "a" + "b" + "c";会变成 String str = "abc";然后直接输出。

public class StringDemo21 {public static void main(String[] args) {String str1 = "a";String str2 = str1 + "b";String str3 = str2 + "b";System.out.println(str3);  // abc}
}

在字符串拼接过程中有变量参与，这里还有分支

在JDK8之前，用的是StringBuilder拼接。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

熟悉的感觉

首先需要了解一下StringBuilder对象下的.toString()方法的源码，快捷键：CTRL+N

public static String newString(byte[] val, int index, int len) {if (len == 0) {return "";}return new String(Arrays.copyOfRange(val, index, index + len),LATIN1);
}

String str1 = "a";会先在串池里面存入字符串a

String str2 = str1 + "b"; 串池里面存放"b"。在字符串拼接的时候有变量参与，那么就会创建StringBuilder对象。这句话等价于 new StringBuilder().append(str1).append("b").toString()，刚刚看过toString()方法的源码，即一次加会创建两个对象

String str3 = str2 + "b";同理，放到串池，创建第二个StringBuilder对象、创建第二个String对象。

每一行在拼接的时候都会创建一个StringBuilder，因此效率慢了。

在jdk8以后，字符串拼接迎来了有害，他会预估用数组字符串的长度，然后创建String对象、

public class StringDemo22 {public static void main(String[] args) {String s1 = "a";String s2 = "b";String s3 = "c";String s4 = s1 + s2 + s3;System.out.println(s4);}
}

s1,s2,s3的字符串长度都是1，所以根据预估，就会创建一个长单是3的字符数组。再把字符数组转换成字符粗

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

如果是每一行字符粗拼接的时候都会有变量参与，那么效率还是会慢。

public class StringDemo21 {public static void main(String[] args) {String str1 = "a";String str2 = str1 + "b";String str3 = str2 + "b";System.out.println(str3);  // abc}
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

如果有很多，那么数组也会多，还是占内存。

如果很多字符粗变量拼接，不要直接+，会在底层创建多个对象，浪费时间、浪费性能

StringBuilder提高效率原理图

public class StringBuilderDemo05 {public static void main(String[] args) {StringBuilder sb = new StringBuilder();sb.append("a");sb.append("b");sb.append("c");System.out.println(sb);}
}

看一下这段代码的内存图

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

虽然这里的字符串a，b，c，不是直接赋值的方式创建的，但是字符还是放在了串池。如果细看底层源码，肯定离不开String对象。

StringBuilder内容可变，所以把所有元素都可以放里面放

容器的话，水装多了会爆，但是StringBuilder不会爆

面试题

题1

下列代码的运行结果

public class StringDemo23 {public static void main(String[] args) {String s1 = "abc";String s2 = "ab";String s3 = s2 + "c";System.out.println(s1 == s3);}
}

肯定不一样了，==号比的是内存地址。而他们的地址值不一样。

字符串拼接的时候，如果有变量：

JDK8以前：系统底层会自动创建一个StringBuilder对象，然后再调用其append方法完成拼接。
拼接后，再调用其toString方法转换为String类型，而toString方法的底层是直接new了一个字符串对象。
JDK8版本：系统会预估要字符串拼接之后的总大小，把要拼接的内容都放在数组中，此时也是产生一个新的字符串。

题2

读结果

public class StringDemo24 {public static void main(String[] args) {String s1 = "abc";String s2 = "a" + "b" + "c";System.out.println(s1 == s2);  // true}
}

这道题我以为是false。结果是true，他们的地址值一样。

因为是直接赋值，且在字符串拼接的时候没有变量参与。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

会先执行String s1 = "abc";，因此字符串"a"，"b"，"c"会在串池中创建，等到执行String s2 = "a" + "b" + "c";字符串"a"，"b"，"c"会进行复用。因此地址一样、

字符串在编译的时候会直接变成"abc"。复用

StringBuilder源码分析

在看源码之前，先了解一下StringBuilder的设计

在创建StringBuilder对象的时候，底层会创建一个16位的字节数组。默认容量是16，但是长度初始是0，因为没有东西。

容量：最多能装多少；
长度：实际上有多少；

接下来，分三种情况讨论：

存放abc（存放内容不超过16）：直接存放。此时长度为3，容量是16；
存放二十六个英文字母（超过16）：会触发默认的扩容机制原来长度(16)*2+2=34；
存放二十六个英文字母加零到九十个数字（扩容后还不够）：以实际长度为准；

public class StringBuilderDemo06 {public static void main(String[] args) {StringBuilder sb1 = new StringBuilder();StringBuilder sb2= new StringBuilder();StringBuilder sb3 = new StringBuilder();StringBuilder sb4 = new StringBuilder();// StringBuilder的初始容量和长度System.out.println(sb1.capacity());  // 16System.out.println(sb1.length());  // 0// 存放内容不超过16sb2.append("abc");System.out.println(sb2.capacity());  // 16System.out.println(sb2.length());  // 3// 存放内容超过16sb3.append("abcdefghijklmnopqrstuvwxzy");System.out.println(sb3.capacity());  // 34System.out.println(sb3.length());  // 26// 扩容之后还不够sb4.append("abcdefghijklmnopqrstuvwxzy0123456789");System.out.println(sb4.capacity());  // 36System.out.println(sb4.length());  // 36}
}

上面的代码虽然有点乱，不影响。验证了StringBuilder的容器机制。在StringBuilder中有两个方法

.capacity()：查看当前StringBuilder容器容量。
.length()：查看当前StringBuilder容器长度

接下来学习源码

选中StringBuilder后CTRL+B，

    /*** Constructs a string builder with no characters in it and an* initial capacity of 16 characters.*/@IntrinsicCandidatepublic StringBuilder() {super(16);}

这是一个空参构造，这里idea有个提示显示super(capacity:16)，capacity是容量的意思。所以说，在进行构造的时候这个容量就已经定了。

按住CTRL不松，点击super进入

    /*** Creates an AbstractStringBuilder of the specified capacity.*/AbstractStringBuilder(int capacity) {if (COMPACT_STRINGS) {value = new byte[capacity];coder = LATIN1;} else {value = StringUTF16.newBytesFor(capacity);coder = UTF16;}}

. AbstractStringBuilder()方法的参数是int capacity，其内容是 value = new byte[capacity];创建有个长度是capacity长的数组。那么super(16)就是创建一个长度是16的字符数组。

接下来，看appen方法，看参数是字符串的，因为append方法都很多重载。

    @Override@IntrinsicCandidatepublic StringBuilder append(String str) {super.append(str);return this;}

ctrl点击append

    /*** Appends the specified string to this character sequence.* <p>* The characters of the {@code String} argument are appended, in* order, increasing the length of this sequence by the length of the* argument. If {@code str} is {@code null}, then the four* characters {@code "null"} are appended.* <p>* Let <i>n</i> be the length of this character sequence just prior to* execution of the {@code append} method. Then the character at* index <i>k</i> in the new character sequence is equal to the character* at index <i>k</i> in the old character sequence, if <i>k</i> is less* than <i>n</i>; otherwise, it is equal to the character at index* <i>k-n</i> in the argument {@code str}.** @param   str   a string.* @return  a reference to this object.*/public AbstractStringBuilder append(String str) {if (str == null) {return appendNull();}int len = str.length();ensureCapacityInternal(count + len);putStringAt(count, str);count += len;return this;}

会先判断字符串是否是空的，null。如果是空，接着ctrl点击.appendNull()方法

   private AbstractStringBuilder appendNull() {ensureCapacityInternal(count + 4);int count = this.count;byte[] val = this.value;if (isLatin1()) {val[count++] = 'n';val[count++] = 'u';val[count++] = 'l';val[count++] = 'l';} else {count = StringUTF16.putCharsAt(val, count, 'n', 'u', 'l', 'l');}this.count = count;return this;}

可以看到是往val数组里面存放null。count表示已经存了几个字符。初始是0；

如果存放的字符串不是空的，那么先获取长度int len = str.length();

然后ensureCapacityInternal(count + len); 这里的count是字符串长度。

也可以证明一下count就是长度，快捷键从ctrl+f12，选择length方法

    /*** Returns the length (character count).** @return  the length of the sequence of characters currently*          represented by this object*/@Overridepublic int length() {return count;}

返回count。ensureCapacityInternal(count + len); 方法里的参数count + len count默认是0，假设存放字符串"abc"，那么len就是3。0+3 在idea里面有提示 ensureCapacityInternal(minimumcapacity: count + len); minimumcapacity是对count + 3的解释。最小容量是3.

CTRL点击ensureCapacityInternal方法

    /*** For positive values of {@code minimumCapacity}, this method* behaves like {@code ensureCapacity}, however it is never* synchronized.* If {@code minimumCapacity} is non positive due to numeric* overflow, this method throws {@code OutOfMemoryError}.*/private void ensureCapacityInternal(int minimumCapacity) {// overflow-conscious codeint oldCapacity = value.length >> coder;if (minimumCapacity - oldCapacity > 0) {value = Arrays.copyOf(value,newCapacity(minimumCapacity) << coder);}}

这里有一个新的变量名oldCapacity老容量，默认容量16。if (minimumCapacity - oldCapacity > 0)这个if条件是判断要不要扩容。3-16=-13 -13<0条件为false，要存放的字符串长度减去默认容量16如果小于0，那么就不扩容。

假设存放字符串abcdefghijklmnopqrstuvwxzy超过了默认容量。因为26-16=10 又10>0所以要扩容。

if (minimumCapacity - oldCapacity > 0) {value = Arrays.copyOf(value,newCapacity(minimumCapacity) << coder);}

按住CTRL选择newCapacity、 newCapacity(minimumCapacity)，可知 minimumCapacity=26

    /*** Returns a capacity at least as large as the given minimum capacity.* Returns the current capacity increased by the current length + 2 if* that suffices.* Will not return a capacity greater than* {@code (MAX_ARRAY_SIZE >> coder)} unless the given minimum capacity* is greater than that.** @param  minCapacity the desired minimum capacity* @throws OutOfMemoryError if minCapacity is less than zero or*         greater than (Integer.MAX_VALUE >> coder)*/private int newCapacity(int minCapacity) {int oldLength = value.length;int newLength = minCapacity << coder;int growth = newLength - oldLength;int length = ArraysSupport.newLength(oldLength, growth, oldLength + (2 << coder));if (length == Integer.MAX_VALUE) {throw new OutOfMemoryError("Required length exceeds implementation limit");}return length >> coder;}

这个方法的参数是minCapacity是最小容量，把26传了进来。oldLength老的长度，那就是16；newLength是新的长度，等于minCapacity那就是26。growth 是newLength - oldLength应该是需要新增的长度。

int length = ArraysSupport.newLength(oldLength, growth, oldLength + (2 << coder));中.newLength()方法，传入了老的长度、新增长度以及 oldLength + (2 << coder)意思是老长度+2左移coder，coder针对中文，没有中文就是0；CTRL.newLength()方法

    /*** Computes a new array length given an array's current length, a minimum growth* amount, and a preferred growth amount. The computation is done in an overflow-safe* fashion.** This method is used by objects that contain an array that might need to be grown* in order to fulfill some immediate need (the minimum growth amount) but would also* like to request more space (the preferred growth amount) in order to accommodate* potential future needs. The returned length is usually clamped at the soft maximum* length in order to avoid hitting the JVM implementation limit. However, the soft* maximum will be exceeded if the minimum growth amount requires it.** If the preferred growth amount is less than the minimum growth amount, the* minimum growth amount is used as the preferred growth amount.** The preferred length is determined by adding the preferred growth amount to the* current length. If the preferred length does not exceed the soft maximum length* (SOFT_MAX_ARRAY_LENGTH) then the preferred length is returned.** If the preferred length exceeds the soft maximum, we use the minimum growth* amount. The minimum required length is determined by adding the minimum growth* amount to the current length. If the minimum required length exceeds Integer.MAX_VALUE,* then this method throws OutOfMemoryError. Otherwise, this method returns the greater of* the soft maximum or the minimum required length.** Note that this method does not do any array allocation itself; it only does array* length growth computations. However, it will throw OutOfMemoryError as noted above.** Note also that this method cannot detect the JVM's implementation limit, and it* may compute and return a length value up to and including Integer.MAX_VALUE that* might exceed the JVM's implementation limit. In that case, the caller will likely* attempt an array allocation with that length and encounter an OutOfMemoryError.* Of course, regardless of the length value returned from this method, the caller* may encounter OutOfMemoryError if there is insufficient heap to fulfill the request.** @param oldLength   current length of the array (must be nonnegative)* @param minGrowth   minimum required growth amount (must be positive)* @param prefGrowth  preferred growth amount* @return the new array length* @throws OutOfMemoryError if the new length would exceed Integer.MAX_VALUE*/public static int newLength(int oldLength, int minGrowth, int prefGrowth) {// preconditions not checked because of inlining// assert oldLength >= 0// assert minGrowth > 0int prefLength = oldLength + Math.max(minGrowth, prefGrowth); // might overflowif (0 < prefLength && prefLength <= SOFT_MAX_ARRAY_LENGTH) {return prefLength;} else {// put code cold in a separate methodreturn hugeLength(oldLength, minGrowth);}}

newLength()方法有三个参数。int oldLength老长度16， int minGrowth新增长度10， int prefGrowth老长度+2得18

在这里CTRLmax的源码；

    /*** Returns the greater of two {@code int} values. That is, the* result is the argument closer to the value of* {@link Integer#MAX_VALUE}. If the arguments have the same value,* the result is that same value.** @param   a   an argument.* @param   b   another argument.* @return  the larger of {@code a} and {@code b}.*/@IntrinsicCandidatepublic static int max(int a, int b) {return (a >= b) ? a : b;}

这是一个三目运算符。a是新增长度10，b是老长度+2得18；因为是18大，所以max的return是18；

回到上一段代码中； int prefLength = oldLength + Math.max(minGrowth, prefGrowth);我们已经知道了 Math.max(minGrowth, prefGrowth);的结果是18，那么，oldLength是16，所以prefLength 就是16+18=34。也可以看作16*2+2=34；prefLength是34，现在新建的长度。

如果在三目运算符比较中，新增的要大，那么就是prefLength = coldLength + minGrowth 新建的长度。

跨度有点大： int length = ArraysSupport.newLength(oldLength, growth, oldLength + (2 << coder));因此计算出来需要扩容的长度。为了方便，我把代码复制一份

 private int newCapacity(int minCapacity) {int oldLength = value.length;int newLength = minCapacity << coder;int growth = newLength - oldLength;int length = ArraysSupport.newLength(oldLength, growth, oldLength + (2 << coder));if (length == Integer.MAX_VALUE) {throw new OutOfMemoryError("Required length exceeds implementation limit");}return length >> coder;}

下面还有一个if比较，这里也反映出来StringBuilder容器石油长度的。存放的字符串不能超过int类型的大小 2147483647。超出长度，会报错。

现在是往回推

    private void ensureCapacityInternal(int minimumCapacity) {// overflow-conscious codeint oldCapacity = value.length >> coder;if (minimumCapacity - oldCapacity > 0) {value = Arrays.copyOf(value,newCapacity(minimumCapacity) << coder);}}

Arrays.copyOf(value, newCapacity(minimumCapacity) << coder)方法。CTRL

    /*** Copies the specified array, truncating or padding with zeros (if necessary)* so the copy has the specified length.  For all indices that are* valid in both the original array and the copy, the two arrays will* contain identical values.  For any indices that are valid in the* copy but not the original, the copy will contain {@code (byte)0}.* Such indices will exist if and only if the specified length* is greater than that of the original array.** @param original the array to be copied* @param newLength the length of the copy to be returned* @return a copy of the original array, truncated or padded with zeros*     to obtain the specified length* @throws NegativeArraySizeException if {@code newLength} is negative* @throws NullPointerException if {@code original} is null* @since 1.6*/public static byte[] copyOf(byte[] original, int newLength) {byte[] copy = new byte[newLength];System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));return copy;}

这个方法有两个参数，original是原字节数组，newLength是需要扩容的长度。

byte[] copy = new byte[newLength];根据需要扩容的长度创建一个字节数组；

.arraycopy()方法根据方法名可以看出是复制数组，根据参数大致可以明白，把原来数组的内容复制到新的数组内容。

然后回到开始，

    public AbstractStringBuilder append(String str) {if (str == null) {return appendNull();}int len = str.length();ensureCapacityInternal(count + len);putStringAt(count, str);count += len;return this;}

在分析了一大圈之后 ensureCapacityInternal(count + len);就是给字节数组扩容。

putStringAt(count, str);添加字符串str到StringBuilder

· count += len;` 修改StringBuilder的长度

综合练习

调整字符串

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

public class StringTest01Case1 {public static void main(String[] args) {String strA = "abcde";String strB = "deabc";System.out.println(check(strA, strB));}// 检查public static boolean check(String strA, String strB) {for (int i = 0; i < strA.length(); i++) {strA = rotateStr(strA);if (strA.equals(strB)) return true;}return false;}// 字符串旋转方法public static String rotateStr(String str){// 拆分字符串，分为头部和尾部String headStr = str.substring(1);  char tailStr = str.charAt(0);return headStr + tailStr;  // 拼接}
}

首先要明白题目中字符串的旋转方式。一次旋转就是把字符串第一个字符放到最后，例如："abcde --> bcdea"。

Java中String对象内容不可改变。但是可以使用截取的方式，因此rotateStr()方法用来完成一次旋转。

check()方法用来检查，如果strA和strB相等，返回true，不等返回false。

字符串不可能一直旋转下去，他是有一个度的。拿字符串"abcde"来举例他的旋转过程。

第一次旋转：abcde --> bcdea
第二次旋转：bcdea --> cdeab
第三次旋转：cdeab --> deabc
第四次旋转：deabc --> eabcd
第五次旋转：eabcd --> abcde

根据旋转过程，字符串"abcde"通过5次旋转就会回来。而5也是字符串的长度。

每一次循环进行一次比较。

  // 字符串选择方法public static String rotateStr(String str){char[] arr = str.toCharArray();char end = arr[0];  // 先获取需要放到后面的字符// 剩下的字符往前移for (int i = 1; i < arr.length; i++) {arr[i-1] = arr[i];}arr[arr.length-1] = end;return new String(arr);}

这道题还有一种解法。数组

字符串是不可变的，但是可以用截取或者数组。

字符串打乱

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

import java.util.Random;
import java.util.Scanner;public class StringTest02 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);String str = sc.next();// 字符串变数组char[] arr = str.toCharArray();String result = new String(disruptArr(arr));System.out.println(result);}// 打乱数组方法public static char[] disruptArr(char[] arr){Random r = new Random();for (int i = 0; i < arr.length; i++) {int indexR = r.nextInt(arr.length);  // 设定随机数范围，随机索引char temp = arr[indexR];arr[indexR] = arr[i];arr[i] = temp;}return arr;}
}

生成验证码

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

import java.util.Random;public class StringTest03 {public static void main(String[] args) {Random r = new Random();// 创建两个数组，存放大小写字母数组和数字数组char[] alphabetArr = new char[52];  // 26+26char[] numberArr= {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};char[] verificationCodeArr = new char[5];int capitalAlphabet = 65, minusculeAlphabet = 97;// 字母数组大写初始化for (int i = 0; i < 26; i++) {if (capitalAlphabet <= 90) {char c = (char) capitalAlphabet;alphabetArr[i] = c;capitalAlphabet ++;}}// 字母数组小写初始化for (int i = 26; i < alphabetArr.length; i++) {char c = (char) minusculeAlphabet;alphabetArr[i] = c;minusculeAlphabet++;}// 组成验证码for (int i = 0; i < verificationCodeArr.length; i++) {int indexR ;if (i<=3) {indexR = r.nextInt(alphabetArr.length);verificationCodeArr[i] = alphabetArr[indexR];} else {indexR = r.nextInt(numberArr.length);verificationCodeArr[i] = numberArr[indexR];}}String result = new String(disruptArr(verificationCodeArr));System.out.println(result);}public static char[] disruptArr(char[] arr){Random r = new Random();for (int i = 0; i < arr.length; i++) {int indexR = r.nextInt(arr.length);  // 设定随机数范围，随机索引char temp = arr[indexR];arr[indexR] = arr[i];arr[i] = temp;}return arr;}
}

借用了上道题打乱字符串的方法。先把验证码保存到字符数组里面，前四位字母，后一位数字，随后打乱。

这里有个常识，应该记忆一下

大写字母的ASCII码（A_Z）是6590；
小写字母的ASCII码（a_z）是97122；

这道题经过搜索，还有改进。我是通过两个循环把52个字母存到数组里的，但是还有别的方法

public class Main {public static void main(String[] args) {char[] letters = new char[52];for (int i = 0; i < 26; i++) {letters[i] = (char) ('A' + i);letters[i + 26] = (char) ('a' + i);}for (char letter : letters) {System.out.print(letter + " ");}}
}

第二个for循环的语法有点看不懂，但是逻辑是清晰的。

数组元素相乘

给定两个以字符串形式表示的非负整数num1和num2,返回num1和num2的乘积，它们的乘积也表示为字符串形式。
注意：需要用已有的知识完成。

练习四

给你一个字符串s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。
单词是指仅由字母组成、不包含任何空格字符的最大子字符串。

示例1：输入：s = “Hello World” 输出：5
解释：最后一个单词是"wor1d”,长度为5。

示例2：输入：s = " fly me to the moon" 输出：4
解释：最后一个单词是“moon”,长度为4。

示例3：输入：s= “luffy is still joyboy” 输出：6
解释：最后一个单词是长度为6的"joyboy”。

总结

字符串操作在编程中很常用的。
// 字母数组小写初始化
for (int i = 26; i < alphabetArr.length; i++) {
char c = (char) minusculeAlphabet;
alphabetArr[i] = c;
minusculeAlphabet++;
}

    // 组成验证码for (int i = 0; i < verificationCodeArr.length; i++) {int indexR ;if (i<=3) {indexR = r.nextInt(alphabetArr.length);verificationCodeArr[i] = alphabetArr[indexR];} else {indexR = r.nextInt(numberArr.length);verificationCodeArr[i] = numberArr[indexR];}}String result = new String(disruptArr(verificationCodeArr));System.out.println(result);
}public static char[] disruptArr(char[] arr){Random r = new Random();for (int i = 0; i < arr.length; i++) {int indexR = r.nextInt(arr.length);  // 设定随机数范围，随机索引char temp = arr[indexR];arr[indexR] = arr[i];arr[i] = temp;}return arr;
}

}


借用了上道题打乱字符串的方法。先把验证码保存到字符数组里面，前四位字母，后一位数字，随后打乱。这里有个常识，应该记忆一下* 大写字母的ASCII码（A~Z）是65~90；
* 小写字母的ASCII码（a~z）是97~122；这道题经过搜索，还有改进。我是通过两个循环把52个字母存到数组里的，但是还有别的方法```java
public class Main {public static void main(String[] args) {char[] letters = new char[52];for (int i = 0; i < 26; i++) {letters[i] = (char) ('A' + i);letters[i + 26] = (char) ('a' + i);}for (char letter : letters) {System.out.print(letter + " ");}}
}

第二个for循环的语法有点看不懂，但是逻辑是清晰的。

数组元素相乘

给定两个以字符串形式表示的非负整数num1和num2,返回num1和num2的乘积，它们的乘积也表示为字符串形式。
注意：需要用已有的知识完成。

练习四

给你一个字符串s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中最后一个单词的长度。
单词是指仅由字母组成、不包含任何空格字符的最大子字符串。

示例1：输入：s = “Hello World” 输出：5
解释：最后一个单词是"wor1d”,长度为5。

示例2：输入：s = " fly me to the moon" 输出：4
解释：最后一个单词是“moon”,长度为4。

示例3：输入：s= “luffy is still joyboy” 输出：6
解释：最后一个单词是长度为6的"joyboy”。