一天吃透 String 与 StringBuilder：从 API 文档到字符串大数相加

/* MD / 富文本中的 .toc（含博客园搬家等嵌套结构）；.toc-box 在侧栏，不受影响 */
#content_views .toc,
/* 编辑器常在目录前后插入空 p（:empty 仍占 20px），一并去掉避免顶空隙 */
#content_views.markdown_views > p:empty:has(+ .toc),
#content_views.markdown_views > .toc + p:empty,
/* 富文本旧版目录标记 */
#content_views.htmledit_views #main-toc,
#content_views.htmledit_views #hr-toc,
#content_views.htmledit_views p[id*=\”-toc\”] {
display: none !important;
}
/* 目录去掉后，紧跟的首个标题不再多出一块上边距 */
#content_views.markdown_views > .toc + h1,
#content_views.markdown_views > .toc + h2,
#content_views.markdown_views > .toc + h3,
#content_views.markdown_views > .toc + h4,
#content_views.markdown_views > .toc + p:empty + h1,
#content_views.markdown_views > .toc + p:empty + h2,
#content_views.markdown_views > .toc + p:empty + h3,
#content_views.markdown_views > .toc + p:empty + h4 {
margin-top: 0 !important;
}

Java学习记录

日期： 10.16

📖今日知识点 ——API和API帮助文档

API：应用程序编辑接口

简单理解：就是JDK提供的各种功能的Java类。我们不需要自己编写，直接使用即可。这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只要学会如何使用。

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

如何使用帮助文档 (API文档)

操作步骤：
1、打开API帮助文档

2、点击显示，并找到索引下面的输入框

3、在输入框中输入类名并点击显示

4、查看类所在的包

5、查看类的描述

6、查看构造方法

7、查看成员方法 (重点关注带参数的方法)

💻练习代码

package com.itheima.apidemo1;
//导包：定位Random的位置
//扩展：在什么情况下不需要导包
// 1、使用当前包下的类
// 2、使用java.lang包下的类
// 其他所有情况下都需要导包
import java.util.Random;

public class Test {
public static void main(String[] args) {
//需求：查询API帮助文档，使用Random类中获取随机小数的方法
//1、创建Random类对象
Random r = new Random();
//2、使用对象调用方法
//[0.0,1.0)
double d1 = r.nextDouble();
System.out.println(d1);
System.out.println("================");
for (int i = 0; i < 10; i++){
double d2 = r.nextDouble(1.2,3.4 );
System.out.println(d2);
}
}
}

📖今日知识点 ——字符串String

1、String是Java定义好的一个类。定义在 java.lang 包中，使用的时候不需要导包。

2、Java 程序中的所有字符串文字（例如 “abc” ）都是此类的对象

3、字符串不可变，它们的值在创建后不能被更改

💻练习代码

package com.itheima.apidemo2;

public class Test {
public static void main(String[] args) {
/*
第一种：直接赋值
第二种：new关键字
public String() 空白字符串，不含任何内容
public String(String original) 根据传入的字符串，创建新的字符串对象
public String(char[] chs) 根据字符数组，创建字符串对象
public String(byte[] chs) 根据字节数组，创建字符串对象
*/
// 1. 直接赋值
// 最简单 最常用
String s = "abc";
System.out.println(s);
// 2.new + 构造方法的方式创建字符串对象
// new + 空参构造
String s1 = new String();
System.out.println("=="+ s1 + "@@");
//3. new + 带参构造
String s2 = new String("abc");
System.out.println(s2);
//4. new + 有参构造（字符数组）
char[] ch = {'a', 'b', 'c'};
String s3 = new String(ch);
System.out.println(s3);
//5.new + 有参构造（字节数组）
//ASCII码表
byte[] by = {97, 98, 99};//不要超过127
String s4 = new String(by);
System.out.println(s4);//a b c
}
}

📖今日知识点 ——直接赋值和new的区别

获取字符串对象的两种方式：

1、直接赋值：代码简单 + 串池复用

2、new：每次都会创建一个新的字符串对象

📖今日知识点 ——字符串的比较

字符串比较

1、boolean equals方法(要比较的字符串)：完全一样结果才是true，否则为false

2、boolean equalsIgnoreCase(要比较的字符串)：忽略大小写的比较

💻练习代码

package com.itheima.apidemo3;

import java.util.Scanner;

