String类
一，String类
1. 概述
java.lang.String类，由final关键字修饰，表示该类不能被继承
该类用于描述 字符串 类型的对象，应用程序中所有的字符串字面值都可以使用该类 实例描述。
该类描述的字符串内容是一个常量，不可更改。
如：
String name = “James” ；
name = " Kobe "；
这是将name 这个引用 指向了 " Kobe " ， 而非 将 “James”这块内容进行了更改。 没有引用指向的 对象，叫做垃圾对象，等待GC回收
本质就是：修改的是 引用的指向地址，而不是修改了对象的内容
注意：
String str = " " ; --- 含义： 有字符串对象，只不过内容为空
String str = null ; --- 含义： 没有字符串对象
2.字符串常量池
为了提高字符串的使用效率，当程序中出现 字符串常量时，首先去到字符串常量池中进行查找，
若存在， 则直接从字符串常量池中返回该对象，
若不存在，则 创建对象并将对象放入常量池。
图解：
代码演示：
public class StringTest { public static void main(String[] args) { // 首次出现"alibaba"这个字符串常量时，去字符串常量池找，字符串常量池中肯定没有。 // 则自动创建这个 "alibaba" 对象。相当于 String s1 = new String("alibaba"); // 并且把 "alibaba"这个字符串放入 字符串常量池中 String s1 = "alibaba"; // 先去字符串常量池中找 "alibaba"这个字符串，找到了。 // 则无需创建对象，即 叫做 保持1个对象，而非创建1个对象 String s2 = "alibaba"; // 比较 s1 和 s2 的地址是否相等 System.out.println("s1 == s2 ------"+(s1 == s2)); // String类重写了equals()方法，用于比较对象的内容是否相等 // 比较 s1 和 s2 的内容是否相等 System.out.println("s1.equals(s2)------"+(s1.equals(s2))); System.out.println("----------------------------"); // 只要new，则创建新对象 // 新创建了一个 s3 对象 String s3 = new String("alibaba"); // 新创建了一个 s4 对象 String s4 = new String("alibaba"); // 比较 s3 和 s4 的地址是否相等 System.out.println(("s3 == s4 ------"+(s3 == s4))); // 比较 s3 和 s4 的内容是否相等 System.out.println("s3.equals(s4)------"+(s3.equals(s4))); } }
结果：
s1 == s2 ------true s1.equals(s2)------true ---------------------------- s3 == s4 ------false s3.equals(s4)------true
3.常用方法
1) 构造方法：
String( ) -使用无参的形式构造对象
String(byte[] bytes) -根据参数指定的 byte[ ] 数组来构造字符串对象
String(byte[] bytes, int offset, int length) -使用数组中的一部分来构造字符串对象
String(String original) -使用字符串字面值来构造字符串对象
String(StringBuffer buffer) -用于将StringBuffer类型 转换为 String 类型
String(StringBuilder builder) -用于将StringBuilder类型 转换为 String 类型
2) 普通方法 （很多）
代码演示：
public class StringMethodTest{ public static void main(String[] args) { // 使用构造方法String类型的对象 String s1 = new String("Hello"); // 使用 charAt()方法获取下标为1 位置的单个字符，并打印出来 char c1 = s1.charAt(1); System.out.println(c1); System.out.println("---------------------"); // 使用for 循环，打印字符串中的每个字符 System.out.println("使用for 循环，打印字符串中的每个字符:"); for(int i=0;i<s1.length();i++) { System.out.println(" "+s1.charAt(i)); } System.out.println(); String s2 = new String("123456"); // 将该字符串中的所有的字符转换成 整数 "123456" --> 123456 // 方式1 int res = Integer.parseInt(s2); System.out.println("---------------------"); System.out.println("方式一："+res); System.out.println("---------------------"); // 方式2 拼接 res=0; for(int i=0;i<s2.length();i++) { res=res*10+(s2.charAt(i)-'0'); // res = 1; res = 12; res = 123; .... } System.out.println("方式二："+res); System.out.println("---------------------"); } }
结果：
e --------------------- 使用for 循环，打印字符串中的每个字符: H e l l o --------------------- 方式一：123456 --------------------- 方式二：123456 ---------------------
代码演示：
package com.monkey1036; public class StringManyMethodTest { public static void main(String[] args) { String s1 = new String("Good Good Study, Day Day Up! "); // 操作1：判断该字符串中是否包含 "Study" boolean b = s1.contains("Study"); System.out.println("1:该字符串中是否包含 \"Study\""+" ---"+b); System.out.println( ); // 操作2：判断该字符串中是否包含 "day" b = s1.contains("day"); System.out.println("2:字符串中是否包含 \"day\""+"---"+b); System.out.println( ); // 操作3：判断是否以"Good"开头 b = s1.startsWith("Good"); System.out.println("3:是否以\"Good\"开头"+"---"+b); System.out.println( ); // 操作4：判断是否以"Up!"结尾 b = s1.endsWith("Up!"); System.out.println("4:是否以\"Up!\"结尾 "+"---"+b); System.out.println( ); // 操作5：将所有字符串转换为大写 String str = s1.toUpperCase(); System.out.println("5:将所有字符串转换为大写"+"---"+str); System.out.println(" "); // 操作6：将所有字符串转换为小写 str = s1.toLowerCase(); System.out.println("6:将所有字符串转换为小写"+"---"+str); System.out.println( ); // 操作7：去除字符串两边的空白字符 str = s1.trim(); System.out.println("7:去除字符串两边的空白字符"+"---"+str); System.out.println( ); // 操作8：将字符串转换为byte[]数组 byte[] bytes = s1.getBytes(); System.out.println("8:将字符串转换为byte[]数组"+"---"+bytes); System.out.println( ); // 操作9：打印byte数组中的每一个字节的数值，得到每个字符的ASCII System.out.println("9:打印byte数组中的每一个字节的数值，得到每个字符的ASCII码："); for(int i=0;i<bytes.length;i++) { System.out.print(" "+bytes[i]); } System.out.println(); System.out.println(); // 操作10：查找单个字符第一次出现的索引位置 'O' int res = s1.indexOf('O'); System.out.println("10:查找单个字符第一次出现的索引位置 'O'"+"---"+res); System.out.println( ); // 操作11：查找单个字符第一次出现的索引位置 'o' res = s1.indexOf('o'); System.out.println("11:查找单个字符第一次出现的索引位置 'o'"+"---"+res); System.out.println( ); // 操作12：查找单个字符第一次出现的索引位置 'o',从下标为1的位置找 (包括3) res = s1.indexOf('o',1); System.out.println("12:查找单个字符第一次出现的索引位置 'o',从下标为1的位置找 (包括3)"+"---"+res); System.out.println( ); // 操作13：查找单个字符第一次出现的索引位置 'o',从下标为3的位置找 res = s1.indexOf('o',3); System.out.println("13:查找单个字符第一次出现的索引位置 'o',从下标为3的位置找"+"---"+res); System.out.println( ); // 操作14：查找字符串 "day" 第一次出现的索引位置，并打印出来 res = s1.indexOf("day"); System.out.println("14:查找字符串 \"day\" 第一次出现的索引位置，并打印出来"+"---"+res); System.out.println( ); // 操作15：查找字符串 "Day" 第一次出现的索引位置，并打印出来 res = s1.indexOf("Day"); System.out.println("15:查找字符串 \"Day\" 第一次出现的索引位置，并打印出来"+"---"+res); System.out.println( ); // 操作16：查找字符串 "Day" 第一次出现的索引位置，从下标为17的位置找,并打印出来 res = s1.indexOf("Day",17); System.out.println("16:查找字符串 \"Day\" 第一次出现的索引位置，从下标为17的位置找,并打印出来"+"---"+res); System.out.println( ); // 操作17：查找字符串 "Day" 第一次出现的索引位置，从下标为18的位置找,并打印出来 res = s1.indexOf("Day",18); System.out.println("17:查找字符串 \"Day\" 第一次出现的索引位置，从下标为18的位置找,并打印出来"+"---"+res); System.out.println( ); // 操作18： 编程实现"Day" 在整个字符串中出现的所有索引位置，打印出来 System.out.println("18:编程实现\"Day\" 在整个字符串中出现的所有索引位置，打印出来:"); int index = s1.indexOf("Day"); // 查找"Day" 第一次出现的索引位置 while(index != -1){ System.out.print(" "+index ); // 打印第一次出现的索引位置 System.out.println( ); // 继续查找下一次出现的位置 index = s1.indexOf("Day", index+3); // +3 因为 "Day"本身占3个字节 } // 操作19：查找字符 "Y" 最后一次出现的索引位置 res = s1.lastIndexOf('Y'); System.out.println("19:查找字符 \"Y\" 最后一次出现的索引位置"+"---"+res); System.out.println(); // 操作20：查找字符 "y" 最后一次出现的索引位置 res = s1.lastIndexOf('y'); System.out.println("20:查找字符 \"y\" 最后一次出现的索引位置"+"---"+res); System.out.println( ); // 操作21：查找字符 "y" 最后一次出现的索引位置,从下标为23的位置开始找 res = s1.lastIndexOf('y',23); System.out.println("21:查找字符 \"y\" 最后一次出现的索引位置,从下标为23的位置开始找"+"---"+res); System.out.println( ); // 操作22：查找字符 "y" 最后一次出现的索引位置,从下标为22的位置开始 反向查找 res = s1.lastIndexOf('y',22); System.out.println("22:查找字符 \"y\" 最后一次出现的索引位置,从下标为22的位置开始 反向查找"+"---"+res); System.out.println( ); // 操作23：查找字符 "day" 最后一次出现的索引位置 res = s1.lastIndexOf("day"); System.out.println("23:查找字符 \"day\" 最后一次出现的索引位置"+"---"+res); System.out.println( ); // 操作24：查找字符 "Day" 最后一次出现的索引位置 res = s1.lastIndexOf("Day"); System.out.println("24:查找字符 \"Day\" 最后一次出现的索引位置"+"---"+res); System.out.println( ); // 操作25：查找字符 "Day" 最后一次出现的索引位置,从下标为21的位置开始查 res = s1.lastIndexOf("Day",21); System.out.println("25:查找字符 \"Day\" 最后一次出现的索引位置,从下标为21的位置开始查"+"---"+res); System.out.println( ); // 操作26：查找字符 "Day" 最后一次出现的索引位置,从下标为20的位置开始 反向查找 res = s1.lastIndexOf("Day",20); System.out.println("26:查找字符 \"Day\" 最后一次出现的索引位置,从下标为20的位置开始 反向查找"+"---"+res); System.out.println( ); } }
结果：
1:该字符串中是否包含 "Study" ---true
2:字符串中是否包含 "day"---false
3:是否以"Good"开头---true
4:是否以"Up!"结尾 ---false
5:将所有字符串转换为大写---GOOD GOOD STUDY, DAY DAY UP!
6:将所有字符串转换为小写---good good study, day day up!
7:去除字符串两边的空白字符---Good Good Study, Day Day Up!
8:将字符串转换为byte[]数组---[B@7852e922
9:打印byte数组中的每一个字节的数值，得到每个字符的ASCII码：
71 111 111 100 32 71 111 111 100 32 83 116 117 100 121 44 32 68 97 121 32 68 97 121 32 85 112 33 32 32 32 32 32 32
10:查找单个字符第一次出现的索引位置 'O'----1
11:查找单个字符第一次出现的索引位置 'o'---1
12:查找单个字符第一次出现的索引位置 'o',从下标为1的位置找 (包括3)---1
13:查找单个字符第一次出现的索引位置 'o',从下标为3的位置找---6
14:查找字符串 "day" 第一次出现的索引位置，并打印出来----1
15:查找字符串 "Day" 第一次出现的索引位置，并打印出来---17
16:查找字符串 "Day" 第一次出现的索引位置，从下标为17的位置找,并打印出来---17
17:查找字符串 "Day" 第一次出现的索引位置，从下标为18的位置找,并打印出来---21
18:编程实现"Day" 在整个字符串中出现的所有索引位置，打印出来:
17
21
19:查找字符 "Y" 最后一次出现的索引位置----1
20:查找字符 "y" 最后一次出现的索引位置---23
21:查找字符 "y" 最后一次出现的索引位置,从下标为23的位置开始找---23
22:查找字符 "y" 最后一次出现的索引位置,从下标为22的位置开始 反向查找---19
23:查找字符 "day" 最后一次出现的索引位置----1
24:查找字符 "Day" 最后一次出现的索引位置---21
25:查找字符 "Day" 最后一次出现的索引位置,从下标为21的位置开始查---21
26:查找字符 "Day" 最后一次出现的索引位置,从下标为20的位置开始 反向查找---17
方法：
String SubString(int beginIndex) -用于获取当前字符串中从 beginIndex位置（包括）开始，一直到该字符串结尾的子串。
String SubString(int beginIndex, int endIndex) -用于获取当前字符串中从 [ beginIndex, endIndex) 位置之间的子串。
代码：
package com.monkey1038; public class StringSubStringTest { public static void main(String[] args) { // 创建一个String类型的字符串 "GoodMorning!" String s = new String("GoodMorning!"); System.out.println("打印s： "+s); System.out.println(); // 获取字符串中 从下标为 6 开始的子串 String s2 = s.substring(+6); System.out.println("获取字符串中 从下标为 6 开始的子串: "+s2); System.out.println(); // 获取字符串从下标6(包括)开始，到下标10的位置(不包括)之间的子串 s2=s.substring(6, 10); System.out.println("获取字符串[6,10)区间的子串： "+s2); } }
结果：
打印s： GoodMorning! 获取字符串中 从下标为 6 开始的子串: rning! 获取字符串从下标6(包括)开始，到下标10的位置(不包括)之间的子串rnin
比较两个字符串的大小：
int compareTo(String anotherString) - 比较调用字符串 和 参数字符串的大小
若调用字符串 比较大 则 返回 正数
若调用字符串 比较大 则 返回 负数
若 两者相等 则 返回 0
比较规则：先比较相同索引位置的单个字符ASCII码，再比较长度确定大小
案例： 比较 字符串 "helloworld" 和 字符串"hellochina" 谁大？
h e l l o w o r l d
h e l l o c h i n a
执行： 先比较下标为0的字符，也就是 'h' ;
发现 'h' 是相等的，则比较下一个位置的字符.......
直到 'w' 和 'c' 做比较，w的ASCII码值大于c的ASCII码值。
因此 字符串 "helloworld" 更大
案例：
要求不断提示用户输入字符串，并且接收输入的字符串
当用户输入的是"bye" （不区分大小写），则结束输入，否则打印输入的内容
package com.monkey1036;
import java.util.Scanner;
/* 要求：不断提示用户输入 字符串，并接收
* 当用户输入的是 "bye"时，结束输入
* 否则 打印输出的内容
*
* */
public class StringEqualsTest{
public static void main(String[] args) {
// 不断地提示用户输入字符串并接收
Scanner sc = new Scanner(System.in);
while(true) {
System.out.println("请输入要发送的内容：");
String str = sc.next(); // 接收键盘输入的内容
System.out.println(str);
// 判断用户输入的内容是否为 "bye"，若是 则结束输入，否则打印键盘输入内容
// 将此 String 与另一个 String 比较，不考虑大小写
if("bye".equalsIgnoreCase(str))break;
}
}
}
