String类的概述和使用
String类的概念（重点）
-
java.lang.String类（引用数据类型，来自java.lang包，够浪，就不用导包，可以随便使用）用于描述字符串（char类型是用来描述单个字符的，把多个字符串起来就叫做字符串），Java程序中所有的字符串字面值（双引号引起来的固定的数值，和直接量很像，直接量是直接写出来的整数数据、小数数据，又叫字面值，又叫常量）都可以使用该类的对象加以描 述，如：“abc”（这个也可以叫直接量/字面值）。
-
该类由final关键字修饰，表示该类不能被继承（笔试考点）。
public final class String extends Object implements Serializable（序列化接口）, Comparable<String>（比较器器接口）, CharSequence（字符序列接口）=>实现多接口 String类表示字符串。 Java程序中的所有字符串文字（例如"abc" ）都实现为此类的实例。 说明只要是""引起来的字符串都可以使用String类加以描述。 String类中的成员变量：private final byte[] value; value修饰为final，而value里存放的是内存地址，说明value的指向不能改变。且一位数组的长度也不能改变。也就说明了字符串是个常量。 -
从jdk1.9开始该类的底层不使用char[]（2个字节）来存储数据，而是改成 byte[]（1个字节）加上编码标记，从而节约了一 些空间。
-
该类描述的字符串内容是个常量不可更改，因此可以被共享使用。 如：
String str1 = “abc”; - 其中"abc"这个字符串是个常量不可改变。
str1 = “123”; - 将“123”字符串的地址赋值给变量str1。
- 改变str1的指向并没有改变指向的内容
-
-
执行String str1的时候相当于在栈区中申请了一块内存空间，"abc"也得申请一块内存，abc由于是个常量，以前正常new对象的时候都是在堆区。但String类是个特例：他除了能new对象之外，还可以直接拿着字符串直接量赋值。而且字符串是个常量，不可改变。既然不可改变，abc会在内存空间的另一块区域：方法区中申请一块内存空间。然后，把abc放进去。既然申请了内存空间，在内存中肯定有地址。String str1 = “abc”;意思就是拿着abc在内存空间中的地址放到str1所在的栈区空间中。此时就相当于str1指向了abc。
-
当我们执行str1 = “123”;相当于又出现了一个字符串叫"123"，也就是我们又在方法区中申请了一块内存空间"123"。然后，拿着123的内存空间地址赋值给了str1。就相当于原先的线断开了。但是，abc本身并没有变，改变的是str1的指向而已。abc没有人指向了之后，Java虚拟机中的垃圾回收机制发现这个对象没人用了，就把这个对象回收掉，就把这个内存空间给它释放掉。
常量池的概念（原理）
由于String类型描述的字符串内容是常量不可改变，因此Java虚拟机将首次出现的字符串（因为它是不可变的且可以被共享）放入常量 池（在Java方法区中申请了一块内存空间）中，若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及创建对 象，从而提高了性能。
package com.huang.task02;
import java.util.Objects;
/**
* @author hhc19
* @date 2022/1/4 17:22
* @description
*/
public class StringPoolTest {
public static void main(String[] args) {
// 1、验证一下常量池的存在
// 到目前为止，只有String这个特殊类除了new的方式外还可以直接使用字符串字面量赋值（包装类除外）
String str1 = "abc";
String str2 = "abc";
// 说明了我们有常量池的存在, 直接使用字面量给字符串引用对象赋值如果常量池中有就直接从常量池中拿
System.out.println(str1 == str2); // true 比较地址 说明了我们有常量池的存在
String str3 = new String("abc");
String str4 = new String("abc");
// 说明new出来的对象还是在堆区空间中申请内存空间，而不是直接从常量池中拿
System.out.println(str1 == str3); // false
System.out.println(str3 == str4); // false
}
}
常用的构造方法（练熟、记住）
方法声明 功能介绍
String() 使用无参方式构造对象得到空字符序列
构造方法就是用来new对象的，new对象的同时自动调用构造方法对成员进行初始化
String(byte[] bytes, int offset, intlength) 使用bytes数组中下标从offset位置开始的length
个字节来构造对象
String(byte[] bytes) 使用bytes数组中的所有内容构造对象
String(char[] value, int offset, intcount) 使用value数组中下标从offset位置开始的
count个字符来构造对象
String(char[] value) 使用value数组中的所有内容构造对象
String(String original) 根据参数指定的字符串内容来构造对象，新创建对象
为参数对象的副本
练习代码：
package com.huang.task02;
/**
* @author hhc19
* @date 2022/1/4 17:41
* @description
*/
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个字节构造字符串对象
// 构造字符串的思路：就是先将每个整数 通过ASCII码值 翻译成对应的字符，再将所有的字符串起来。
// 98 - 'b' 99 - 'c' 100 - '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
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
}
}
笔试考点：使用字符串字面量构造对象和使用构造方法的区别
package com.huang.task02;
/**
* @author hhc19
* @date 2022/1/4 20:20
* @description
*/
public class StringExamTest {
public static void main(String[] args) {
// 1.请问下面的代码会创建几个对象？分别存放在什么地方？
//String str1 = "hello"; // 1个对象 存放在常量池中
//String str1 = new String("helo"); // 2个对象 1个在常量池中(双引号引起来的字符串字面量)，1个在堆区（new 出来的String对象）
// 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"; // 常量优化机制 "abcd"
System.out.println(str5 == str6); // 比较地址 true
String str7 = "ab";
String str8 = str7 + "cd"; // 没有常量优化 有一个是变量 + 只是起拼接，将变量的内容和字符串拼接起来
System.out.println(str5 == str8); // 比较地址 false
}
}
常用的成员方法（练熟、记住）
方法声明 功能介绍
String toString() 返回字符串本身
byte[] getBytes() 将当前字符串内容转换为byte数组并返回
char[] toCharArray() 用于将当前字符串内容转换为char数组并返回
练习代码：
package com.huang.task02;
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]);
/**
* 下标为i的元素是：119
* 下标为i的元素是：111
* 下标为i的元素是：114
* 下标为i的元素是：108
* 下标为i的元素是：100
*/
}
// 将byte数组转回String类型并打印
String str2 = new String(bArr); // 使用构造器来转
// String str2 = bArr.toString(); // [B@380fb434
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]);
}
/**
* 下标为0的字符是：w
* 下标为1的字符是：o
* 下标为2的字符是：r
* 下标为3的字符是：l
* 下标为4的字符是：d
*/
// 将char数组转回String类型并打印
String str3 = new String(cArr); // 直接用 char 数组作为构造方法的参数进行转换
System.out.println("转回字符串为：" + str3); // world
}
}
方法声明 功能介绍
char charAt(int index) 方法charAt用于返回字符串指定位置的字符。
int length() 返回字符串字符序列的长度
boolean isEmpty() 判断字符串是否为空
练习代码：
package com.huang.task02;
public class StringCharTest {
public static void main(String[] args) {
// 1.构造String类型的对象并打印
String str1 = new String("hello");
System.out.println("str1 = " + str1); // hello
// 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 字符串下标越界异常
System.out.println("----------------------------------------------");
// 3.使用for循环获取所有字符
for (int i = 0; i < str1.length(); i++) {
System.out.println("下标为" + i + "的字符是：" + str1.charAt(i)); // h e l l o
}
System.out.println("----------------------------------------------");
// 4.判断字符串是否为空
System.out.println(0 == str1.length()? "字符串为空": "字符串不为空"); // 不为空
System.out.println(str1.isEmpty()? "字符串为空": "字符串不为空"); // 不为空
/**
* String 中isEmpty()方法的源码：
* public boolean isEmpty() {
* return value.length == 0;
* }
*/
System.out.println("----------------------------------------------");
// 5.笔试考点
// 使用两种方式实现字符串"12345"转换为整数12345并打印
String str2 = new String("12345");
// 方式一：调用Integer类中的parseInt()方法即可
int ia = Integer.parseInt(str2);
System.out.println("转换出来的整数是：" + ia); // 12345
// 方式二：利用ASCII来实现类型转换并打印
// '1' - '0' => 1 '2' - '0' => 2 ...
// 字符之间的减法会得到数字
// '1' 的ASCII码：49 '0'的ASCII码：48
int ib = 0;
for (int i = 0; i < str2.length(); i++) {
ib = ib*10 + (str2.charAt(i) - '0'); // 1 12 ...
// 结论：当字符类型的数据进行加减乘除运算时，会将字符先转化为ASCII码对应的int数据再进行计算并得到一个int类型的数值
}
System.out.println("转换出来的结果是：" + ib); // 12345
System.out.println("----------------------------------------------");
// 如何实现整数到字符串的转换
//String str3 = String.valueOf(ib);
String str3 = "" + ib; // 推荐使用 字符串跟任意类型的数据拼接返回的结果都是字符串，当前字符串是个空字符串，相当于变相地把它转换成了一个字符串
System.out.println("str3 = " + str3); // 12345
}
}
结论：当字符类型的数据进行加减乘除运算时，会将字符先转化为ASCII码对应的int数据再进行计算并得到一个int类型的数值。当只输出 ‘1’ 时会打印对应的图案。字符之间的减法会得到数字。
案例题目：判断字符串“上海自来水来自海上”是否为回文并打印，所谓回文是指一个字符序列无论从左向右读 还是从右向左读都是相同的句子。
代码实现1--------------------------------------------------------------------
package com.huang.task02;
public class StringJudgeTest {
public static void main(String[] args) {
// 1.创建字符串对象并打印
String str1 = new String("上海自来水来自海上");
System.out.println("str1 = " + str1); // 上海自来水来自海上 9
// 2.判断该字符串内容是否为回文并打印
for (int i = 0; i < str1.length()/2; i++) {
if (str1.charAt(i) != str1.charAt(str1.length()-i-1)) { // 0和8 1和7 2和6 3和5
System.out.println(str1 + "不是回文！");
return; // 仅仅是用于实现方法的结束
// return; 的作用是返回数据并结束当前方法，但是此处不需要返回数据
}
}
System.out.println(str1 + "是回文！");
}
}
代码实现2------------------------------------------------------------------------------
package com.huang.task02;
/**
* @author hhc19
* @date 2022/1/4 21:33
* @description
*/
public class StringJudgeTest2 {
public static boolean stringJudge(String str) {
boolean flag = true;
// 二分法 + 标志法
for (int i = 0; i < (str.length()/2); i ++) {
if ((str.charAt(i) != str.charAt(str.length() - i - 1))) {
flag = false;
break;
}
}
return flag;
}
public static void main(String[] args) {
String str = new String("上海自来水来自海上");
if (StringJudgeTest2.stringJudge(str)) {
System.out.println("该字符串是回文！");
System.out.println(str);
} else {
System.out.println("该字符串不是回文！");
}
}
}
方法声明 功能介绍
int compareTo(String anotherString) 用于比较调用对象和参数对象的大小关系
int compareToIgnoreCase(String str) 不考虑大小写，也就是'a'和'A'是相等的关系
/**
* compareTo方法：
*
* 按字典顺序比较两个字符串。 比较基于字符串中每个字符的Unicode值。
* 此String对象表示的字符序列按字典顺序与参数字符串表示的字符序列进行比较。
* 如果此String对象按字典顺序排在参数字符串之前，则结果为负整数。
* 如果此String对象按字典顺序跟随参数字符串，则结果为正整数。
* 如果字符串相等，结果为零; compareTo在equals(Object)方法返回0完全返回true 。
*
*
* 这是词典排序的定义。
* 如果两个字符串不同，则它们在某个索引处具有不同的字符，这些字符串是两个字符串的有效索引，或者它们的长度不同，或者两者都有。
* 如果它们在一个或多个索引位置具有不同的字符，则令k为最小的索引; 然后，通过使用<运算符确定其位置k处的字符具有较小值的字符串，按字典顺序排在另一个字符串之前。
* 在这种情况下， compareTo返回两个字符串中位置k处两个字符值的k - 即值：
*
* this.charAt(k)-anotherString.charAt(k)
* 如果没有它们不同的索引位置，那么较短的字符串按字典顺序排在较长的字符串之前。 在这种情况下， compareTo返回字符串长度的差异 - 即值：
* this.length()-anotherString.length()
*
*/
总结：compareTo()是两个串对象比较大小,返回一个整数值,如果调用串对象大,返回正整数,反之,返回负整数。相等则返回0。返回的值是两个串首次出现不同字符的ASCII的差值。
大小关系：要么大于，要么等于，要么小于
负数小于，0等于，正数大于
案例题目：编程实现字符串之间大小的比较并打印。
package com.huang.task02;
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 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) 判断字符串是否以参数字符串结尾
CharSequence : 字符序列接口，回顾之前的回调模式。我们的形参列表中有接口类型对象有两种方式：1、传递一个子类类型的对象；2、使用匿名内部类；3、lambda表达式。此处的contains方法庆幸我们的String类实现了此接口。
案例题目：编程实现上述方法的使用。
package com.huang.task02;
public class StringManyMethodTest {
public static void main(String[] args) {
String str = "hello";
System.out.println(str.concat(", world!")); // hello, world!
// 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! 常量
// str1 从new出来就不可改变，因为它是一个常量，调用toUpperCae方法str1本身不会改变，相当于重写创建了一个字符串
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
}
}
方法声明 功能介绍
boolean equals(Object anObject) 用于比较字符串内容是否相等并返回
int hashCode() 获取调用对象的哈希码值（UniCode码）
重写equals方法就要重写hashCode方法, 这是Java官方的协定
boolean equalsIgnoreCase(StringanotherString) 用于比较字符串内容是否相等并返回，不考虑大小写，
如：'A'和'a'是相等
案例题目：提示用户从键盘输入用户名和密码信息，若输入”admin”和”123456”则提示“登录成功，欢迎使 用”，否则提示“用户名或密码错误，您还有n次机会”，若用户输入三次后依然错误则提示“账户已 冻结，请联系客服人员！”
package com.huang.task02;
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)) { // 把字符串字面量放前面是为了防止空指针异常
System.out.println("登录成功，欢迎使用！");
break;
} //else {
if (1 == i) {
System.out.println("账户已冻结，请联系客服人员！");
} else {
System.out.println("用户名或密码错误，您还有" + (i - 1) + "次机会！");
}
//}
}
// 关闭扫描器
sc.close();
}
}
搜索或查询功能的方法：
方法声明 功能介绍
int indexOf(int ch) 用于返回当前字符串中参数ch指定的字符第一次出现的下标
能找到就是0到它的长度 - 1 的有效位置，找不到就是负数，就是这个范围之外的
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位置开始反向搜索的第一次出现的下标。
案例题目：编写通用的代码可以查询字符串"Good Good Study, Day Day Up!"中所有"Day"出现的索引位置并 打印出来。
package com.huang.task02;
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');
/**
* int indexOf(int ch) 为什么参数是int类型，字符不应该使用char类型就够了吗？
* 这个char类型的范围扩展、字符编码的发展有关。
* 使用int类型，能把char类型的都描述出来。如果新增的、额外的突出的一些字符也可以描述。
* 所以用int类型
*/
System.out.println("pos = " + pos); // -1 代表查找失败 如果字符不存在返回-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 该字符第一次出现的索引位置
// 查找'G'下一次出现的位置
// 表示从下标1开始（包含1）查找字符 'G' 第一次出现的索引位置
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"出现的索引位置找到并打印出来
// 先找第一个，然后根据第一个的位置 + 1，再找下一个。如果没找到的话会返回-1
pos = str1.indexOf("Day");
while (-1 != pos) {
System.out.println("pos = " + pos); // 17
pos = str1.indexOf("Day", pos+1);
}
System.out.println("------------------------------------------------------");
// 优化一下 上方代码写了两次 indexOf 方法，代码重复啰嗦了
// 我们要写一遍而且能不断执行，只有写在循环条件中时才会一上来就直接执行
pos = 0;
while ((pos = str1.indexOf("Day", pos)) != -1) {
System.out.println("pos = " + pos);
// 跳过了ay的判断，因为Day本身占3个位置，代表了之后3个位置绝对不会出现Day
// 之后3个位置都是它自身所占的位置
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 substring(int beginIndex, int endIndex):返回字符串中从下标beginIndex（包括）开始到endIndex（不包括）结束的子字符串
String substring(int beginIndex):返回字符串中从下标beginIndex（包括）开始到字符串结尾的子字符串
在java中几乎所有的方法都是前面包含，后面不包含，如：Math.random() [0.0, 1.0)
案例题目：提示用户从键盘输入一个字符串和一个字符，输出该字符(不含)后面的所有子字符串
package com.huang.task02;
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开始获取子字符串（包含12）
String str2 = str1.substring(12);
System.out.println("str2 = " + str2); // Happy Life!
// 可以取到6但是取不到10 （不包含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);
}
}