public class Test {
public static void main(String[] args) {
/*
字符串比较
1.boolean equals方法(要比较的字符串)：完全一样结果才是true，否则为false
2.boolean equalsIgnoreCase(要比较的字符串)：忽略大小写的比较

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

第一个方法：使用equals
String username = "Yewen";
String rightUser = "yewen";
boolean b1 = username.equals(rightUser);
System.out.println(b1);
*/
//1、已知正确的用户名和密码
String rightUsername = "Yewen";
String rightPassword = "123456";

//总共给三次机会
for(int i = 0; i < 3; i++){
//2.请用程序实现模拟用户登录
Scanner s = new Scanner(System.in);
System.out.println("请输入用户名：");
String username = s.next();
System.out.println("请输入密码：");
String password = s.next();
//3.比较用户名和密码是否正确
boolean result = username.equals(rightUsername) && password.equals(rightPassword);
if(result){
System.out.println("登录成功！");
break;
}else{
if(i < 2){
System.out.println("登录失败！还剩下" + (2 – i) + "次机会");
}else{
System.out.println("登录失败！账号已被锁定");
}
}
}
}
}

📖今日知识点 ——Java 中 == 号的比较规则

核心结论：

== 号在比较不同数据类型时，其含义是不同的：

代码示例：

int a = 10;
int b = 20;
System.out.println(a == b); // 输出 false (因为 10 不等于 20)

代码示例：

String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2); // 输出 false (因为 s1 和 s2 是两个不同的对象，内存地址不同)

(注：虽然两个字符串内容都是 “abc”，但因为使用了 new 关键字，它们在堆内存中是不同的对象，地址值不同)

📖今日知识点 ——遍历字符串

public char charAt(int index)：根据索引返回字符

public int length()：返回此字符串的长度

数组的长度：数组名.length

字符串的长度：字符串对象.length()

💻练习代码

package com.itheima.apidemo4;

import java.util.Scanner;

public class Test {
public static void main(String[] args){
/*
正文内容：
需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串

public char charAt(int index)：根据索引返回字符
public int length()：返回此字符串的长度
数组的长度：数组名.length
字符串的长度：字符串对象.length()
*/

//根据索引返回字符
String str = "Yewen0625";
char c = str.charAt(4);
System.out.println(c);//n
//获取字符串的长度
int length = str.length();
System.out.println(length);//9
//键盘录入一个字符串，使用程序实现在控制台遍历该字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String s = sc.next();
//字符串遍历中循环的快速生成方式s.length().fori
for (int i = 0; i < s.length(); i++) {
char cc = s.charAt(i);
System.out.println(cc);
}

}
}

统计字符次数

package com.itheima.apidemo4;

import java.util.Scanner;

public class Test2 {
public static void main(String[] args) {
/*
键盘录入一个字符串，统计该字符串中大小写的字母字符，小写字母字符，
数字字符出现的次数（不考虑其他字符）
*/
//1.键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String str = sc.next();
//2.遍历字符串得到每一个字符
//3.计数器思想 count
int upperCount = 0;//大写字母
int lowerCount = 0;//小写字母
int numberCount = 0;//数字
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (c >= 'A' && c <= 'Z') {
upperCount++;
} else if (c >= 'a' && c <= 'z') {
lowerCount++;
} else if (c >= '0' && c <= '9') {
numberCount++;
}else{
System.out.println("其他字符不参与统计");
break;
}
}
//4.打印
System.out.println("大写字母出现的次数是：" + upperCount);
System.out.println("小写字母出现的次数是：" + lowerCount);
System.out.println("数字出现的次数是：" + numberCount);
}
}

拼接字符串

package com.itheima.apidemo4;

public class Test3 {
public static void main(String[] args) {
/*
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，
调用该方法，并在控制台输出结果。
例如：
数组为 int[] arr = {1,2,3};
执行方法后的输出结果为：[1, 2, 3]
*/
//1、定义一个数组
int[] arr = {1, 2, 3};
//2、调用方法并打印结果
System.out.println(arrayToString(arr));
}
public static String arrayToString(int[] arr) {
String result = "[";
for (int i = 0; i < arr.length; i++) {
if(i == arr.length – 1){
result += arr[i];
}else{
result += arr[i] + ", ";
}
}
result += "]";
return result;
}
}

📖今日知识点 ——字符串的截取、替换和其他常见方法——-数据脱敏

1、String substring(int beginIndex, int endIndex) 截取

注意点：包头不包尾，包左不包右

只有返回值才是截取的小串

2、String substring(int beginIndex) 截取到末尾

💻练习代码

package com.itheima.apidemo5;

