知识点–1.String类的常用方法
知识点–1.1 String类概述
目标
- 理解String类概述
路径
- String类的概述
讲解
String类的概述
String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！
小结
- String类表示字符串,在java程序中所有双引号的字符串都是String类的对象
- String类在java.lang包下,所以使用的时候不需要导包
知识点–1.2 String类的构造方法
目标
- 掌握String类构造方法的使用
路径
- String类常用的构造方法
- 使用String类的构造方法
讲解
String类常用的构造方法
- 常用的构造方法
public String() 创建一个空字符串对象 例如: ""
public String(byte[] bytes) 根据byte数组中的内容,来创建对应的字符串对象
public String(byte[] bytes, int offset, int length) 指定byte数组的范围,根据指定范围中的内容,来创建对应的字符串对象
public String(char[] value) 根据char数组中的内容,来创建对应的字符串对象
public String(String original) 新创建的字符串是该参数字符串的副本。
直接写字符串字面值也是String类对象 例如: String str = "abc"; 常用
使用String类的构造方法
public class Test {
public static void main(String[] args) {
/*
public String() 创建一个空字符串对象 例如: ""
public String(byte[] bytes) 根据byte数组中的内容,来创建对应的字符串对象
public String(byte[] bytes, int offset, int length) 指定byte数组的范围,根据指定范围中的内容,来创建对应的字符串对象
public String(char[] value) 根据char数组中的内容,来创建对应的字符串对象
public String(String original) 新创建的字符串是该参数字符串的副本。
直接写字符串字面值也是String类对象 例如: String str = "abc"; 常用
*/
// 创建一个空字符串对象
String str1 = new String();// str1表示的字符串是:""
// 根据byte数组中的内容,来创建对应的字符串对象
byte[] bys = {97,98,99,100};
String str2 = new String(bys);// str2表示的字符串是:"abcd"
// 指定byte数组的范围,根据指定范围中的内容,来创建对应的字符串对象
String str3 = new String(bys,1,2);// str3表示的字符串是:"bc"
// 根据char数组中的内容,来创建对应的字符串对象
char[] chs = {'a','b','c'};
String str4 = new String(chs);// str4表示的字符串是:"abc"
// 新创建的字符串是该参数字符串的副本
String str5 = new String("abc");// str5表示的字符串是:"abc"
// 直接写字符串字面值也是String类对象
String str6 = "abc";
System.out.println("str1:"+str1+"=");
System.out.println("str2:"+str2);
System.out.println("str3:"+str3);
System.out.println("str4:"+str4);
System.out.println("str5:"+str5);
System.out.println("str6:"+str6);
}
}
知识点–1.3 创建字符串对象两种方式的区别
目标
- 能够知道通过构造方法创建字符串对象与直接赋值方式创建字符串对象的区别
路径
-
通过构造方法创建
-
直接赋值方式创建
-
绘制对比内存图
讲解
通过构造方法创建
- 通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然字符串内容相同，但是地址值不同
char[] chs = {'a','b','c'};
String s1 = new String(chs);// s1字符串的内容: abc
String s2 = new String(chs);// s2字符串的内容: abc
// 上面的代码中,JVM首先会先创建一个字符数组,然后每一次new的时候都会有一个新的地址,只不过s1和s2参考的字符串内容是相同的
直接赋值方式创建
- 以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护
String s3 = "abc";
String s4 = "abc";
// 上面的代码中,针对第一行代码,JVM会建立一个String对象放在字符串池中,并给s3参考;第二行代码,则让s4直接参考字符串池中String对象,也就是说他们本质上是同一个对象
绘制内存图
public class Test {
public static void main(String[] args) {
// - 通过构造方法创建
char[] chs = {'a','b','c'};
String str1 = new String(chs);// str1表示的字符串是: "abc"
String str2 = new String(chs);// str2表示的字符串是: "abc"
System.out.println(str1 == str2);// false ==比较的是2个对象的地址值
// - 直接赋值方式创建
String str3 = "abc";// str3表示的字符串是: "abc"
String str4 = "abc";// str4表示的字符串是: "abc"
System.out.println(str3 == str4);// true 直接赋值方式创建的字符串是字符串常量
}
}
小结
- 通过new创建的字符串对象,每一次都会新开辟空间
- 通过""方式直接创建的字符串对象,是常量,在常量池中,只有一份
知识点–1.4 String类的特点
目标
- 能够理解String类的特点
路径
- String类的特点
讲解
String类的特点
- String类的字符串不可变，它们的值在创建后不能被更改
String s1 = "abc";
s1 += "d";// s1 = s1 + "d"
System.out.println(s1);
// 内存中有"abc"，"abcd","d",3个对象，s1从指向"abc"，改变指向，指向了"abcd"。
- 虽然 String 的常量值是不可变的，但是它们可以被共享
String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。
- 字符串效果上相当于字符数组( char[] )
例如：
String str = "abc";
相当于：
char[] data = {'a', 'b', 'c'};
String str = new String(data);// str表示的字符串内容: abc
// String底层是靠字符数组实现的jdk8,jdk9底层是字节数组。
byte[] bys = {97,98,99};
String str = new String(bys);// str表示的字符串内容: abc
小结
String类的特点:
1.String类不可变
2.String类字符串常量对象可以共享
3. String底层是靠字符数组实现的,jdk9底层是字节数组。
知识点–1.5 字符串的比较
目标
- 能够比较2个字符串内容是否相同
路径
- ==号的比较
- equals方法的作用
- equalsIgnoreCase 方法的使用
讲解
==号的比较
- 比较基本数据类型：比较的是具体的值
int num1 = 10;
int num2 = 20;
num1 == num2 ===> 10==20 结果:false
- 比较引用数据类型：比较的是对象地址值
String str1 = new String("abc");
String str2 = new String("abc");
str1 == str2 ===> str1存储的对象地址值 == str2存储的对象地址值 结果: false
// ==比较运算符:
private static void method01() {
// 基本数据类型比较的是2个变量中的值是否相同
int num1 = 10;
int num2 = 10;
System.out.println(num1 == num2);// true
// 引用数据类型比较的是2个对象的地址值是否相同
String str1 = "abc";
char[] chs = {'a','b','c'};
String str2 = new String(chs);// "abc"
System.out.println(str1 == str2);// false
}
equals方法的作用
-
字符串是对象,它比较内容是否相同,是通过一个方法来实现的,就是equals()方法
-
方法介绍
public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写
- 示例代码
public class StringDemo02 {
public static void main(String[] args) {
String str1 = "abc";
String str2 = new String("abc");
String str3 = "abc";
String str4 = "Abc";
// 比较str1和str2中的字符串内容是否相同(区分大小写)
System.out.println(str1.equals(str2));// true
// 比较str1和str3中的字符串内容是否相同(区分大小写)
System.out.println(str1.equals(str3));// true
// 比较str1和str4中的字符串内容是否相同(区分大小写)
System.out.println(str1.equals(str4));// false
}
}
扩展
-
public boolean equalsIgnoreCase (String anotherString)：将此字符串与指定对象进行比较，忽略大小写。 -
示例
public static void main(String[] args) {
String str1 = "abc";
String str2 = new String("abc");
String str3 = "abc";
String str4 = "Abc";
// 比较str1和str2中的字符串内容是否相同(不区分大小写)
System.out.println(str1.equalsIgnoreCase(str2));// true
// 比较str1和str3中的字符串内容是否相同(不区分大小写)
System.out.println(str1.equalsIgnoreCase(str3));// true
// 比较str1和str4中的字符串内容是否相同(不区分大小写)
System.out.println(str1.equalsIgnoreCase(str4));// true
}
小结
- 比较字符串内容是否相等,区分大小写,需要使用String类的equals方法,千万不要用 == 比较
- 如果比较字符串内容是否相等,不区分大小写,需要使用String类的equalsIgnoreCase()方法
知识点–1.6 String类获取功能的方法
目标
- 理解String类中各个方法的作用\调用
路径
- 介绍获取功能的方法
- 使用获取功能的方法
讲解
获取功能的方法
- public int length () ：返回此字符串的长度。
- public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
- public char charAt (int index) ：返回指定索引处的 char值。
- public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
- public int indexOf (String str,int fromIndex) ：返回指定子字符串第一次出现在该字符串内的索引,从指定的索引开始。
- public int lastIndexOf(String str) ：返回指定子字符串最后一次出现在该字符串内的索引。
- public int lastIndexOf(String str,int fromIndex) ：返回指定子字符串最后一次出现在该字符串内的索引,从指定的索引开始反向搜索。
- public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
- public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
使用获取功能的方法
public class Test {
public static void main(String[] args) {
/*
String类获取功能的方法:
- public int length () ：返回此字符串的长度。
- public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
- public char charAt (int index) ：返回指定索引处的 char值。
- public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
- public int indexOf (String str,int fromIndex) ：返回指定子字符串第一次出现在该字符串内的索引,从指定的索引开始。
- public int lastIndexOf(String str) ：返回指定子字符串最后一次出现在该字符串内的索引。
- public int lastIndexOf(String str,int fromIndex) ：返回指定子字符串最后一次出现在该字符串内的索引,从指定的索引开始反向搜索。
- public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
- public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
*/
String str1 = "hello";
// 需求1:获取str1字符串的长度
int len = str1.length();
System.out.println("str1字符串的长度:"+len);// 5
// 需求2:在str1字符串的后面拼接上world
String str2 = str1.concat("world");
System.out.println("原字符串:"+str1);// str1: hello
System.out.println("拼接后的字符串:"+str2);// str2: helloworld
// 需求3:获取str1字符串的第二个字符
char c = str1.charAt(1);
System.out.println("索引为1的字符:"+c);// e
// 需求4:循环遍历str1字符串的每一个字符
for (int i = 0; i < str1.length(); i++) {
System.out.println(str1.charAt(i));
}
System.out.println("=================================");
// public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
String str3 = "hello-java-hello-world-hello-heima";
// 需求5:查找hello子字符串在str3中第一次出现的位置对应的索引
int index1 = str3.indexOf("hello");
System.out.println("index1:"+index1);// 0
// public int indexOf (String str,int fromIndex) ：返回指定子字符串第一次出现在该字符串内的索引,从指定的索引开始。
// 需求5:查找hello子字符串在str3中第二次出现的位置对应的索引
int index2 = str3.indexOf("hello", index1+1);
System.out.println("index2:"+index2);// 11
// public int lastIndexOf(String str) ：返回指定子字符串最后一次出现在该字符串内的索引。
// 需求5:查找hello子字符串在str3中最后一次出现的位置对应的索引
int index3 = str3.lastIndexOf("hello");
System.out.println("index3:"+index3);// 23
// public int lastIndexOf(String str,int fromIndex) ：返回指定子字符串最后一次出现在该字符串内的索引,从指定的索引开始反向搜索。
// 需求5:查找hello子字符串在str3中倒数第二次出现的位置对应的索引
int index4 = str3.lastIndexOf("hello", index3 - 1);
System.out.println("index4:"+index4);// 11
// public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
// 需求6:从str3中截取出"java-hello-world-hello-heima"
String subStr1 = str3.substring(6);
System.out.println("subStr1:"+subStr1);// "java-hello-world-hello-heima"
// public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
// 需求6:从str3中截取出"hello-world"
String subStr2 = str3.substring(11, 22);
System.out.println("subStr2:"+subStr2);// hello-world
}
}
实操–1.7 用户登录案例【应用】
需求
已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示
分析
- 已知用户名和密码，定义两个字符串表示即可
- 键盘录入要登录的用户名和密码，用 Scanner 实现
- 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
- 用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
实现
public class Test {
public static void main(String[] args) {
// 需求: 已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示
// 1.定义2个字符串存储已知的用户名和密码
String username = "admin";
String password = "123456";
// 由于次数确定,所以使用for循环,当输入成功时,可以使用break提前结束循环
for (int i = 0; i < 3; i++) {
// 2.模拟用户输入用户名和密码,使用Scanner
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名:");
String name = sc.next();
System.out.println("请输入密码:");
String pwd = sc.next();
// 3.判断用户输入的用户名和密码是否与已知的用户名和密码完全相同
if (username.equals(name) && password.equals(pwd)) {
// 4.如果相同,那么就显示: 恭喜您,登录成功!
System.out.println("恭喜您,登录成功!");
break;
}else {
// i: 0,1,2
if (i == 2){
System.out.println("很遗憾,您的账户已被锁定,请充钱解锁!");
}else{
// 4.如果不相同,那么就显示: 很遗憾您,登录失败,请重新输入!
System.out.println("很遗憾,登录失败,您还有"+(2-i)+"次机会");
}
}
}
}
}
实操–1.8 遍历字符串案例
需求
键盘录入一个字符串，使用程序实现在控制台遍历该字符串
分析
- 键盘录入一个字符串，用 Scanner 实现
- 遍历字符串，首先要能够获取到字符串中的每一个字符
- 遍历字符串，其次要能够获取到字符串的长度
- 遍历字符串的通用格式
实现
/*
思路：
1:键盘录入一个字符串，用 Scanner 实现
2:遍历字符串，首先要能够获取到字符串中的每一个字符
public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
3:遍历字符串，其次要能够获取到字符串的长度
public int length()：返回此字符串的长度
数组的长度：数组名.length
字符串的长度：字符串对象.length()
4:遍历字符串的通用格式
*/
public class StringTest02 {
public static void main(String[] args) {
//键盘录入一个字符串，用 Scanner 实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String line = sc.nextLine();
for(int i=0; i<line.length(); i++) {
System.out.println(line.charAt(i));
}
}
}
实操–1.9 统计字符次数案例
需求
键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
分析
- 键盘录入一个字符串，用 Scanner 实现
- 要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
- 遍历字符串，得到每一个字符
- 在循环中,判断该字符属于哪种类型，然后对应类型的统计变量+1
- 大写字母：ch>=‘A’ && ch<=‘Z’
- 小写字母： ch>=‘a’ && ch<=‘z’
- 数字： ch>=‘0’ && ch<=‘9’
- 输出三种类型的字符个数
实现
public class Test {
public static void main(String[] args) {
// 需求: 键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
// 1.键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String str = sc.next();
// 2.定义三个int类型的变量,分别用来统计大写,小写,数字字符出现的个数,初始值默认为0
int count1 = 0;
int count2 = 0;
int count3 = 0;
// 3.循环遍历字符串
for (int i = 0; i < str.length(); i++) {
// 4.在循环中,获取遍历出来的字符
char c = str.charAt(i);
// 5.在循环中,判断该字符
if (c >= 'A' && c <= 'Z') {
// 5.如果该字符是大写字母字符,那么就统计大写字母字符个数的变量自增1
count1++;
}else if (c >= 'a' && c <= 'z') {
// 5.如果该字符是小写字母字符,那么就统计小写字母字符个数的变量自增1
count2++;
}else if (c >= '0' && c <= '9') {
// 5.如果该字符是数字字符,那么就统计数字字符个数的变量自增1
count3++;
}
}
// 6.打印结果
System.out.println("大写字母字符个数:"+count1);
System.out.println("小写字母字符个数:"+count2);
System.out.println("数字字符个数:"+count3);
}
}
实操–1.10 字符串拼接案例
需求
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
并在控制台输出结果。例如，数组为 int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
分析
- 定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
- 定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回。返回值类型 String，参数列表 int[] arr
- 在方法中遍历数组，按照要求进行拼接
- 调用方法，用一个变量接收结果
- 输出结果
实现
public class Test {
public static void main(String[] args) {
/*
需求
定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，
并在控制台输出结果。例如，数组为 int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
*/
int[] arr = {1,2,3};
System.out.println(concat(arr));
}
/**
* 按照指定格式拼接数组中的元素
*
* @param arr 数组
* @return 拼接后的字符串
*/
public static String concat(int[] arr) {
// 1.定义一个空字符串对象
String str = "";
// 2.循环遍历数组
for (int i = 0; i < arr.length; i++) {
// 3.在循环中,获取数组的元素
int e = arr[i];
// 4.判断遍历出来的元素
if (i == 0) {
// 4.如果该元素是数组中第一个元素,那么拼接的格式: [+元素+逗号空格
str += "["+e+", ";
} else if (i == arr.length - 1) {
// 4.如果该元素是数组中最后一个元素,那么拼接的格式: 元素+]
str += e+"]";
} else {
// 4.如果该元素是数组的中间元素,那么拼接的格式: 元素+逗号空格
str += e + ", ";
}
}
// 5.返回拼接后的字符串对象
return str;
}
}
实操–1.11 字符串反转案例
需求
定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出反转后的结果
例如，键盘录入 abc，输出结果 cba
分析
- 键盘录入一个字符串，用 Scanner 实现
- 定义一个方法，实现字符串反转。返回值类型 String，参数 String s
- 在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
- 调用方法，用一个变量接收结果
- 输出结果
实现
public class Test {
public static void main(String[] args) {
/*
需求
定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出反转后的结果
例如，键盘录入 abc，输出结果 cba
*/
// 键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String str = sc.next();
// 调用reverse方法,打印结果
System.out.println(reverse(str));
}
public static String reverse(String str) {
// 1.创建一个空字符串对象
String newStr = "";
// 2.循环倒叙遍历传入的str字符串 abc
for (int i = str.length() - 1; i >= 0; i--) {
// 3.在循环中,获取遍历出来的字符
char c = str.charAt(i);
// 4.在循环中,拼接
newStr += c;
}
// 5.返回拼接后的字符串(反转后的字符串)
return newStr;
}
}
常用的方法：
concat(); //把两个字符串拼接起来，获取一个新的字符串
★length(); //获取字符串的长度(其实就是获取字符串中 字符的个数)
★equals(); //比较两个字符串的内容是否相同。 //区分大小写
equalsIgnoreCase(); //比较两个字符串的内容是否相同。 //忽略大小写
★charAt(); //根据给定的索引，获取对应位置的字符
★indexOf(); //获取指定的字符 在字符串中 第一次出现的位置(索引)，找不到返回-1
//int index = a1.indexOf('h'); 从头找，'h'第一次出现的位置
//int index = a1.indexOf('h',3); 从索引为3的元素开始往后找，'h'第一次出现的位置
lastIndexOf(); //获取指定的字符 在字符串中 最后一次出现的位置(索引)，找不到返回-1
//int index = a1.lastIndexOf('h'); 从尾部找，'h'最后一次出现的位置
//int index = a1.lastIndexOf('h',3); 从索引为3的元素开始往前找，'h'最后一次出现的位置
★substring(); //截取字符串，返回新的字符串
//String newStr = a1.substring(2); //从给定索引，直接截取到字符串末尾
//String newStr = a1.substring(2,5); //包左不包右(前闭后开), 能取索引2的元素，不能取索引5的元素
★isEmpty(); //判断字符串是否为空(长度为0返回true，不为0返回false)
★contains(); //判断字符串中是否包含 给定的字符串。
endsWith(); //判断字符串是否以 给定的字符串 结尾。
startsWith(); //判断字符串是否以 给定的字符串 开头。
★replace(); //用新内容替代旧内容，返回新的字符串
toLowerCase(); //把字母都转成其对应的小写形式。
toUpperCase(); //把字母都转成其对应的大写形式。
toCharArray() // 把字符串转换为数组
getBytes() // 把字符串转换为字节数组
★trim(); //移除首尾空格。
★split(); //根据给定的内容，切割字符串，返回字符串数组
public class Test {
public static void main(String[] args) {
/*
★boolean isEmpty(); 判断字符串是否为空字符串(长度为0返回true，不为0返回false)
★boolean contains(String str); 判断字符串中是否包含 给定的字符串。
boolean endsWith(String str); 判断字符串是否以 给定的字符串 结尾。
boolean startsWith(String str); 判断字符串是否以 给定的字符串 开头。
★String replace(String oldStr,String newStr); 用新内容替代旧内容，返回新的字符串
String toLowerCase(); 把字母都转成其对应的小写形式。
String toUpperCase(); 把字母都转成其对应的大写形式。
char[] toCharArray() 把字符串转换为数组
byte[] getBytes() 把字符串转换为字节数组
String trim(); 移除首尾空格。
String[] split(String str); 根据给定的内容，切割字符串，返回字符串数组
*/
// String replace(String oldStr,String newStr); 用新内容替代旧内容，返回新的字符串
String str = "hello-heima";
// 需求:把str中的heima换成itcast
String replaceStr = str.replace("heima", "itcast");
System.out.println("返回的字符串:"+replaceStr);// hello-itcast
System.out.println("原字符串:"+str);// hello-heima
// String toLowerCase(); 把字母都转成其对应的小写形式。
String str1 = "ABCaD";
// 需求:把str1中所有的字符都变成小写字母
System.out.println(str1.toLowerCase());// abcad
// String toUpperCase(); 把字母都转成其对应的大写形式。
// 需求:把str1中所有的字符都变成大写字母
System.out.println(str1.toUpperCase());// ABCAD
// char[] toCharArray() 把字符串转换为数组
// 需求:把str1转换为字符数组
char[] chs = str1.toCharArray();
for (int i = 0; i < chs.length; i++) {
System.out.print(chs[i]+" ");
}
System.out.println();
// byte[] getBytes() 把字符串转换为字节数组
// 需求:把str1转换为字节数组
byte[] bys = str1.getBytes();// 65,66,67,97,68
for (int i = 0; i < bys.length; i++) {
System.out.print(bys[i]+" ");
}
System.out.println();
// String trim(); 移除首尾空格。
String str2 = " admin ";
System.out.println(str2.trim()+"-----");
// String[] split(String str); 根据给定的内容，切割字符串，返回字符串数组
String str3 = "itheima-itcast-java-hello";
// 需求:以-对str3字符串进行分割
String[] arr = str3.split("-");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
System.out.println("===========了解,后面正则表达式================");
String str4 = "itheima.itcast.java.hello";
// 需求:以.对str4字符串进行分割
String[] split = str4.split("\\.");
System.out.println("split数组的长度:"+split.length);
for (int i = 0; i < split.length; i++) {
System.out.print(split[i]+" ");
}
}
private static void method01() {
// boolean isEmpty(); 判断字符串是否为空字符串(长度为0返回true，不为0返回false)
String str1 = null;// null表示什么都没有
String str2 = "";// ""表示空字符串对象
System.out.println(str2.isEmpty());// true
// boolean contains(String str); 判断字符串中是否包含 给定的字符串。
String str3 = "hello-world";
// 需求:判断str3字符串中是否包含world
System.out.println(str3.contains("world"));// true
// 需求:判断str3字符串中是否包含heima
System.out.println(str3.contains("heima"));// false
// boolean startsWith(String str); 判断字符串是否以 给定的字符串 开头。
String str4 = "itcast-itheima-java-world";
// 需求:判断str4字符串是否以it开头
System.out.println(str4.startsWith("it"));// true
// 需求:判断str4字符串是否以itcast开头
System.out.println(str4.startsWith("itcast"));// true
// 需求:判断str4字符串是否以itheima开头
System.out.println(str4.startsWith("itheima"));// false;
// boolean endsWith(String str); 判断字符串是否以 给定的字符串 结尾。
String fileName = "Person.java";
// 需求:判断fileName是否以.java结尾(判断文件是否是java文件)
System.out.println(fileName.endsWith(".java"));// true
}
}
扫一扫
299
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
