Java核心类库-上（二）String类的概述和使用
二、String类的概述和使用
- 2.1 String类和常量池的概念
-
- String类的概念（重点）
- 常量池的概念（原理）
- 2.2 常用的构造方法（练熟、记住）
-
- 笔试考点
- 2.3 常用的成员方法（练熟、记住）
-
- String类和数组之间的转换
- String类中字符的获取和使用
-
- 案例：回文数判断
- String类实现字符串之间大小的比较
- String类实现各种方法的使用
- String类实现登录功能的模拟
- 字符和字符串的正向(反向)查找
- String类中子字符串的获取
- 2.4 正则表达式
-
- 概念（了解）
- 规则（了解）
- 编程使用
- 相关的方法使用
- 总结
2.1 String类和常量池的概念
String类的概念（重点）
- java.lang.String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描
述，如：“abc”。 - 该类由 final 关键字修饰，表示该类不能被继承
- 从 jdk1.9 开始该类的底层不使用 char[ ] 来存储数据，而是改成 byte[ ] 加上编码标记，从而节约了一
些空间 - 该类描述的字符串内容是个常量（final修饰不可改变，byte[ ]数组长度不可改变）不可更改，因此可以被共享使用
注：常量存储在方法区 - 举例：
String str1 = "abc"; // 其中"abc"这个字符串是个常量不可改变
String str1 = "123" // 将"123"字符串的地址赋值给str1
// 改变str1的指向，并没有改变所指向的内容
常量池的概念（原理）
- 由于String类型描述的字符串内容是常量不可改变，，因此Java虚拟机将首次出现的字符串放入常量池中，若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及无需创建对象，从而提高了性能。
public class StringPoolTest {
public static void main(String[] args) {
// 1.验证一下常量池的存在
// 到目前为止，只有String这个特殊类除了new的方式外还可以直接字符串赋值（包装类除外）
String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2); // 比较地址 true
}
}
2.2 常用的构造方法（练熟、记住）
- 注意：最后一个构造方法，一共创建两个对象
一个在常量池中（字符串），一个在堆区（new创建的对象）
public class StringConstructorTest {
public static void main(String[] args) {
// 1.使用无参方式构造对象并打印
String str1 = new String();
// ""表示空字符串对象，有对象但是里面没内容
// null表示空，连对象也没有
System.out.println("str1 = " + str1); // "" 自动调用toString方法
// 2.使用参数指定的byte数组来构造对象并打印
//byte[] bArr = new byte[] {65, 66, 67, 68, 69};
byte[] bArr = {65, 66, 67, 68, 69};
// 使用字节数组中的一部分来构造对象，表示使用数组bArr中下标从1开始的3个字节构造字符串对象
// 66-'B' 67-'C' 68-'D' => BCD
String str2 = new String(bArr, 1, 3);
System.out.println("str2 = " + str2); // BCD
// 使用整个字节数组来构造字符串对象
String str3 = new String(bArr);
System.out.println("str3 = " + str3); // ABCDE
// 3.使用字符数组来构造对象并打印
//char[] cArr = new char[]{'h', 'e', 'l', 'l', 'o'};
char[] cArr = {'h', 'e', 'l', 'l', 'o'};
// 使用字符数组中的一部分来构造对象，表示使用数组cArr中下标从1开始的3个字符串构造字符串对象
String str4 = new String(cArr, 1, 3);
System.out.println("str4 = " + str4); // ell
// 使用整个字符数组来构造字符串对象
String str5 = new String(cArr);
System.out.println("str5 = " + str5); // hello
// 4.使用字符串来构造字符串对象
String str6 = new String("world");
System.out.println("str6 = " + str6); // world
}
}
笔试考点
public class StringExamTest {
public static void main(String[] args) {
// 1.请问下面的代码会创建几个对象？分别存放在什么地方？
//String str1 = "hello"; // 1个对象 存放在常量池中
//String str1 = new String("hello"); // 2个对象 一个在常量池中，一个在堆区
// 2.问题：下列分别打印什么内容？（常量池和堆区对象的比较）
String str1 = "hello"; // 常量池
String str2 = "hello"; // 常量池
String str3 = new String("hello"); // 堆区
String str4 = new String("hello"); // 堆区
System.out.println(str1 == str2); // true 比较地址
System.out.println(str1.equals(str2)); // true 比较内容
System.out.println(str3 == str4); // false 比较地址
System.out.println(str3.equals(str4)); // true 比较内容
System.out.println(str2 == str3); // false 比较地址
System.out.println(str2.equals(str3)); // true 比较内容
// 3.常量优化机制，变量没有优化机制
String str5 = "abcd";
String str6 = "ab" + "cd"; // 常量优化机制
System.out.println(str5 == str6); // true 比较地址
String str7 = "ab";
String str8 = str7 + "cd"; // str7是变量，所有没有优化机制
System.out.println(str5 == str8); // false 比较地址
}
}
2.3 常用的成员方法（练熟、记住）
String类和数组之间的转换
public class StringByteCharTest {
public static void main(String[] args) {
// 1.创建String类型的对象并打印
String str1 = new String("world");
System.out.println("str1 = " + str1); // world
// 2.实现将String类型转换为Byte类型并打印
// 思路：先将字符串拆分为字符，再将每个字符转换byte类型，即获取所有字符的ASCII码
byte[] bArr = str1.getBytes();
for(int i = 0; i < bArr.length; i++) {
System.out.println("下标为" + i + "的元素是：" + bArr[i]);
}
// 将byte类型转回String类型
String str2 = new String(bArr);
System.out.println("byte类型转回字符串为：" + str2); // world
// 3.实现将String类型转换为char数组类型并打印
// 思路：将字符串拆分为字符并保存到char数组中
char[] cArr = str1.toCharArray();
for(int i = 0; i < cArr.length; i++) {
System.out.println("下标为" + i + "的元素是：" + cArr[i]);
}
// 将char类型的数组转回到String类型并打印
String str3 = new String(cArr);
System.out.println("char数组转回字符串为: " + str3);
}
}
String类中字符的获取和使用
public class StringCharTest {
public static void main(String[] args) {
// 1.构造String类型的对象并打印
String str1 = new String("hello");
System.out.println("str1 = " + str1);
// 2.获取字符串的长度和每个字符并打印
System.out.println("字符串的长度为：" + str1.length()); // 5
System.out.println("下标为0的字符为：" + str1.charAt(0)); // h
System.out.println("下标为1的字符为：" + str1.charAt(1)); // e
System.out.println("下标为2的字符为：" + str1.charAt(2)); // l
System.out.println("下标为3的字符为：" + str1.charAt(3)); // l
System.out.println("下标为4的字符为：" + str1.charAt(4)); // o
//System.out.println("下标为5的字符为：" + str1.charAt(5)); // 编译ok，运行报错
// StringIndexOutOfBoundsException 字符串下标越界异常
/**
* 至此，一共出现过7种异常
* 1.算术异常：ArithmeticException
* 2.数组越界异常：ArrayIndexOutOfBoundsException
* 3.空指针异常：NullPointerException
* 4.类型转换异常：ClassCastException
* 5.非法参数异常：IllegalArgumentException
* 6.数字格式异常：NumberFormatException
* 7.字符串下标越界异常：StringIndexOutOfBoundsException
*/
// 3.使用for循环获得所有字符
for(int i = 0; i < str1.length(); i++) {
System.out.println("下标为" + i + "的字符为：" + str1.charAt(i));
}
// 4.判断字符串是否为空
System.out.println(0 == str1.length()? "字符串为空": "字符串不为空");
System.out.println(str1.isEmpty()? "字符串为空": "字符串不为空");
// 5.笔试考点
// 使用两种方式实现字符串"12345"装换为整数12345并打印
String str2 = new String("12345");
// 方式一：调用Integer类中的parseInt()方法即可
int ia = Integer.parseInt("12345");
System.out.println("转换出来的整数是：" + ia); // 12345
// 方式二：利用ASCII码来实现类型转换并打印
// '1' - '0' => 1 '2' - '0' => 2 ... (字符0的ASCII码是48)
int ib = 0;
for(int i = 0; i < str2.length(); i++) {
ib = ib*10 + (str2.charAt(i) - '0');
}
System.out.println("转换出来的整数是：" + ib);
}
}
> 至此，一共出现过7种异常
1.算术异常：ArithmeticException
2.数组越界异常：ArrayIndexOutOfBoundsException
3.空指针异常：NullPointerException
4.类型转换异常：ClassCastException
5.非法参数异常：IllegalArgumentException
6.数字格式异常：NumberFormatException
7.字符串下标越界异常：StringIndexOutOfBoundsException
案例：回文数判断
- 判断字符串“上海自来水来自海上”是否为回文并打印，所谓回文是指一个字符序列无论从左向右读还是从右向左读都是相同的句子。
public class StringJudgeTest {
public static void main(String[] args) {
// 1.创建字符串对象并打印
String str1 = new String("上海自来水来自海上");
// 2.判断该字符串内容是否为回文并打印
for(int i = 0; i < str1.length()/2; i++) {
if (str1.charAt(i) != str1.charAt(str1.length()-i-1)) {
System.out.println("不是回文！");
return; // 仅仅是用于实现方法的结束
}
}
System.out.println("是回文！");
}
}
String类实现字符串之间大小的比较
- 比较大小关系，大于、小于和等于，而布尔类型只有false和true两种，无法表示，所以使用int类型类表示大小关系
- 按字典顺序比较两个字符串，即第一个字符的ASCII码比较，如果不等，则返回差值，否则继续比较第二个字符的ASCII码…
public class StringCompareTest {
public static void main(String[] args) {
// 1.构造String类型的对象并打印
String str1 = new String("hello");
System.out.println("str1 = " + str1); // hello
// 2.使用构造好的对象与其它字符串对象之间比较大小并打印
System.out.println(str1.compareTo("world")); // 'h' - 'w' => 104 - 119 => -15
System.out.println(str1.compareTo("haha")); // 'e' - 'a' => 101 - 97 => 4
System.out.println(str1.compareTo("hehe")); // 'l' - 'h' => 108 - 104 => 4
System.out.println(str1.compareTo("heihei")); // 'l' - 'i' => 108 - 105 => 3
System.out.println(str1.compareTo("helloworld")); // 长度： 5 - 10 => -5
System.out.println(str1.compareToIgnoreCase("HELLO")); // 0
}
}
String类实现各种方法的使用
public class StringManyMethodTest {
public static void main(String[] args) {
// 1.构造String类型的对象并打印
String str1 = new String(" Let Me Give You Some Color To See See!");
System.out.println("str1 = " + str1); // Let Me Give You Some Color To See See!
// 2.实现各种成员方法的调用和测试
boolean b1 = str1.contains("some");
System.out.println("b1 = " + b1); // false 区分大小写
b1 = str1.contains("Some");
System.out.println("b1 = " + b1); // true
System.out.println("----------------------------------------------");
// 将所有字符串转换为大写 小写 以及去除两边的空白字符
String str2 = str1.toUpperCase();
System.out.println("str2 = " + str2); // LET ME GIVE YOU SOME COLOR TO SEE SEE!
System.out.println("str1 = " + str1); // Let Me Give You Some Color To See See! 常量
String str3 = str1.toLowerCase();
System.out.println("str3 = " + str3); // let me give you some color to see see!
System.out.println("str1 = " + str1); // Let Me Give You Some Color To See See!
String str4 = str1.trim();
System.out.println("str4 = " + str4); //Let Me Give You Some Color To See See! 奇点
System.out.println("----------------------------------------------");
// 判断字符串是否以...开头 以...结尾
b1 = str1.startsWith("Let");
System.out.println("b1 = " + b1); // false
b1 = str1.startsWith(" ");
System.out.println("b1 = " + b1); // true
// 从下标5开始是否以"Let"开头
b1 = str1.startsWith("Let", 5);
System.out.println("b1 = " + b1); // true
b1 = str1.endsWith("See");
System.out.println("b1 = " + b1); // false
b1 = str1.endsWith("See!");
System.out.println("b1 = " + b1); // true
}
}
String类实现登录功能的模拟
- 提示用户从键盘输入用户名和密码信息，若输入”admin”和”123456”则提示“登录成功，欢迎使
用”，否则提示“用户名或密码错误，您还有n次机会”，若用户输入三次后依然错误则提示“账户已冻结，请联系客服人员！” - 使用以下方法
import java.util.Scanner;
public class StringEqualsTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
for (int i = 3; i > 0; i--) {
// 1.提示用户从键盘输入用户名和密码信息并使用变量记录
System.out.println("请输入您的用户名和密码信息：");
String userName = sc.next();
String password = sc.next();
// 2.判断用户名和密码是否为"admin"和"123456"并给出提示
//if ("admin".equals(userName) && "123456".equals(password)) {
if ("admin".equalsIgnoreCase(userName) && "123456".equals(password)) { // 忽略大小写
// 如果写成下面的形式，由于userName有可能为null，会引起空指针异常
// if (userName.equalsIgnoreCase("admin") && "123456".equals(password)) {
System.out.println("登录成功，欢迎使用！");
break;
} //else {
if (1 == i) {
System.out.println("账户已冻结，请联系客服人员！");
} else {
System.out.println("用户名或密码错误，您还有" + (i - 1) + "次机会！");
}
//}
}
// 关闭扫描器
sc.close();
}
}
字符和字符串的正向(反向)查找
- 正向
- 反向
- 代码实现
public class StringIndexTest {
public static void main(String[] args) {
// 1.构造String类型的对象并打印
String str1 = new String("Good Good Study, Day Day Up!");
System.out.println("str1 = " + str1); // Good Good Study, Day Day Up!
// 2.实现字符串中指定字符和字符串的查找功能
int pos = str1.indexOf('g');
System.out.println("pos = " + pos); // -1 代表查找失败
pos = str1.indexOf('G');
System.out.println("pos = " + pos); // 0 该字符第一次出现的索引位置
// 表示从下标0开始查找字符'G'第一次出现的索引位置，包含0
pos = str1.indexOf('G', 0);
System.out.println("pos = " + pos); // 0
pos = str1.indexOf('G', 1);
System.out.println("pos = " + pos); // 5
System.out.println("------------------------------------------------------");
// 查找字符串
pos = str1.indexOf("day");
System.out.println("pos = " + pos); // -1
pos = str1.indexOf("Day");
System.out.println("pos = " + pos); // 17 字符串中第一个字符的下标
pos = str1.indexOf("Day", 17);
System.out.println("pos = " + pos); // 17 字符串中第一个字符的下标
pos = str1.indexOf("Day", 18);
System.out.println("pos = " + pos); // 21 字符串中第一个字符的下标
System.out.println("------------------------------------------------------");
// 编写通用代码实现将字符串str1中所有"Day"出现的索引位置找到并打印出来
pos = str1.indexOf("Day");
while (-1 != pos) {
System.out.println("pos = " + pos); // 17
pos = str1.indexOf("Day", pos+1);
}
System.out.println("------------------------------------------------------");
// 优化一下
pos = 0;
while ((pos = str1.indexOf("Day", pos)) != -1) {
System.out.println("pos = " + pos);
pos += "Day".length();
}
System.out.println("------------------------------------------------------");
// 3.实现字符和字符串内容的反向查找
pos = str1.lastIndexOf('G');
System.out.println("pos = " + pos); // 5
// 从下标5的位置开始反向查找
pos = str1.lastIndexOf('G', 5);
System.out.println("pos = " + pos); // 5
pos = str1.lastIndexOf('G', 6);
System.out.println("pos = " + pos); // 5
pos = str1.lastIndexOf('G', 4);
System.out.println("pos = " + pos); // 0
System.out.println("------------------------------------------------------");
pos = str1.lastIndexOf("Day");
System.out.println("pos = " + pos); // 21
pos = str1.lastIndexOf("Day", 21);
System.out.println("pos = " + pos); // 21
pos = str1.lastIndexOf("Day", 20);
System.out.println("pos = " + pos); // 17
pos = str1.lastIndexOf("Day", 15);
System.out.println("pos = " + pos); // -1
}
}
String类中子字符串的获取
import java.util.Scanner;
public class SubStringTest {
public static void main(String[] args) {
// 1.构造String类型的对象并打印
String str1 = new String("Happy Wife, Happy Life!");
System.out.println("str1 = " + str1); // Happy Wife, Happy Life!
// 2.获取字符串中的一部分内容并打印
// 表示从当前字符串中下标12开始获取子字符串
String str2 = str1.substring(12);
System.out.println("str2 = " + str2); // Happy Life!
// 可以取到6但是取不到10
String str3 = str1.substring(6, 10);
System.out.println("str3 = " + str3); // Wife
System.out.println("---------------------------------------------------------");
// 3.获取输入字符串中从输入字符起的子字符串内容
System.out.println("请输入一个字符串：");
Scanner sc = new Scanner(System.in);
String str4 = sc.next();
System.out.println("请输入一个字符：");
String str5 = sc.next();
// 从str4中查找str5第一次出现的索引位置
int pos = str4.indexOf(str5);
System.out.println("pos = " + pos);
// 根据该位置获取子字符串
String str6 = str4.substring(pos+1);
System.out.println("获取到的子字符串是：" + str6);
}
}
2.4 正则表达式
概念（了解）
- 正则表达式本质就是一个“规则字符串”，可以用于对字符串数据的格式进行验证，以及匹配、查找、替换等操作。该字符串通常使用 ^ 运算符作为开头标志，使用 $ 运算符作为结尾标志，当然也可以省略。
规则（了解）
- 需要使用以下方法来使用正则表达式
- 此方法的参数必须是：正则表达式
编程使用
- 使用正则表达式描述一下银行卡密码的规则：要求是由6位数字组成。
- 正则表达式描述一下QQ号码的规则：要求是由非0开头的5~15位数组成。
- 正则表达式描述一下手机号码的规则：要求是由1开头，第二位数是3、4、5、7、8中的一位，总共11位
- 身份证号码的规则：总共18位，6位数字代表地区，4位数字代表年，2位数字代表月，2位数字代表日期， 3位数字代表个人，最后一位可能数字也可能是X。
public class StringRegTest {
public static void main(String[] args) {
// 1.定义描述规则的正则表达式字符串并使用变量记录
// 正则表达式只能对数据格式进行验证，无法对数据内容的正确性进行检查，内容的正确性检查需要后台查询数据库
// 描述银行卡密码的规则：由6位数字组成
//String reg = "^[0-9]{6}$";
//String reg = "[0-9]{6}"; // ^ 和 $ 可以省略
//String reg = "\\d{6}"; // 前面一个斜杠\是用于转义
// 使用正则表达式描述一下QQ号码的规则：要求是由非0开头的5~15位数字组成。
//String reg = "[1-9]\\d{4,14}";
//使用正则表达式描述一下手机号码的规则：要求是由1开头，第二位数是3、4、5、7、8中的一位，总共11位
//String reg = "1[34578]\\d{9}";
//描述身份证号码的规则：总共18位，6位数字代表地区，4位数字代表年，2位数字代表月，2位数字代表日期， 3位数字代表个人，
// 最后一位可能数字也可能是X。
String reg = "(\\d{6})(\\d{4})(\\d{2})(\\d{2})(\\d{3})([0-9|X])"; // 小括号里面为一个整体，([0-9|X])中的|表示或的意思
// 上面的身份证号输入格式：46000319891230465X
// 2.提示用户从键盘输入指定的内容并使用变量记录
Scanner sc = new Scanner(System.in);
while(true) {
//System.out.println("请输入您的银行卡密码：");
//System.out.println("请输入您的QQ号码：");
//System.out.println("请输入您的手机号码：");
System.out.println("请输入您的身份证号码：");
String str = sc.next();
// 3.判断用户输入的字符串内容是否满足指定的规则并打印
if (str.matches(reg)) {
//System.out.println("银行卡密码的格式正确！");
System.out.println("输入字符串的格式正确！");
break;
} else {
//System.out.println("银行卡密码的格式错误！");
System.out.println("输入字符串的格式错误！");
}
}
}
}
相关的方法使用
public class StringRegMethodTest {
public static void main(String[] args) {
// 1.准备一个字符串对象并打印
String str1 = "1001,zhangfei,30";
System.out.println("str1 = " + str1); // 1001,zhangfei,30
// 2.按照逗号对字符串内容进行切割
String[] sArr = str1.split(",");
for (int i = 0; i < sArr.length; i++) {
System.out.println("下标为" + i + "的字符串是：" + sArr[i]); // 1001 zhangfei 30
}
System.out.println("--------------------------------------------------------------");
// 3.准备一个字符串内容并进行替换
String str2 = "我的小名叫大帅哥";
// 将字符串中所有的字符'我'替换为'你'
String str3 = str2.replace('我', '你');
System.out.println("str2 = " + str2); // 我的小名叫大帅哥
System.out.println("str3 = " + str3); // 你的小名叫大帅哥
// 将字符串中所有的字符'大'替换为'小'
String str4 = str3.replace('大', '小');
System.out.println("str4 = " + str4); // 你的小名叫小帅哥
// 将字符串中所有的字符'小'替换为'大'
String str5 = str4.replace('小', '大');
System.out.println("str5 = " + str5); // 你的大名叫大帅哥
System.out.println("--------------------------------------------------------------");
// 4.准备一个字符串进行字符串内容的替换
String str6 = "123abc456def789ghi";
// 将第一个数字字符串替换为"#"
String str7 = str6.replaceFirst("\\d+", "#");
System.out.println("替换第一个字符串后的结果是：" + str7); // #abc456def789ghi
// 将所有字母字符串替换为"$$$"
String str8 = str7.replaceAll("[a-z]+", "A");
System.out.println("str8 = " + str8); // #A456A789A
}
}
总结