public class Test1 {
public static void main(String[] args) {
/*
public String substring(int beginIndex, int endIndex): 截取指定范围
public String substring(int beginIndex): 截取到末尾

需求：只保留用户名的第一个字符，后面用三个***替代
*/

// 定义一个字符串
String str = "abcdef";
// 截取
// 第一个参数：截取的开始索引
// 第二个参数：截取的末尾索引
// 包头不包尾，包左不包右 —-> 包含1索引，但是不包含5索引 1 2 3 4
// 字符串本身一旦创建之后，是无法发现改变的，截取的时候不会影响调用者的字符串，切记：只有返回值才是截取之后的结果
String res = str.substring(1,5);//bcde
System.out.println(res);
// 参数：截取的开始索引，默认是截取到字符串的末尾
// 字符串本身一旦创建之后，是无法发现改变的，截取的时候不会影响调用者的字符串，切记：只有返回值才是截取之后的结果
String res2 = str.substring(1);//bcddef
System.out.println(res2);
System.out.println("======================================" );
//练习：需求：只保留用户名的第一个字符，后面用三个***替代
//charAt(0)获取第一个字符
//substring(0,1)截取从索引0开始到索引1结束
String username = "故人西辞";
//ctrl+alt+v自动生成左边
char firstName1 = username.charAt(0);
String result1 = firstName1 + "***";
System.out.println(result1);
String firstName2 = username.substring(0,1);
String result2 = firstName2 + "***";
System.out.println(result2);

}
}

📖今日知识点 ——字符串的截取、替换和其他常见方法——-敏感词过滤

String replace(旧值,新值) 替换

注意点：只有返回值才是替换之后的结果

subString截取：截取固定位置的数据

replac替换：位置不确定，替换指定内容

💻练习代码

package com.itheima.apidemo5;

import java.util.Scanner;

public class Test2 {
public static void main(String[] args){
/*
String replace(旧值,新值) 替换
注意点：只有返回值才是替换之后的结果

需求：
过滤玩游戏中的骂人的脏话
*/
// 定义字符串
//String str = "你玩的好菜呀，TMD";
// 替换
// 第一个参数：被替换的数据
// 第二个参数：用来替换的数据
// 只有返回值才会替换之后的结果
//String res = str.replace("TMD","****");
//System.out.println(res);

//1.定义一个敏感词库
String[] arr = {"TMD","SB","jr","ck"};
//2.键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String msg = sc.next();
//3.替换敏感词
for (int i = 0; i < arr.length; i++) {
//arr[i]:依次表示敏感词库中的每一个敏感词
msg = msg.replace(arr[i],"***");
}
System.out.println(msg);

}
}

📖今日知识点 ——字符串的其他常见方法

比较：equals equalsIgnoreCase

长度：length

获取单个字符：charAt

截取：substring

替换：replace

💻练习代码

package com.itheima.apidemo5;

import java.util.Locale;

public class Test3 {
public static void main(String[] args) {
/*
String 类当中常见的方法：
比较 equals equalsIgnoreCase
长度 length
获取单个字符 charAt
截取 substring
替换 replace

是否包含 contains
判断开头、结尾 startsWith/endsWith
查找 indexOf(int ch) lastIndexOf(int ch)
判断是否为空 isEmpty()
转字符数组 toCharArray()
大小写转换 toUpperCase() 、toLowerCase()
去除头尾空格 trim()

*/
String str = "abcdefgd";
//是否包含contains—敏感词过滤
boolean b1 = str.contains("abd");
System.out.println(b1);//false

//判断开头、结尾 startsWith/endsWith
//判断文件后缀名 a.txt
boolean b2 = str.startsWith("bc");//判断是否以bc开头
System.out.println(b2);//false
boolean b3 = str.startsWith("bc",1);//从索引1开始判断是否以abc开头
System.out.println(b3);//true

boolean b4 = str.endsWith(".txt");
System.out.println(b4);//false

//查找 indexOf(int ch) lastIndexOf(int ch)—最后一次出现的索引
//查找当前字符/字符串 第一次出现的索引,如果当前查找的内容不存在，方法会返回-1
int i1 = str.indexOf(99);
System.out.println(i1);//2
int i2 = str.lastIndexOf(100);
System.out.println(i2);//7
int i3 = str.indexOf(104);
System.out.println(i3);//-1

//判断是否为空 isEmpty()
boolean empty1 = str.isEmpty();
System.out.println(empty1);//false

String str2 = "";
boolean empty2 = str2.isEmpty();
System.out.println(empty2);//true

//转字符数组 toCharArray()
//将字符串转换为字符数组
//"abcdefgd"—->['a','b','c','d','e','f','g','d']
//"abc"—>0索引改为A，就可以用到toCharArray()先将字符串转换为字符数组，再将0索引改为A
char[] array = str.toCharArray();
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}

//大小写转换 toUpperCase() 、toLowerCase()
//只能转换字符串中的英文，不能转换中文
String upperCase = str.toUpperCase(Locale.ROOT);
System.out.println(upperCase);//ABCDEFGD

String str1 = "ABC";
String lowerCase = str1.toLowerCase(Locale.ROOT);
System.out.println(lowerCase);//abc

//去除头尾空格 trim()
String str3 = " abc ";
String trim = str3.trim();
System.out.println(trim);//"abc"
}
}

