第九章 Java常用类
9.1 字符串相关的类
9.1.1 String的特性
①.String类：代表字符串。Java 程序中的所有字符串字面值（如“abc”）都作为此类的实例实现。
②.String是一个final类，不可被继承，代表不可变的字符序列，不可变性。
体现：
当字符串重新赋值时，需要重写指定内存域赋值，不能使用原有的value赋值；
当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value赋值；
当调用String的replace( )方法修改指定字符或字符串时，也需要重新指定内存区域赋值。
③.字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。
④.String对象的字符内容是存储在一个字符数组value[]中的。
⑤.String实现了Serializable接口：表示字符串是支持序列化的；实现了Comparable接口：表示String可以比较大小。
⑥.通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串声明在字符串常量池中。
⑦.字符串常量池中是不会存储相同内容的字符串。
public class StringTest {
public static void main(String[] args) {
String string1 = "abc"; //字面量的定义方式
String string2 = "abc";
string1 = "hello";
System.out.println(string1 == string2);//比较string1与string2的地址值
System.out.println(string1);
System.out.println(string2);
/* 输出结果
* false
* hello
* abc
* */
}
}
9.1.2 String的两种实例化方式和区别
①.方式一：通过字面量定义的方式：此时的 string1 的数据在JavaEE声明在方法区的字符串常量池中。
String string1 = "abc"; //字面量的定义方式
②.方式二：通过new + 构造器的方式：此时的 string2 保存的地址值，是数据在堆空间中开辟空间以后对应的地址值
String string2 = new String("abc");//通过new + 构造器的方式
9.1.3 String不同拼接操作的对比
public class StringTest {
public static void main(String[] args) {
String string1 = "JavaEE";
String string2 = "hadoop";
String string3 = "JavaEEhadoop";
String string4 = "JavaEE" + "hadoop";
String string5 = string1 + "hadoop";
String string6 = "JavaEE" + string2;
String string7 = string1 + string2;
System.out.println(string3 == string4);//true
System.out.println(string3 == string5);//false
System.out.println(string3 == string6);//false
System.out.println(string5 == string6);//false
System.out.println(string5 == string7);//false
System.out.println(string6 == string7);//false
}
}
结论：常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量；只要其中有一个是变量，结果就在堆中；如果拼接的结果调用intern()方法，返回值就在常量池中。
9.1.4 String的使用练习实例
public class StringTest {
public static void main(String[] args) {
String string1 = "JavaEE";
String string2 = "JavaEE";
String string3 = new String("JavaEE");
String string4 = new String("JavaEE");
System.out.println(string1 == string2);//true
System.out.println(string1 == string3);//false
System.out.println(string1 == string4);//false
System.out.println(string3 == string4);//false
}
}
public class StringTest {
String str = new String("good");
char[] ch = {'t', 'e', 's', 't'};
public void change(String str, char ch[]) {
str = "test ok";
ch[0] = 'b';
}
public static void main(String[] args) {
StringTest ex = new StringTest();
ex.change(ex.str,ex.ch);
System.out.println(ex.str+"and");//goodand
System.out.println(ex.ch);//best
}
}
9.1.5 String的常用方法
import java.util.Locale;
public class StringTest {
public static void main(String[] args) {
String str1 = "abcdefg";
String str2 = "ABCDEFG";
String str3 = " ABCDEFG ";
//1.length()方法 返回字符串长度
System.out.println(str1.length()); //7
//2.charAt(int index)方法 返回某索引处的字符
System.out.println(str1.charAt(0)); //a
//3.isEmpty()方法 判断是否为空字符串
System.out.println(str1.isEmpty()); //false
//4.toLowerCase(Locale.ROOT)方法 使用默认语言环境，将字符全部转换为小写
System.out.println(str2.toLowerCase(Locale.ROOT)); //abcdefg
//5.toUpperCase(Locale.ROOT)方法 使用默认语言环境，将字符全部转换为大写
System.out.println(str1.toUpperCase(Locale.ROOT));//ABCDEFG
//7.equals()方法 比较字符串的内容是否相同
System.out.println(str1.equals(str2)); //false
//8.equalsIgnoreCase()方法 比较字符串的内容是否相同,忽略大小写
System.out.println(str1.equalsIgnoreCase(str2));//true
//9.concat()方法 将指定字符串连接到此字符串的结尾 等价于”+“
System.out.println(str1.concat(str2));//abcdefgABCDEFG
//10.compareTo()方法 比较两个字符串的大小 结果为正数前者大，负数后者大
System.out.println(str1.compareTo(str2));//32
//11.substring(beginIndex)方法 返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个字符串
System.out.println(str1.substring(1));//bcdefg
//12.substring(beginIndex,endIndex)方法 返回一个新的字符串，它是此字符串的从beginIndex开始截取到endIndex(不包含)的一个字符串
System.out.println(str1.substring(1,6));//bcdef
//13.去掉字符串的前导空白和尾导空白
System.out.println(str3.trim());//ABCDEFG
}
}
public class StringTest {
public static void main(String[] args) {
String str1 = "abcdefg";
String str2 = "ABCDEFG";
//1.endsWith()方法 测试字符串是否以指定后缀结尾
System.out.println(str1.endsWith("g"));//true
//2.startsWith(String prefix)方法 测试字符串是否以指定前缀开始
System.out.println(str1.startsWith("a"));//true
//3.startsWith(String prefix,int toffset)方法 测试此字符串从指定索引开始的子字符串是否以指定前缀开始
System.out.println(str1.startsWith("b",1));//true
//4.contains()方法 测试此字符串中是否包含指定的字符串
System.out.println(str1.contains("bcd"));//true
//5.indexOf()方法 返回指定字符串在此字符串中第一次出现的索引
System.out.println(str1.indexOf("c"));//2
//6.indexOf()方法 返回指定字符串在此字符串中第一次出现的索引，从指定的索引开始
System.out.println(str1.indexOf("c",1));//2
//7.replace(oldStr,newStr)方法 返回一个新字符串 它是通过用newStr替换此字符串中出现的所有oldStr
System.out.println(str1.replace("a","A"));
System.out.println(str1.replace(str1,"AABBCCDD"));
}
}
9.1.6 String与其它类型之间的转换
①.String与基本数据类型的转换
字符串转基本数据类型，包装类
Integer包装类的public static int parseInt(String s)：可以将由“数字”字符组成的字符串转换为整型。类似地，使用java.lang包中的Byte，Short，Long，Float，Double类调用相应的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型。
基本数据类型，包装类转字符串
调用String类的public String valueOf(int n)可将int型转换为字符串；相应的valueOf(byte b)，valueOf(float f)，valueOf(double d)，valueOf(boolean b)可由参数的相应类型到字符串的转换
②.String与字符数组的转换
字符数组转字符串
String类的构造器：String(char[])和String(char[],int offset,int length)分别用字符数组中的全部字符和部分字符创建字符串对象。
字符串转字符数组
public char[] toCharArray()：将字符串中的全部字符存放在一个字符数组中的方法。
public void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)：提供了将指定索引范围内的字符串存放到数组中的方法。
③.String与字节数组的转换
字节数组转字符串
String(byte[])：通过使用平台的默认字符集解码指定的byte数组，构造一个新的String
String(byte[],int offset,int length)：用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。
字符串转字节数组
public byte[] getBytes()：使用平台的默认字符集将此String编码为byte序列，并将结果存储到一个新的byte数组中。
public byte[] getBytes(String charsetName)：使用指定的字符集将此String编码到byte序列，并将结果存储到新的byte数组 。
import java.nio.charset.StandardCharsets;
public class StringTest {
public static void main(String[] args) {
//字符串转换为基本数据类型
String s = "123";
int num = Integer.parseInt(s);
System.out.println(num+1);
Integer sum = Integer.valueOf(s);
System.out.println(sum+1);
//字符串转换为字符数组
String a = "abcdefg";
char[] chars = a.toCharArray();
for (Object o:chars
) {
System.out.print(o+" ");
}
//字符串转换为字节数组
System.out.print("\n");
byte[] bytes = a.getBytes(StandardCharsets.UTF_8);
for (Object o:bytes
) {
System.out.print(o+" ");
}
}
}
9.1.7 常见的算法题目
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class StringTest {
public static void main(String[] args) {
//输入一个两端带有空格的字符串
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个两端带有空格的字符串：");
String string = scanner.next();
// 执行方法，打印输出
//练习一
System.out.println("去除两端空格后的字符串：" + removeSpa(string));
//练习二
System.out.println("反转后的字符串：" + reverSal(removeSpa(string)));
//练习三
System.out.print("请输入一个测试的字符串：");
String oldString = scanner.next();
System.out.print("请输入字符串：");
String newString = scanner.next();
System.out.println(showCount(oldString, newString));
}
//1.模拟一个trim方法，去除字符串两端的空格
public static String removeSpa(String str1) {
//2.将创建好的字符串转换为字节数组
byte[] bytes = str1.getBytes(StandardCharsets.UTF_8);
//3.判断字节数组的第一位（也就是字符串的前缀）是否为空格
if (bytes[0] == ' ') {
//4.如果是则将字符串从第二位打印出一个新的字符串
String substring1 = str1.substring(1);
//5.将新的字符串转换为字节数组
byte[] bytes1 = substring1.getBytes(StandardCharsets.UTF_8);
int i = bytes1.length - 1;
//6.判断字节数组的最后一位（也就是字符串的后缀）是否为空格
if (bytes1[i] == ' ') {
//7.如果是则将字符串从第一位到最后一位（不包括）打印赋值给最先的字符串
str1 = substring1.substring(0, i);
}
}
return str1;
}
//2.将一个字符串中的指定位置进行反转
public static String reverSal(String str1) {
//2.将一个字符串反转
char C = 'a';
char D = 'a';
char E = 'a';
char F = 'a';
char[] chars = str1.toCharArray();
int length = chars.length;
for (int i = 0; i < chars.length; i++) {
if (i == 2) {
C = chars[i];
} else if (i == 3) {
D = chars[i];
}else if (i == 4) {
E = chars[i];
}else if (i == 5) {
F = chars[i];
}
}
chars[2] = F;
chars[3] = E;
chars[4] = D;
chars[5] = C;
str1 = String.valueOf(chars);
return str1;
}
//3.获取一个字符串在另一个字符串中出现的数字
public static String showCount(String str1, String str2) {
int count = 0;
char[] chars = str2.toCharArray();
char aChar0 = chars[0];
char aChar1 = chars[1];
char[] chars1 = str1.toCharArray();
for (int i = 0; i < chars1.length; i++) {
if (chars1[i] == aChar0 && chars1[i + 1] == aChar1) {
count++;
}
}
return "字符串" + str2 + "出现次数为：" + count + "次";
}
}
9.1.8 字符串相关的类：StringBuffer类和StrungBulider类
StringBuffer类：
①.java.lang.StringBuffer代表可变的字符序列，JDK1.0中声明，可以对字符串内容进行增删，此时不会产生新的对象；很多方法与String相同；作为参数传递时，方法内部可以改变值。
②.StringBuffer类不同String，其对象必须使用构造器生成。
有三个构造器：
StringBuffer()：初始容量为16的字符串缓冲区
StringBuffer(int size)：构造指定容量的字符串缓冲区
StringBuffer(String str)：将内容初始化为指定字符串内容
③.StringBuffer类的常用方法：
StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end)：删除指定位置的内容
StringBuffer replace(int start,int end,String str)：把[ start,end)位置替换为str
StringBuffer insert(int offset,xxx)：在指定位置插入xxx
StringBuffer reverse()：把当前字符序列逆转
当append和insert时，如果原来value数组长度不够，可扩容。如上这些方法支持方法链操作。
④.StringBulider和StringBuffer非常类似，均代表可变的字符序列，而且提供相关功能的方法也一样。
⑤.String和StringBulider和StringBuffer的效率测试
