目录
String类的概述和使用
String类的概念
java.lang.String类用于描述字符串,java程序中的所有字符串字面值都可以使用该类的对象加以描述,如:"abc"- 该类由final关键字修饰,表示该类不能被继承
- 从jdk1.9开始该类的底层不使用char[]来存储数据,而是改查byte[]加上编码标记,从而节约了一些空间
- 该类描述的字符串内容是个常量不可更改,因此可以被共享使用,如:
String str1 = "abc"; //其中"abc"这个字符串是个常量不可改变
str1 = "123"; // 将"123"字符串的地址复制给str1
//上面改变str1的指向,但并没有改变指向的内容
常量池的概念(原理)
由于String类型描述的字符串内容是常量不可改变,因此Java虚拟机将首次出现的字符串放入常量池中,若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及创建对象,从而提高了性能.
StringTest.java
package cn.itcast.module2.demo02;
public class StringTest {
public static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2);
/**
* == 比较的是左边两个字符串的地址,比较结果是true,
* 意味着两个字符串地址相同,是同一个对象,
* 所以两次赋值并没有创建新对象,而是用的常量池中的同一个对象
*/
}
}
//执行结果
true
常用的构造方法
| 方法声明 | 功能介绍 |
|---|---|
String() |
使用无参方式构造对象得到空字符序列 |
String(byte[] bytes, int offset, int length) |
使用bytes数组中下标从offset位置开始的length个字节来构造对象 |
String(byte[] bytes) |
使用bytes数组中的所有内容构造对象 |
String(char[] value, int offset, int count) |
使用value数组中下标从offset位置开始的count个字符来构造对象 |
String(char[] value) |
使用value数组中的所有内容构造对象 |
String(String original) |
根据参数指定的字符串内容来构造对象,新创建对象为参数对象的副本 |
StringConstructorTest.java
package cn.itcast.module2.demo02;
public class StringConstructorTest {
public static void main(String[] args) {
//1.使用无参方式构造对象并打印
String str1 = new String();
/**
* "" 表示空字符串对象，有对象只是里面没有内容
* null 表示空,连对象都没有
*/
System.out.println("str1 = " + str1); //自动调用toString方法
System.out.println("-----------------------------");
//2.使用参数指定的byte数组来构造对象并打印
// 'a' - 97
byte[] bArr = {97, 98 , 99, 100, 101};
//使用字节数组中的一部分内容来构造对象,表示使用数组bArr中下标从1开始的3个字节构造字符串对象
//构造字符串的思路:就是先将每个整数翻译成对应的字符,再将所有的字符串起来
String str2 = new String(bArr, 1, 3);
System.out.println("str2 = " + str2);
//使用整个字节数组来构造字符串对象
String str3 = new String(bArr);
System.out.println("str3 = " + str3); //abcde
System.out.println("-----------------------------");
//3.使用字符数组来构造字符串对象
char[] cArr = {'h', 'e', 'l', 'l', 'o'};
//使用字符数组中的一部分内容来构造对象
//思路:直接将字符串起来
String str4 = new String(cArr, 2, 2);
System.out.println("str4 = " + str4); //ll
//使用整个字符数组来构造对象
String str5 = new String(cArr);
System.out.println("str5 = " + str5); //hello
System.out.println("-----------------------------");
//4.使用字符串来构造字符串对象
String str6 = new String("world");
System.out.println("str6 = " + str6); //world
}
}
笔试考点
StringExamTest.java
package cn.itcast.module2.demo02;
public class StringExamTest {
public static void main(String[] args) {
//1.请问下面的代码会创建几个对象?分别存放在什么地方? String s1 = "hello";创建1个对象,存放在常量池中
String s1 = "hello"; //创建1个对象,存放在常量池中
String s2 = new String("hello"); //创建2个对象,其中一个存放在常量池中,另一个存放在堆区中,变量s2指向的是堆区空间的内存
//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 == str4); //比较地址 false
System.out.println(str2.equals(str4)); //比较内容 true
System.out.println("--------------------------------------------------");
//3.常量有优化机制,而变量没有
String str5 = "abcd";
String str6 = "ab" + "cd"; //这里用到了常量优化机制,拼接后的字符串仍然在常量池中
System.out.println(str5 == str6); //true
String str7 = "ab";
String str8 = str7 + "cd"; // 有变量,所以没有常量优化机制
System.out.println(str5 == str8);
}
}
常用的成员方法
| 方法声明 | 功能介绍 |
|---|---|
String toString() |
返回字符串本身 |
byte[] getBytes() |
将当前字符串内容转换为byte数组并返回 |
cahr[] toCharArray() |
用于将当前字符串内容转换为char数组并返回 |
char charAt(int index) |
方法charAt用于返回字符串指定位置的字符 |
int length() |
返回字符串字符序列的长度 |
boolean isEmpty() |
判断字符串是否为空 |
String类型和数组之间的转换
StringByteCharTest.java
package cn.itcast.module2.demo02;
public class StringByteCharTest {
public static void main(String[] args) {
//1.创建String类型的对象并打印
String str1 = new String("world");
System.out.println("str1 = " +str1); //world
System.out.println("----------------------------------");
//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("转回字符串为:" + str2); //world
System.out.println("----------------------------------");
//3.实现将String类型转换为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("转回字符串为:" + str3); //world
}
}
//执行结果
str1 = world
----------------------------------
bArr = [119, 111, 114, 108, 100]
下标为i的元素是:119
下标为i的元素是:111
下标为i的元素是:114
下标为i的元素是:108
下标为i的元素是:100
转回字符串为:world
----------------------------------
cArr = [w, o, r, l, d]
下标为0的字符是:w
下标为1的字符是:o
下标为2的字符是:r
下标为3的字符是:l
下标为4的字符是:d
转回字符串为:world
String类中字符的获取和使用
StringCharTest.java
package cn.itcast.module2.demo02;
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());
for (int i = 0; i < str1.length(); i++) {
System.out.println("下标为" + i + "的字符是:" + str1.charAt(i));
}
System.out.println("-----------------------------------------");
//3.判断字符是否为空
System.out.println(0 == str1.length() ? "字符串为空" : "字符串不为空");
System.out.println(str1.isEmpty() ? "字符串为空" : "字符串不为空");
System.out.println("-----------------------------------------");
//4.笔试考点: 使用两种方式实现字符串"12345"转换为整数12345并打印
String str2 = new String("12345");
//方式一:调用Integer类中的parseInt()方法即可
int ia = Integer.parseInt(str2);
System.out.println("转换出来的整数是:" + ia);
//方式二:利用ASCII来实现类型转换并打印
//'1' - '0' => 1, '2' - '0' => 2
//字符串1对应的ASCII 减去 字符0对应的ASCII 的数值是1,字符串2对应的ASCII 减去 字符0对应的ASCII 的数值是2
int ib = 0;
for (int i = 0; i < str2.length(); i++) {
ib = ib*10 + (str2.charAt(i) - '0');
}
System.out.println("转换出来的整数时:" + ib);
System.out.println("-----------------------------------------");
//5.笔试考点: 如何实现整数到字符串的转换
int ic = 56789;
//方式一:
String str3 = "" + ic; //推荐使用
System.out.println("str3 = " + str3);
}
}
//执行结果
str1 = hello
字符串长度是:5
下标为0的字符是:h
下标为1的字符是:e
下标为2的字符是:l
下标为3的字符是:l
下标为4的字符是:o
-----------------------------------------
字符串不为空
字符串不为空
-----------------------------------------
转换出来的整数是:12345
转换出来的整数时:12345
-----------------------------------------
str3 = 56789
案例:String类对象实现回文的判断
判断字符串"上海自来水来自海上"是否为回文并打印(所谓回文是指一个字符序列无论从左往右读还是从右往左读都是相同的句子)
StringJudgeTest.java
package cn.itcast.module2.demo02;
public class StringJudgeTest {
public static void main(String[] args) {
String str1 = new String("上海自来水来自海上");
for (int i = 0; i < str1.length() / 2; i++) {
if (str1.charAt(i) != str1.charAt(str1.length() - i - 1)) {
System.out.println(str1 + "不是回文");
return;
}
}
System.out.println(str1 + "是回文");
}
}
//执行结果
上海自来水来自海上是回文
String类实现字符串之间大小的比较
| 方法声明 | 功能介绍 |
|---|---|
int compareTo(String anotherString) |
用于比较调用对象和参数对象的大小关系 |
int compareToIgnoreCase(String str) |
不考虑大小写，也就是'a'和'A'是相等的关系 |
StringCompareTest.java
package cn.itcast.module2.demo02;
public class StringCompareTest {
public static void main(String[] args) {
String str1 = new String("hello");
System.out.println("str1 = " + str1);
System.out.println(str1.compareTo("world"));
System.out.println(str1.compareTo("hello"));
}
}
//执行结果
str1 = hello
-15
0
String类实现各种方法的使用
| 方法声明 | 功能介绍 |
|---|---|
String concat(String str) |
用于实现字符串的拼接 |
boolean contains(CharSequence s) |
用于判断当前字符串是否包含参数指定的内容 |
String toLowerCase() |
返回字符串的小写形式 |
String toUpperCase() |
返回字符串的大写形式 |
String trim() |
返回去掉前导和后继空白的字符串 |
boolean startsWith(String prefix) |
判断字符串是否以参数字符串开头 |
boolean startsWith(String prefix, int toffset) |
从指定位置开始是否以参数字符串开头 |
boolean endsWith(String suffix) |
判断字符串是否以参数字符串结尾 |
StringManyMethodTest.java
package cn.itcast.module2.demo02;
public class StringManyMethodTest {
public static void main(String[] args) {
String str1 = new String(" Hello");
String str2 = new String(" World ");
String str3 = str1.concat(str2); //字符串拼接
System.out.println("字符串拼接结果:" + """ + str3 + """); //打印结果:" Hello world "
System.out.println(str3.contains("hello") ? """ + str3 + """ + "包含"hello"" : """ + str3 + """ + "不包含"hello"");
System.out.println(str3.contains("Hello") ? """ + str3 + """ + "包含"Hello"" : """ + str3 + """ + "不包含"Hello"");
System.out.println(""" + str3 + ""的小写是:" + """ + str3.toLowerCase() + """);
System.out.println(""" + str3 + ""的大写是:" + """ + str3.toUpperCase() + """);
System.out.println(""" + str3 + ""去掉两侧空白后是:" + """ + str3.trim() + """);
System.out.println(str3.startsWith(" hello") ? """ + str3 + ""以" hello"开头" : """ + str3 + ""不以" hello"开头");
System.out.println(str3.startsWith(" Hello") ? """ + str3 + ""以" Hello"开头" : """ + str3 + ""不以" Hello"开头");
System.out.println(str3.endsWith("world ") ? """ + str3 + ""以"world "结尾" : """ + str3 + ""不以"world "结尾");
System.out.println(str3.endsWith("World ") ? """ + str3 + ""以"World "结尾" : """ + str3 + ""不以"World "结尾");
}
}
//执行结果
字符串拼接结果:" Hello World "
" Hello World "不包含"hello"
" Hello World "包含"Hello"
" Hello World "的小写是:" hello world "
" Hello World "的大写是:" HELLO WORLD "
" Hello World "去掉两侧空白后是:"Hello World"
" Hello World "不以" hello"开头
" Hello World "以" Hello"开头
" Hello World "不以"world "结尾
" Hello World "以"World "结尾
案例:String类实现登录功能模拟
| 方法声明 | 功能介绍 |
|---|---|
boolean equals(Object anObject) |
用于比较字符串内容是否相等并返回 |
int hashCode() |
获取调用对象的哈希码值 |
boolean equalsIgnoreCase(String anotherString) |
用于比较字符串内容是否相等并返回，不考虑大小写，如：'A'和'a'是相等 |
案例题目:提示用户从键盘输入用户名和密码信息，若输入”admin”和”123456”则提示“登录成功，欢迎使
用”，否则提示“用户名或密码错误，您还有n次机会”，若用户输入三次后依然错误则提示“账户已
冻结，请联系客服人员！”
StringEqualsTest.java
package cn.itcast.module2.demo02;
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--) {
System.out.println("请输入用户名密码:");
String userName = sc.next().trim();
String password = sc.next().trim();
if ("admin".equalsIgnoreCase(userName) && "123456".equals(password)) {
System.out.println("登录成功,欢迎使用!");
break;
}
if (1 == i) {
System.out.println("账户已冻结,请联系客服人员!");
} else {
System.out.println("用户名或密码错误,您还有" + (i - 1) + "次机会!");
}
}
sc.close();
}
}
//执行结果
请输入用户名密码:
admin admin
用户名或密码错误,您还有2次机会!
请输入用户名密码:
admin admin
用户名或密码错误,您还有1次机会!
请输入用户名密码:
admin 123456
登录成功,欢迎使用!
String类实现字符和字符串的正向/反向查找
| 方法声明 | 功能介绍 |
|---|---|
int indexOf(int ch) |
用于返回当前字符串中参数ch指定的字符第一次出现的下标 |
int indexOf(int ch, int fromIndex) |
用于从fromIndex位置开始查找ch指定的字符 |
int indexOf(String str) |
在字符串中检索str返回其第一次出现的位置,若找不到返回-1 |
int indexOf(String str, int fromIndex) |
表示从字符串的fromIndex位置开始检索str第一次出现的位置 |
int lastIndexOf(int ch) |
用于返回参数ch指定的字符最后一次出现的下标 |
int lastIndexOf(int ch, int fromIndex) |
用于从fromIndex位置开始查找ch指定字符出现的下标 |
int lastIndexOf(String str) |
返回str指定字符串最后一次出现的下标 |
int lastIndexOf(String str, int fromIndex) |
用于从fromIndex位置开始反向搜索的第一次出现的下标 |
String类中子字符串的获取
| 方法声明 | 功能介绍 |
|---|---|
String substring(int beginIndex, int endIndex) |
返回字符串中从下标beginIndex（包括）开始到endIndex（不包括）结束的子字符串 |
String substring(int beginIndex) |
返回字符串中从下标beginIndex（包括）开始到字符串结尾的子字符串 |
SubStringTest.java
package cn.itcast.module2.demo02;
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);
//2.获取字符串中的一部分内容并打印
//表示从当前字符串中下标12开始获取子字符串
String str2 = str1.substring(12);
System.out.println("str2 = " + str2);
//可以取到6但是取不到10(左闭右开)
String str3 = str1.substring(6, 10);
System.out.println("str3 = " + str3);
System.out.println("----------------------------------------");
//3.获取输入字符串中从输入字符起的子字符串内容
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String str4 = sc.next();
System.out.println("请输入一个字符:");
String str5 = sc.next();
//从str4中查找str5第一次出现的位置
int pos = str4.indexOf(str5);
System.out.println(str4 + "中第一次出现" + str5 + "的位置是:" + pos);
//根据该位置截取后面的子字符串
String str6 = str4.substring(pos + 1);
System.out.println("获取到的子字符串是:" + str6);
}
}
//执行结果
str1 = Happy Wife, Happy Life!
str2 = Happy Life!
str3 = Wife
----------------------------------------
请输入一个字符串:
hello
请输入一个字符:
l
hello中第一次出现l的位置是:2
获取到的子字符串是:lo
正则表达式
正则表达式的概念
正则表达式本质就是一个"规则字符串",可以用于对字符串数据的格式进行验证,以及匹配/查找/替换等操作.该字符串通常使用^运算符作为开头标志,使用$运算符作为结尾标志,当然也可以省略.
正则表达式的规则
| 正则表达式 | 说明 |
|---|---|
[abc] |
可以出现a、b、c中任意一个字符 |
[^abc] |
可以出现任何字符，除了a、b、c的任意字符 |
[a-z] |
可以出现a、b、c、……、z中的任意一个字符 |
[a-zA-Z0-9] |
可以出现a~z、A~Z、0~9中任意一个字符 |
| 正则表达式 | 说明 |
|---|---|
. |
任意一个字符（通常不包含换行符） |
d |
任意一个数字字符，相当于[0-9] |
D |
任意一个非数字字符 |
s |
空白字符，相当于
x0Bf
] |
S |
非空白字符 |
w |
任意一个单词字符，相当于[a-zA-Z_0-9] |
W |
任意一个非单词字符 |
| 正则表达式 | 说明 |
|---|---|
X? |
表示X可以出现一次或一次也没有，也就是0 ~ 1次 |
X* |
表示X可以出现零次或多次，也就是0 ~ n次 |
X+ |
表示X可以出现一次或多次，也就是1 ~ n次 |
X{n} |
表示X可以出现恰好 n 次 |
X{n,} |
表示X可以出现至少 n 次，也就是>=n次 |
X{n,m} |
表示X可以出现至少 n 次，但是不超过 m 次，也就是>=n并且<=m次 |
正则表达式相关的方法
| 方法名称 | 方法说明 |
|---|---|
boolean matches(String regex) |
判断当前正在调用的字符串是否匹配参数指定的正则表达式规则 |
String[] split(String regex) |
参数regex为正则表达式，以regex所表示的字符串为分隔符，将字符串拆分成字符串数组 |
String replace(char oldChar,newChar) |
使用参数newChar替换此字符串中出现的所有参数oldChar |
String replaceFirst(String regex,String replacement) |
替换此字符串匹配给定的正则表达式的第一个子字符串 |
String replaceAll(String regex,String replacement) |
将字符串中匹配正则表达式regex的字符串替换成replacement |