📖今日知识点 ——StringBuilder

StringBuilder append (任意类型)添加数据
StringBuilder reverse() 反转容器中的内容
int length()返回长度 （字符的个数）
String toString() 转回String字符串对象

StringBuilder 构造方法

构造方法 说明
public StringBuilder() 创建StringBuilder容器，不含有任何内容
public StringBuilder(String str)创建StringBuilder容器，包含指定的内容

💻练习代码

package com.itheima.stringbuilderdemo6;

public class Test3 {
public static void main(String[] args) {
/*
StringBuilder的构造方法：
public StringBuilder() 空参构造
public StringBuilder(String str) 带参构造

StringBuilder的常见成员方法：
append (任意类型) 添加数据
reverse() 反转
int length() 获取长度
toString 变回字符串

*/
//1.创建StringBuilder对象（容器） 空参构造
StringBuilder sb1 = new StringBuilder();
System.out.println("===" + sb1 + "&&&");
int len = sb1.length();
System.out.println("len:" + len);//0
//2.创建StringBuilder对象（容器） 带参构造
StringBuilder sb2 = new StringBuilder("hello");
//添加
//sb2.append("Yewen");
//System.out.println(sb2);//helloYewen
//反转
sb2.reverse();
System.out.println(sb2);//olleh
//转换为字符串
String res = sb2.toString();
System.out.println(res);//olleh
}
}

注：三个容易混的点（精炼版）
① 打印像字符串 ≠ 它就是字符串

sb2 的类型是 StringBuilder。System.out.println 会自动调它的 toString()，所以看着像文字。

② toString() 到底做了什么

比喻：StringBuilder 是能拆能装的活字印刷盘（可 append、reverse），String 是浇铸定型的铅板（内容不可变）。 String res = sb2.toString(); 就是把印刷盘上当前的字誊写一份、打成铅板——是复制，不是换个名字。

③ 要求 String 的地方不能直接传 sb2

void show(String s) { }

show(sb2); // ❌ 类型不匹配
show(sb2.toString()); // ✅

一句话：sb2 是"能改的容器"，res 是"不能改的成品"，toString() 负责把容器内容誊写出来做成成品；类型不同，打印看着一样 ≠ 是同一个东西。

📖今日知识点 ——练习题：

练习题1：

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

练习题2：

键盘录入字符串，将该字符串进行反转，当输入拜拜的时候程序停止运行
例如，键盘录入 abc，输出结果 cba

练习题3：

键盘录入任意字符串，请按长度为8拆分每个输入字符串并进行输出
长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
举例：
输入：abcdabcda
输出：
第一行：abcdabcd
第二行：a0000000

练习题4：

定义一个任意字符串，打乱里面的内容
“abcd”—–>“bcad”

💻练习代码

练习题1代码实现：

package com.itheima.testdemo7;

public class ArrayUtil {
private ArrayUtil(){

}
//定义方法，把数组变成字符串进行返回
public static String arrayToString1(int[] arr){
String str = "[";
//遍历数组
for (int i = 0; i < arr.length; i++) {
if(i == arr.length – 1){
str += arr[i] + "]";
}else{
str += arr[i] + ", ";
}
}
return str;
}
public static String arrayToString2(int[] arr){
StringBuilder sb = new StringBuilder("[");
//遍历数组
for (int i = 0; i < arr.length; i++) {
if(i == arr.length – 1){
sb.append(arr[i]).append("]");
}else{
sb.append(arr[i]).append(", ");
}
}
return sb.toString();
}
}

package com.itheima.testdemo7;

public class Test1 {
public static void main(String[] args) {
/*
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，
调用该方法，并在控制台输出结果。
例如：
数组为 int[] arr = {1,2,3};
执行方法后的输出结果为：[1, 2, 3]
*/
//1、定义一个数组
int[] arr = {1, 2, 3};
//2、调用方法并打印结果
String res = ArrayUtil.arrayToString2(arr);
System.out.println(res);
}
}

练习题2代码实现：

package com.itheima.testdemo7;

import java.util.Scanner;

public class Test2 {
public static void main(String[] args) {
/*
键盘录入字符串，将该字符串进行反转，当输入拜拜的时候程序停止运行
例如，键盘录入 abc，输出结果 cba
for:知道循环次数
while:知道循环结束条件，不知道循环次数
*/
while(true){
//1.键盘录入字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String str = sc.next();
//2.判断字符串是否为拜拜
if(str.equals("拜拜")){
System.out.println("程序停止运行");
break;
}else{
StringBuilder sb = new StringBuilder(str);
sb.reverse();
String res = sb.toString();
System.out.println(res);
}
}
}
}

练习题3代码实现：

package com.itheima.testdemo7;

import java.util.Scanner;

