Java的常用类—String 类

Java的常用类—String 类

开发工具与关键技术：工具：myeclipse  技术： String 、StringBuffer、StringBuilder
作者：吴东梅
撰写时间：2019-06-16 

String类
String类是Java最常用的类之一。在Java中，通过程序中建立String类可以轻松地管理字符串，字符串对象一旦被初始化就不会被改变。什么是字符串呢？简单的说，字符串就是一个或多个字符组成的连续序列（如“How do you do!” “有志者事竟成”等）。程序需要存储的大量文字、字符都使用字符串进行表示、处理。
下面来一步步的了解String类如何应用吧。
一、String类常用构造器
（1）String() 初始化一个新创建的 String 对象，使其表示一个空字符序列。
（2）String(String original) 初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
（3）String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
如下图所示是上面三种方法的应用和执行的效果图：

（4）String(byte[] bytes, Charset charset) 通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。
（5）String(byte[] bytes, String charsetName) 通过使用指定的 charset 解码指定的byte 数组，构造一个新的 String。
（6）String(byte[] bytes, int offset, int length) 通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
如下所示，就是上面三种方法的应用和执行的结果：
代码：
System.out.println("----String(byte[] bytes, Charset charset)—");
byte[] bytes = new byte[] {-24, -65, -103, -26, -104, -81, -28, -72, -83, -26, -106, -121};
String str3 = new String(bytes,Charset.forName(“UTF-8”));
System.out.println(str3);
//这串byte数组是使用GBK编码生成的
byte[] bytes2 = new byte[]{-43, -30, -54, -57, -42, -48, -50, -60};
String str4 = new String(bytes2,Charset.forName(“GBK”));
System.out.println(str4);
System.out.println("—String(byte[] bytes, String charsetName)-");
try {
str4 = new String(bytes2,“GBK”);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
System.out.println(str4);
System.out.println(“String(byte[] bytes, int offset, int length)”);
String str5 = new String(bytes,0,6);//[0,6) //从bytes里面的那些数字里面拿出从索引为0(包括)到索引为6(不包括)的数字的中文。
System.out.println(str5);
效果：

（7）String(byte[] bytes, int offset, int length, Charset charset) 通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。
（8）String(byte[] bytes, int offset, int length, String charsetName) 通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。
（9）String(char[] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
（10）String(char[] value, int offset, int count) 分配一个新的 String，它包含取自字符数组参数一个子数组的字符。
如下所示，是上面方法的应用和执行后的效果图：
代码：
System.out.println("---------String(byte[] bytes, int offset, int length, Charset charset)------");
String str6 = new String(bytes,0,6,Charset.forName(“UTF-8”));
System.out.println(str6);
System.out.println("---------String(byte[] bytes, int offset, int length, String charsetName)------");
try {
str6 = new String(bytes,0,6,“UTF-8”);
System.out.println(str6);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
System.out.println("---------String(char[] value);String(char[] value, int offset, int count)------");
char[] cs = new char[]{‘a’,‘b’,‘c’,‘1’,‘2’,‘3’};
String str7 = new String(cs);//拼接
System.out.println(str7);
str7 = new String(cs,0,4); //[0,4) 从哪到哪截断，放的是索引。
System.out.println(str7);
效果 ：

二、String常用判断方法 （1）equals(Object obj):比较字符串的内容是否相同,区分大小写。
（2）equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写。
（3）contains(String str):判断大字符串中是否包含小字符串。
（4）startsWith(String str):判断字符串是否以某个指定的字符串开头。
（5）endsWith(String str):判断字符串是否以某个指定的字符串结尾。
如下所示，就是上面五种判断方法的应用和执行的结果：
代码：
String str1 = “abcd”;
String str2 = “Abcd”;
System.out.println("---------equals(Object obj)--------");
System.out.println(str1.equals(str2));
System.out.println("-------equalsIgnoreCase(String str)------");
System.out.println(str1.equalsIgnoreCase(str2));
System.out.println("---------contains(String str)--------");
System.out.println(str1.contains(“b”));//判断str1这个大字符串里面是否包含b这个小字符串。
System.out.println(str1.contains(“B”));
System.out.println("---------startsWith(String str)--------");
System.out.println(str1.startsWith(“A”)); //判断str1这个大字符串里面是否以“A”字符开头的。
System.out.println("---------endsWith(String str)--------");
System.out.println(str1.endsWith(“d”));
效果：

（6）isEmpty():判断字符串是否为空。
String str3 = “”;
String str4 = null;
System.out.println("---------isEmpty()----------");
System.out.println(str3.isEmpty());
//System.out.println(str4.isEmpty()); //java.lang.NullPointerException
//如果要判断String不为null或者""
System.out.println(stringNotNull(str4));
public static boolean stringNotNull(String str) {
if (str != null && !str.isEmpty()) {
return true;
}
return false;
}
效果图如下所示：

三、String类常用的获取方法
（1）length():获取字符串的长度。(空格也算)
（2）charAt(int index):获取指定索引位置的字符。
如下图所示，是上面获取方法的引用和执行的结果：

（3）indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
（4）indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引。
（5）indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
（6）indexOf(String str,int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
代码：返回-1,代表没有找到。
String str=“sadfghjkl65jhgfj jds256”;
System.out.println("---------indexOf(int ch)-----------");
System.out.println(str.indexOf(‘j’));
System.out.println("---------indexOf(String str)-----------");
System.out.println(str.indexOf(“jk”));
System.out.println("-------indexOf(int ch,int fromIndex)-------");
System.out.println(str.indexOf(‘j’,7));//从索引为7的位置开始找第一次出现j的索引。在索引小于7的前面找到的j不算。
System.out.println("—indexOf(String str,int fromIndex)------");
System.out.println(str.indexOf(“jk”,7));
效果图如下：

（7）lastIndexOf(int ch):返回指定字符在此字符串中最后一次出现处的索引。
（8）lastIndexOf(int ch,int fromIndex):返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
（9）lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引。
（10）lastIndexOf(String str,int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
代码：
System.out.println("---------lastIndexOf(int ch)-----------");
System.out.println(str.lastIndexOf(‘j’));
System.out.println("------lastIndexOf(int ch,int fromIndex)----");
System.out.println(str.lastIndexOf(‘j’,7));
System.out.println("---------lastIndexOf(String str)-----------");
System.out.println(str.lastIndexOf(“jk”));
System.out.println("—lastIndexOf(String str,int fromIndex)—");
System.out.println(str.lastIndexOf(“jk”,7));
效果图如下图所示：

（11）substring(int start):从指定位置开始截取字符串,默认到末尾。
（12）substring(int start,int end):从指定位置(包含)开始到指定位置(不包含)结束截取字符串。
代码：
System.out.println("---------substring(int start)-----------");
String str1 = str.substring(5);
System.out.println(str1);
String str2 = str.substring(5, 10); //[startindex,endindex)
System.out.println(str2);
效果图如下图所示：

四、String的常用转换方法
（1）getBytes():把字符串转换为字节数组。
代码：
System.out.println("-------getBytes()------------");
String str = “你好，世界！”;
byte[] bs;
try {
bs = str.getBytes();
System.out.print(“默认编码：”);
for (byte b : bs) {
System.out.print(b+",");
}
System.out.println();
bs = str.getBytes(“gbk”);
System.out.print(“gbk 编码：”);
for (byte b : bs) {
System.out.print(b+",");
}
System.out.print("\nutf-8 编码：");
bs = str.getBytes();
for (byte b : bs) {
System.out.print(b+",");
}
System.out.println();
String newStr = new String(bs);
System.out.println(newStr);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
效果图如下图所示：

（2）toCharArray():把字符串转换为字符数组。
（3）valueOf():把字符数组转成字符串。
代码：
System.out.println("---------toCharArray()-----------");
char[] arr = str.toCharArray();
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " “);
}
System.out.println();
System.out.println(”---------valueOf()-----------");
String str2 = String.valueOf(arr);
System.out.println(str2);
String str3 = String.valueOf(10);
System.out.println(str3);
效果图如下图所示：

（4）toLowerCase():把字符串转成小写。
（5）toUpperCase():把字符串转成大写。
（6）concat(String str):把字符串拼接。
代码：
String str4 = “abcDEFgh”;
System.out.println("---------toLowerCase()-----------");
System.out.println(str4.toLowerCase());
System.out.println("---------toUpperCase()-----------");
System.out.println(str4.toUpperCase());
System.out.println("-----concat-----");
String str5 = “abc”;
String str6 = “def”;
String str7 = str5.concat(str6);
System.out.println(str7);
五、String类其他常用方法
（1）replace(char old,char new):返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
（2）replace(String old,String new):使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
（3）trim() :返回字符串的副本，忽略前导空白和尾部空白。
代码：
System.out.println("-------replace(char old,char new)-------");
String str1 = “abcdefg”;
String str2 = str1.replace(‘z’, ‘o’); // 替换,返回替换后的字符串;如果没有被替换的字符,返回原字符串。
System.out.println(str2);
System.out.println("------replace(String old,String new)----");
String str3 = str1.replace(“fg”, “ooo”);
System.out.println(str3);
//trim() :返回字符串的副本，忽略前导空白和尾部空白。
System.out.println("-----------trim()----------");
String str4 = " abcdefg “;
String str5 = str4.trim(); // 去除前后空格
System.out.println(str5);
效果图如下所示：

（4）compareTo(String str) :按字典顺序比较两个字符串。
（5）compareToIgnoreCase(String str):按字典顺序比较两个字符串，不考虑大小写。
代码：
System.out.println(”-----------compareTo(String str)----------");
String str6 = “aaa”;
String str7 = “acc”;
int inta = str6.compareTo(str7); // 按照码表值比较两个字符串的大小
System.out.println(inta);
System.out.println("----compareToIgnoreCase(String str)–");
inta = str6.compareToIgnoreCase(str7);
System.out.println(inta);
效果图如下所示：

（6）split(String regex):根据给定正则表达式的匹配拆分此字符串。
（7）split(String regex,int limit):根据匹配给定的正则表达式来拆分此字符串。
如下所示：
代码：
/*
* 如果 n > 0，模式将被最多应用 n - 1 次，数组的长度将不会大于 n，而且数组的最后一项将包含所有超出最后匹配的定界符的输入
* 如果 n < 0，模式将被应用尽可能多的次数，数组可以是任何长度，并且结尾空字符串将保留。
* 如果 n = 0，模式将被应用尽可能多的次数，数组可以是任何长度，并且结尾空字符串将被丢弃。
*/
System.out.println("-----------split(String regex)----------");
String str8 = “asdgjkl;sadfg;fasdfg;rtscvb;rewe;d;;fg;hrew;5623;”;
String[] strings = str8.split(";");//默认为0
for (String string : strings) {
System.out.print("""+string+"",");
}
System.out.println();
System.out.println("------split(String regex,int limit)------");
String[] strings2 = str8.split(";", 2);
for (String string : strings2) {
System.out.print("""+string+"",");
}
执行结果：

六、String、StringBuffer和StringBuilder
Java中定义了String和StringBuffer两个类来封装对字符串的各种操作，它们都被放到了java.lang包中，import java.lang 是默认加载的，所以不需要显示的用“import java.lang”导入这个包。
String类用于比较两个字符串，查找和抽取串中的字符或子串，进行字符串与其他类型之间的相互转化等。String类对象的内容一旦被初始化就不能再改变，对于String类的每次改变（如字符串连接等）都会生成一个新的字符串，比较浪费内存。
StringBuffer类用于内容可以改变的字符串，可以被其他各种类型的数据增加、插入到字符串中，也可以转置字符串中原来的内容。一旦通过StringBuffer生成了最终想要的字符串，就应该使用StringBuffer.toString()方法将其转换成String类，随后，就可以使用String类的各种方法操纵这个字符串了。StringBuffer每次都改变其身，不生成新的对象，比较节约内存。

1、String 类对象不可变，一旦修改 String的值就是隐形的重建了一个新的对象，释放了原 String对象。
2、StringBuffer和StringBuilder类是可以通过append()、insert()、reverse()…等方法来修改值。创建的对象是可变。
3、StringBuffer：线程安全的； StringBuilder：线程非安全的。
4、字符串连接 String 的 + 比 StringBuffer(StringBuilder) 的 Append() 性能差了很多。
5、三者在执行速度方面的比较：StringBuilder > StringBuffer > String。

接下来我们就来了解一下StringBuffer和StringBuilder的简单的数据操作吧。
追加数据和插入数据的操作，如下图所示：

替换数据、删除数据和反转数据的操作如下图所示：
代码：
System.out.println("---------replace 替换-----");
sb.replace(5, 6, “,”); //sb = “hello,java” [5,6)的元素替换成“,”
System.out.println(sb.toString());
System.out.println("---------delete 删除-----");
sb.delete(5, 6); //sb = “hellojava” [5,6)
System.out.println(sb.toString());
System.out.println("---------reverse 反转-----");
sb.reverse(); sb=“avajolleh”
System.out.println(sb.toString());
效果图如下所示：

length 输出字符串的长度。
capacity() 输出 StringBuffer\StringBuilder的容量。
setLength 改变StringBuilder的长度，将只保留前面部分。
代码：
//字符串的长度跟容量一样之后，之后不管加了多少，都是一样的了。
System.out.println("----length----");
System.out.println(sb.length());
System.out.println("----capacity----");
System.out.println(sb.capacity());
System.out.println("----setLength----");
sb.setLength(21); //改变字符串的长度为21，就会自动截断21位长度的字符串，超出的将不会再输出。
System.out.println(sb.toString());
效果图如下所示：

String----> StringBuilder/StringBuffer或StringBuilder/StringBuffer-----> String之间的转换方式。
代码：
System.out.println("----------转换-----------");
//String----> StringBuilder/StringBuffer
String str = “111111”;
StringBuilder sb1 = new StringBuilder(str);
StringBuffer stringBuffer = new StringBuffer(str);
System.out.println(stringBuffer);
sb1.append(str);
//StringBuilder/StringBuffer-----> String
String newStr1 = sb1.toString();
newStr1 = stringBuffer.toString();
System.out.println(newStr1);
效果图如下：