public class Test3Case2 {
public static void main(String[] args) {
/*
键盘录入任意字符串，请按长度为8拆分每个输入字符串并进行输出
长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
举例：
输入：abcdabcda
输出：
第一行：abcdabcd
第二行：a0000000
*/
// 1. 键盘录入任意字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String str = sc.next();
//2.直接在str的后面补0
//abcdabcda0000000
//计算最后一行有多少个字符
int lastLineCount = str.length() % 8;
//计算最后一行补0的个数
int count = 8 – lastLineCount;
if(lastLineCount != 0){
//获取最后一行补的0
String s = "0000000".substring(0, count);
//拼接
str = str + s;
}
//System.out.println(str);
//3.每8个打印一行
//i += 8,表示每次截取8个
// 第一行：从0索引开始
// 第二行：从8索引开始
//截取：substring
for(int i = 0; i < str.length(); i += 8){
String res = str.substring(i, i + 8);
System.out.println(res);
}

}
}

练习题4代码实现：

package com.itheima.testdemo7;

import java.util.Random;

public class Test5 {
public static void main(String[] args) {
// 定义一个任意字符串，打乱里面的内容
// “abcd”—–>“bcad”

//定义一个字符串
String str = "abcd";
//把字符串转换成字符数组
char[] arr = str.toCharArray();
//打乱字符数组arr中的内容
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
//获取一个随机索引
int randomIndex = r.nextInt(arr.length);
//依次得到数组的每一个字符
char temp = arr[i];
arr[i] = arr[randomIndex];
arr[randomIndex] = temp;
}
//把字符数组转换成字符串
String result = new String(arr);
//输出结果
System.out.println(result);
}
}

5.算法练习——字符串计算：

package com.itheima.testdemo7;

public class Test6 {
public static void main(String[] args) {
/*
字符串计算
定义两个字符串，记录为非负整数，求它们的和。
输入："12395" 和 "133"，输出："12528"
注意：需要数据过大，超出int取值范围的情况
*/
//1.定义两个字符串
String str1 = "12395";
String str2 = "133";
//2.把两个字符串的数据放入int类型的数组里面
int len = str1.length() >= str2.length() ? str1.length() : str2.length();
int[] arr1 = copyData(str1, len);
int[] arr2 = copyData(str2, len);
//3.定义一个数组存入最终结果，数组长度+1
int[] sum = new int[len + 1];
//4.定义一个变量表示进位
int num = 0;
//5.核心：遍历数组：从个位（最大索引）位置开始遍历
//arr[i] + arr2[i] + num = 结果
//结果的个位 — sum数组当中
//结果的十位 — 进位num
for (int i = arr1.length – 1; i >= 0; i—) {
int temp = arr1[i] + arr2[i] + num;
sum[i + 1] = temp % 10;
num = temp / 10;
}
//6.考虑首位
sum[0] = num;
//7.把数组当中的数据，连接成一个字符串
StringBuilder sb = new StringBuilder();
if(sum[0] != 0){
sb.append(sum[0]);
}
for (int i = 1; i < sum.length; i++) {
sb.append(sum[i]);
}
System.out.println(sb.toString());

}

public static int[] copyData(String str, int len) {
//定义int类型数组
int[] arr = new int[len];
//把字符串的数据，放入到数组当中
//定义一个变量表示数组中应存入的位置
int index = arr.length – 1;
for (int i = str.length() – 1; i >= 0; i—) {
char c = str.charAt(i);//获取单个字符
arr[index] = c – 48;//字符转为数字
index—;//数组中应存入的位置减1
}
return arr;

}

}

package com.itheima.testdemo7;

public class Test7 {
public static void main(String[] args){
//'1' —1 49
//'2' —2 50
//'3' —3 51
//'4' —4 52
//'5' —5 53
//'6' —6 54
//'7' —7 55
//'8' —8 56
//'9' —9 57
//'0' —0 48
char c = '9';
System.out.println(c – 48);//9
}
}

📖今日知识点 ——字符串作业

作业1：

💻练习代码

package com.itheima.testdemo7;

public class Test8 {
public static void main(String[] args) {
/*
数据脱敏（作业1）
1、把任意手机号中间四位变成****
2、保留邮箱名第一个字母，保留@后面的内容
131 1234 5678 -> 131****5678
zw1234@163.com -> z*@163.com
*/
String phoneNumber = "13112345678";
//substring截取字符串
//前3位
String phonePrefix = phoneNumber.substring(0,3);
//后4位
String phoneSuffix = phoneNumber.substring(7);
System.out.println(phonePrefix + "****" + phoneSuffix);

String email = "zw1234765489@163.com";
//保留邮箱名第一个字母
String emailPrefix = email.substring(0,1);
//保留@后面的内容
String emailSuffix = email.substring(email.indexOf("@"));
System.out.println(emailPrefix + "*" + emailSuffix);
}
}

作业2：

package com.itheima.testdemo7;

import java.util.Scanner;

public class Test9 {
public static void main(String[] args) {
/*
计算某个字符出现的次数（作业2）
描述
写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）
数据范围：1 ≤ n ≤ 1000
输入描述：
第一行输入一个由字母、数字和空格组成的字符串，第二行输入一个字符（保证该字符不为空格）。
输出描述：
输出输入字符串中含有该字符的个数。（不区分大小写字母）
示例1
输入：
ABCabc
A
输出：
2
*/
//1.键盘录入一个字符
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String str = sc.nextLine();
//2.目标字符
char target = sc.next().charAt(0);
//统计目标字符出现的次数
int count = 0;
//将目标字符转换成小写
char t = Character.toLowerCase(target);
//3.遍历字符串，获取每一个字符并和目标字符进行比较
for (int i = 0; i < str.length(); i++){
char c = str.charAt(i);
//当前字符和目标字符都转为小写
if(Character.toLowerCase(c) == t){
count++;
}
}
System.out.println(count);
}
}

作业3：

package com.itheima.testdemo7;

public class Test11 {
public static void main(String[] args) {
/*
【案例】 字符串转换（作业3）
给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
示例 1：
输入：s = "Hello World"
输出：5
解释：最后一个单词是“World”，长度为 5。

示例 2：
输入：s = " fly me to the moon "
输出：4
解释：最后一个单词是“moon”，长度为 4。 (注：原图中“moon”下方有红色下划线)

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

思路：从最后一个单词出发，向左遍历，直到遇到空格为止，即可得到最后一个单词的长度。
*/
//1.定义一个字符串
String s = "Hello World";

int len = 0;
for(int i = s.length() – 1;i >= 0;i—){
if(s.charAt(i) == ' '){
break;
}else{
len++;
}
}
System.out.println(len);
}
}

作业4：

package com.itheima.testdemo7;

public class Test10 {
public static void main(String[] args) {
/*
【案例】字符串获取信息（作业4）
我们的身份证号码拥有一定的规则：
1、2位：省份　　　　　　3、4位：城市
5、6位：区县　　　　　　7-14位：出生年、月、日
15、16位：所在地派出所　17位：性别（奇数男性，偶数女性）
18位：个人信息码（随机产生）

要求：
假设有身份证：321104200801121234，获取人物的出生年月日和性别进行输出。

输出结果：
出生年月日：2008年01月12日
性别为：男
*/
String id = "321104200801121234";
String year = id.substring(6,10);
String month = id.substring(10,12);
String day = id.substring(12,14);
char genderChar = id.charAt(16);//获取性别字符
int genderNum = genderChar – '0';
System.out.println("出生年月日：" + year + "年" + month + "月" + day + "日");
if (genderNum % 2 == 0) {
System.out.println("性别为：女");
} else {
System.out.println("性别为：男");
}
}

}

作业5：

package com.itheima.testdemo7;

import java.util.Scanner;

public class Test12 {
public static void main(String[] args) {
/*
【案例】字符串转换（作业5）
将一个字符串中所有的整数前后加上符号“*”，其他字符保持不变。连续的数字视为一个整数。
数据范围：字符串长度满足 1 ≤ n ≤ 100
输入描述：
输入一个字符串
输出描述：
字符中所有出现的数字前后加上符号“*”，其他字符保持不变

示例1
输入：
Jkdi234klowe90a3 (注：此处有一个鼠标光标)
输出：
Jkdi*234*klowe*90*a*3*
*/
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String str = sc.nextLine();
if(str.length() < 1 || str.length() > 100){
System.out.println("输入字符串长度超出范围");
}

//新建一个字符串容器
StringBuilder sb = new StringBuilder();
int i = 0;
while(i < str.length()){
char c = str.charAt(i);
if(c >= '0' && c <= '9'){
//遇到数字，先加前面的*
sb.append('*');

//把连续的数字全部数字拼进去
while(i < str.length() && str.charAt(i) >= '0' && str.charAt(i) <= '9'){
sb.append(str.charAt(i));
i++;
}
//连续数字结束后，加后面的*
sb.append('*');
}else{
//不是数字，原样拼进去
sb.append(c);
i++;
}
}
System.out.println(sb.toString());
}
}

作业6：

package com.itheima.testdemo7;

import java.util.Random;

public class Test13 {
public static void main(String[] args) {
/*
【案例】生成验证码（作业6）
验证码的内容：可以是小写字母，也可以是大写字母，还可以是数字
验证码的规则：
　　长度为5
　　内容中是四位字母，1位数字。
　　其中数字只有1位，但是可以出现在任意的位置。

举例：
正确的验证码：We1fg 6gKoq tqB2p
错误的验证码：iuybs（没有数字） j1s2u（两个数字）
*/
Random r = new Random();
//1.先随机生成5位字母(大小写随机)
StringBuilder sb = new StringBuilder();
for(int i = 0;i < 5;i++){
char c;
if(r.nextBoolean()){// 抛硬币，正面(true)走这里
//生成大写: 'A' + 0~25
c = (char)('A' + r.nextInt(26) );
}else{ // 反面(false)走这里
//生成小写: 'a' + 0~25
c = (char) ('a' + r.nextInt(26));
}
sb.append(c);
}
//2.随机一个位置(0~4)和一个数字(0~9),把该位置覆盖成数字
//setCharAt(位置, 新字符) = 把 StringBuilder 里某个位置的字符，替换成新字符
int index = r.nextInt(5);
int num = r.nextInt(10);
sb.setCharAt(index, (char)('0' + num));
//3.输出结果
System.out.println(sb.toString());
}
}

作业7：

package com.itheima.testdemo7;

import java.util.Scanner;

public class Test14 {
public static void main(String[] args) {
/*
案例 字符串计算（作业7）【不太懂】
键盘输入两个字符串表示的非负整数，求它们的乘积。
注意： 需要考虑键盘录入的数据过大，超出int取值范围的
*/
Scanner sc = new Scanner(System.in);
System.out.println("请输入两个字符串表示的非负整数：");
String str1 = sc.nextLine();
String str2 = sc.nextLine();
int m = str1.length();
int n = str2.length();
//乘积最多 m+n 位
int[] res = new int[m + n];
//模拟竖式乘法：从两个数的最低位开始两两相乘
for (int i = m – 1; i >= 0; i—) {
int d1 = str1.charAt(i) – '0';//把字符转成数字
for (int j = n – 1; j >= 0; j—) {
int d2 = str2.charAt(j) – '0';
int mul = d1 * d2;
int p1 = i + j; //进位存放的位置(高位)
int p2 = i + j + 1; //当前位存放的位置(低位)
int sum = mul + res[p2];//加上该位置原来已经累积的值
res[p2] = sum % 10; //留个位
res[p1] += sum / 10; //进位累加到高位
}
}

//拼接结果，跳过开头的0
StringBuilder sb = new StringBuilder();
boolean leading = true;
for (int num : res) {
if (leading && num == 0) {
continue;//还在跳过前导零
}
leading = false;
sb.append(num);
}
//如果结果全是0(乘了0)，那就是"0"
String result = sb.length() == 0 ? "0" : sb.toString();
System.out.println(str1 + " * " + str2 + " = " + result);
}
}

📖今日知识点 ——ArrayList集合

一、集合的引入：数组的弊端

Java 中要保存多个数据，最先想到的是数组：

// 格式：数据类型 数组名[] = {数据值, 数据值…}
int arr[] = {1, 2, 3};

数组的特点：一旦定义，长度不可变。
因此数组中存在明显弊端：

结论：数组适合"数据个数确定、以查询为主"的场景；一旦需要动态增删，就应该改用集合。

二、什么是集合

集合：是一种长度可变的容器。
集合的两大特点：

• 特点 1：长度可变。 添加元素时自动扩容，删除元素后长度随之变小，不用关心容量。
• 特点 2：只能存引用数据类型，不能存基本数据类型。 想存 int、double 等基本类型，必须先用对应的包装类装箱。

数组 vs 集合

三、基本数据类型对应的包装类

集合的泛型 <> 中只能写引用数据类型，基本类型要用"包装类"来代替：

• 除了 int → Integer、char → Character 两个"改名"的，其余都是首字母大写。
• 有了包装类，ArrayList<Integer> list = new ArrayList<>(); list.add(1); 这样写是合法的——1 会被自动装箱成 Integer 对象（JDK 5 之后的自动装箱/拆箱机制）。

四、易错点与补充

五、总结

💻练习代码

package com.itheima.arraylistdemo8;

import java.util.ArrayList;

public class Test1 {
public static void main(String[] args) {
/*
ArrayList集合
空参构造：
ArrayList()：创建一个空的ArrayList集合
常见方法：
boolean add(E e)：向集合的末尾添加指定元素
void add(int index, E e)：在集合的指定位置插入指定元素
boolean remove(E e): 删除元素
E remove(int index): 删除指定位置的元素，并返回该元素
E set(int index, E e): 修改指定位置的元素，并返回该位置原来的元素
E get(int index): 获取元素
int size(): 获取集合中元素的个数

*/
//1. 创建ArrayList集合对象
//ArrayList list = new ArrayList();
ArrayList<String> list = new ArrayList<String>();
//2.添加元素
// 细节1：ArrayList的add方法不管添加什么都添加成功，忽略返回值即可
// true：添加成功 false:添加失败
// 此时add方法在任意情况下，都会添加成功，永远不会失败
// 因为在Java当中，有很多很多的集合 HashSet（元素要唯一） aaa(true) aaa(false)
// 设计：跟其他的集合保持统一（面向对象的思想）

// 细节2：在集合当中无法直接添加基本数据类型的（byte short int long float double char boolean）
// 只能添加引用数据类型（对象）
// 如果在集合里面一定要添加基本数据类型，那么可以转成其对应的包装类
list.add("aaa");
list.add("bbb");
list.add("ccc");
// 把qqq添加到0索引的位置
// 细节：
// 如果集合长度为3，那么下面方法要添加的索引范围只能是0 ~ 3
// 0 – 2 已经存在的索引
// 3：把当前元素添加到集合的末尾，等同于一个参数的add方法
// 如果要添加的索引超出了这个范围，程序就会直接报错
list.add(3,"qqq");
System.out.println(list);//[aaa, bbb, ccc, qqq]

// boolean remove(E e) 根据元素删除
// 细节：
// 根据元素的内容进行删除的
// 存在：删除成功 true
// 不存在：删除失败 false
//boolean res = list.remove("QQQ");
//System.out.println(res);

// E set(int index,E e) 将指定位置的数据，修改为新元素
// 细节：
// 把指定索引上的数据修改为新的数据，把被替换的元素进行返回
// 注意：
// 如果当前的索引不存在，代码会报错
//把0索引的数据修改为"www"
String res = list.set(0,"www");
System.out.println(res);
System.out.println(list);
// E get(int index) 获取特定索引的数据
// String res = list.get(0);
// System.out.println(res);

// 遍历：get + size
// 遍历：把容器里面的数据一个一个的拿出来，打印，计算，处理
for (int i = 0; i < list.size(); i++) {
// i: 依次表示集合中的每一个索引
// list.get(i):依次获取集合中的每一个元素
System.out.println(list.get(i));
}
// 只能看一看集合当中有什么，无法操作里面的每一个元素的
System.out.println(list);

}
}

练习题1：

package com.itheima.arraylistdemo8;

import java.util.ArrayList;

public class Test2 {
public static void main(String[] args) {
/*
需求：定义一个集合，添加数字，并进行遍历
遍历格式参考[元素1,元素2,元素3]
*/
//1.创建一个集合
ArrayList<Integer> list = new ArrayList<>();
//2.添加数据
list.add(1);
list.add(2);
list.add(3);
//3.遍历数据
System.out.print("[");
for (int i = 0; i < list.size(); i++) {
//i:索引
//list.get(i):获取索引i位置的元素
Integer num = list.get(i);
if(i == list.size() – 1){
System.out.print(num);
}else{
System.out.print(num + ",");
}
}
System.out.println("]");
}
}

练习题2：

package com.itheima.arraylistdemo8;

public class Student {
//属性：id, 姓名, 年龄
private String id;
private String name;
private int age;
//无参构造方法
public Student() {
}
//有参构造方法
public Student(String id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
//getters and setters
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}

package com.itheima.arraylistdemo8;

import java.util.ArrayList;

public class Test3 {
public static void main(String[] args) {
/*
需求：定义一个集合，添加一些学生对象
学生类的属性为：id, 姓名, 年龄。
要求：
1. 遍历集合，将所有学生的属性打印在控制台上，每个学生一行
2. 定义一个方法，根据id查找学生的信息。
存在：返回索引
不存在：返回-1
*/
// 1. 创建集合对象
ArrayList<Student> list = new ArrayList<>();
//2.创建一些学生的对象
// ALT + 鼠标左键 竖着选中
Student s1 = new Student("001", "张三", 18);
Student s2 = new Student("002", "李四", 19);
Student s3 = new Student("003", "王五", 20);
//3.添加到集合
list.add(s1);
list.add(s2);
list.add(s3);
//4.遍历集合
for (int i = 0; i < list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getId() + " " + s.getName() + " " + s.getAge());
}
//5.查找对应的id
int index = findStudent("002", list);
System.out.println(index);
}
public static int findStudent(String id,ArrayList<Student> list){
//遍历集合得到集合中的每一个元素（学生对象），判断元素的id跟要查找的id是否一致
for (int i = 0; i < list.size(); i++) {
Student s = list.get(i);
//判断equals — 链式编程，多行代码写在一行（少定义几个变量
//链式编程核心点：利用前一个方法的结果，继续调用后面的内容
if(s.getId().equals(id)){
return i;
}
}
//只有当循环结束了，才表示集合中的所有元素找完，如果还没有找到，表示要查找的id不存在
return –1;
}
}