Java常用类库之String

Java常用类库之String学习与积累

概述

在学习Java时，我们知道Java的基本数据类型有整型的int，byte，short，long，字符型的char，布尔型的Boolean和浮点型的float、double，String虽然不是基本数据类型，但是我们在使用Java的时候，经常会用到String字符串，String是Java中一个重要的常用类库，任何一个字符串都是String类的实例，String类的对象。

---

JDK解释：

JDK中对String的介绍中，我们可以发现有这么一句话（如图红色部分）

为什么“String的对象是不可变的”，所以就可以共享它呢？这里便涉及到String的一些实现原理。

首先我们知道，字符串是不变的，它们的值在创建后无法更改，这是因为在字符串内部，是使用一个char数组来表示这个字符串的，比如

String str = "abc";
//相当于
char[] ch = ('a','b','c');

由数组的特性，数组的长度一旦确定，则无法更改，因此字符串是不变的；

其次，为什么字符串是不变的，就可以共享他们呢？假设现在有两个String类型的变量如下：

String s1 = "abc";
String s2 = "abc";

那么s1和s2在创建完成后是永远不变的，也就是永远相等

因为这样一个特性，Java设置了这样一个想法：如果两个字符串内容完全相同，那么它们则采用同一个内存地址，也即s1和s2的指针均指向同一个内存，如下图：

我们可以测试如下：

public class Demo3 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);
    }
}

运行结果如下：

也就是说，在两个字符串完全相同的情况下，他们是共享内存空间的，每个字符串对象的创建都会放到堆内存的永久代中，作为一个常量存在，因此，下次创建字符串时，JVM会先去永久代中寻找有没有相同的字符串，如果有就仅仅返回地址值，如果没有则创建新的字符串对象。

---

注意，如果是采用new关键字类进行字符串对象的创建，则JVM会直接创建一个新的内存空间，而不会去寻找是否有相同的字符串，因为new关键字的作用就是开辟一块新的空间。

演示如下：

public class Demo4 {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");
        System.out.println(s1 == s2);
    }
}

结果为false，如下：

String常用构造方法：

一般我们是直接定义即可（99%情况下均采用该方式）：

String str = "123";

其他三个较常用的构造方法：

​ String(byte[] bytes)——通过使用平台的默认字符集解码指定的字节数组构造新的String。

​ String(char[] value)——分配新的String，使其表示当前包含在字符数组参数中的字符序列。

​ String(byte[] bytes,String charsetName)——构造一个新的String，由指定的字节数组解码charset；

String的常用方法

​ charAt(int index)——返回指定索引处的char值

String s1 = "ahfgianri";
char c = s1.charAt(4);
System.out.println(c);

//输出结果：
i

---

​ compareTo(String another String)

​ compareToIgnoreCase(String str)

​ 这两个方法都是按照字典顺序，逐个比较两个字符串相同索引的字符，不同之处在于一个区分大小写，一个不区分大小写。但都返回int类型的值。

​ 所谓按照字典顺序比较，是指基于字符串中每个字符的Unicode值进行比较。比较该String对象与参数字符串对象表示的字符序列差异。

​ 依照字典顺序，如果该String对象的顺序在参数字符串之前，则结果为负整数；如果该String对象在字典上的顺序在参数字符串之后，则结果为正整数；如果字符串相等，则结果为零。
​ 字典顺序的定义：如果两个字符串不同，那么它们要么在某个索引处具有不同的字符（该索引应该在两个字符串的有效索引内），要么它们的长度不同，或者两者都不同。如果它们在一个或多个索引位置具有不同的字符，则令k为最小索引；假设在索引k处，两个字符串不同，则将两个字符串索引k处的字符的Unicode值进行相减，所得的差即为返回的int值：

String s1 = "asdfghjkl" ;
String s2 = "asDggg";
int i1 = s1.compareTo(s2);
int i2 = s1.compareToIgnoreCase(s2);
System.out.println(i1);
System.out.println(i2);

//输出结果：
32
-1

---

​ concat(String str)——将指定字符串拼接到该字符串末尾

String a="a";
String b="b";
String c= a.concat(b);

---

​ contains(CharSequence a)——当且仅当该字符串包含指定的char值虚列，返回true

String s1 = "asdfghjkl" ;
boolean asd = s1.contains("asd");
System.out.println(asd);

//输出结果：
true

---

​ copyValueOf(char[] data)——返回指定数组中表示该字符序列的字符串。

​ copyValueOf(char[] data,int offset,int count)——返回指定数组中指定字符序列（从索引offset开始，长度为count）的字符串。

 char[] c = {'a','b','c','d','e','f','a','b','c','d','e','f'};
String s3 = "";
String s4 = "";
s3 = s3.copyValueOf(c);
s4 = s4.copyValueOf(c,2,5);
System.out.println(s3);
System.out.println(s4);

//输出结果：
abcdefabcdef
cdefa

---

​ startsWith(String prefix) ——测试此字符串是否以指定的前缀开头。

​ startsWith(String prefix, int toffset) ——测试从指定索引开始的此字符串的子字符串是否以指定的前缀开头。

​ endsWith(String suffix)——测试该字符串是否以指定字符序列结尾

String s = "qwertyuiop";
Boolean flag1 = s.startsWith("qw");
Boolean flag2 = s.endsWith("o");
Boolean flag3 = s.startsWith("rty",3);
System.out.println(flag1);
System.out.println(flag2);
System.out.println(flag3);

//输出结果：
true
false
true

---

​ equals（Object anObject)——与Object对象比较

​ equalsIngnoreCase(String anotherString)——与另一个String变量对比（忽略大小写）

String s = "abc";
Boolean b1 = s.equals("Abc");
Boolean b2 =s.equalsIgnoreCase("Abc");
System.out.println(b1);
System.out.println(b2);

//输出结果：
false
true

---

​ format(String format, Object… args)——使用指定的格式字符串和参数返回格式化字符串。

​ format(Locale l, String format, Object… args)——使用指定的语言环境，格式字符串和参数返回格式化的字符串。

这两个方法的解析可以参见该推文：https://www.cnblogs.com/travellife/p/Java-zi-fu-chuan-ge-shi-hua-xiang-jie.html

---

​ hashCode() ——返回此字符串的哈希码。

String s = "abc";
int i = s.hashCode();
System.out.println(i);

//输出结果：
96354

---

​ indexOf(int ch) ——返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1；这个时候细心的人会发现，这个查找指定字符的indexOf方法传入的参数是int类型，而不是char类型，相关的简介可以参照该博客的解释： https://blog.csdn.net/qq_34579060/article/details/79067965

​ indexOf(int ch, int fromIndex)—— 返回指定字符第一次出现的此字符串中的索引，从指定索引处开始搜索，如果此字符串中没有这样的字符，则返回 -1。

​ indexOf(String str) ——返回指定子字符串第一次出现的字符串中的索引，如果此字符串中没有这样的字符，则返回 -1。

​ indexOf(String str, int fromIndex) ——从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引，如果此字符串中没有这样的字符，则返回 -1。

​ lastIndexOf(int ch)—— 返回指定字符最后一次出现的字符串中的索引，如果此字符串中没有这样的字符，则返回 -1。

​ lastIndexOf(int ch, int fromIndex) ——返回指定字符最后一次出现的字符串中的索引，从指定的索引开始向后搜索，如果此字符串中没有这样的字符，则返回 -1。

​ lastIndexOf(String str)—— 返回指定子字符串最后一次出现的字符串中的索引，如果此字符串中没有这样的字符，则返回 -1。

​ lastIndexOf(String str, int fromIndex)—— 返回指定子字符串最后一次出现的字符串中的索引，从指定索引开始向后搜索，如果此字符串中没有这样的字符，则返回 -1。

---

​ isBlank() ——如果字符串为空或仅包含 white space（空格）代码点，则返回 true ，否则 false 。

​ isEmpty()—— 当且仅当字符串的长度length()为0时返回 true 。

String s = "";
String ss = "       ";
Boolean b = s.isBlank();
Boolean bb = s.isEmpty();
Boolean bbb = ss.isBlank();
Boolean bbbb = ss.isEmpty();
System.out.println(b);
System.out.println(bb);
System.out.println(bbb);
System.out.println(bbbb);

//输出结果：
true
true
true
false

---

​ length()—— 返回此字符串的长度。

String s = "rfe348345fh rjrehturih";
System.out.println(s.length());
        
//输出结果：
22    

---

​ matches(String regex) ——判断此字符串是否与给定的 正则表达式匹配，匹配返回true，否则返回false。

String Str = new String("www.google.com");

System.out.print("返回值 :" );
System.out.println(Str.matches("(.*)google(.*)"));

System.out.print("返回值 :" );
System.out.println(Str.matches("(.*)baidu(.*)"));

System.out.print("返回值 :" );
System.out.println(Str.matches("www(.*)"));

//输出结果：
返回值 :true
返回值 :false
返回值 :true

---

​ repeat(int count)—— 将调用该方法的字符串重复多次，重复的次数为指定的count。

​ 注意，如果count为正数，则返回重复后的结果；如果count为零，则最终结果为一个空的，长度为0 的字符串，如下：

 String ss = "qwer";
 String r1 = ss.repeat(3);
 System.out.println(r1);
 String r2 = ss.repeat(0);
 System.out.println("这里有一个字符串"+r2+"这里有一个字符串");
 int l = r2.length();
 System.out.println("r2的长度为："+l);
 
 //输出结果：
qwerqwerqwer
这里有一个字符串这里有一个字符串
r2的长度为：0

​ 如果count为负数，则抛出异常IllegalArgumentException，如下：

String ss = "qwer";
String repeat = ss.repeat(0);
System.out.println(repeat);

//抛出异常：
Exception in thread "main" java.lang.IllegalArgumentException: count is negative: -3

---

​ replace(char oldChar, char newChar)—— 返回一个字符串，该字符串为将原字符串中某些字符以另外指定的字符替代的新字符串。

 String ss = "qwer";
 String replace = ss.replace('e', 'c');
 System.out.println(replace);

//输出结果：
qwcr

​ replace(CharSequence target, CharSequence replacement) ——将此字符串中与文字目标序列匹配的每个子字符串全部替换为指定的文字替换序列(也就是说replace方法也可以传入CharSequence类型的参数)。

String s = "aaabhygfaaaffaaa";
CharSequence cs1 = "aaa";
CharSequence cs2 = "bbb";
String r1 = s.replace(cs1, cs2);
System.out.println(r1);

 //输出结果：
bbbbhygfbbbffbbb

​ replaceAll(String regex, String replacement)—— 返回一个字符串，该字符串为将原字符串中某些字符（也可以是正则表达式）以另外指定的全部字符替代的新字符串。

​ replaceFirst(String regex, String replacement) ——返回一个字符串，该字符串为将原字符串中某些字符（也可以是正则表达式）以另外指定的第一个字符替代的新字符串。

String s = "aaa.bbb.aaa.vvv";

String ss = s.replaceAll("aaa", "hhh");
System.out.println(ss);

String sss = s.replaceFirst("aaa", "nnn");
System.out.println(sss);

//输出结果：
hhh.bbb.hhh.vvv
nnn.bbb.aaa.vvv

---

​ split(String regex) ——根据匹配给定的正则表达式来拆分此字符串。

String s = "aaa.bbb.aaa|vvv|ccc";
String[] split = s.split("\\.|\\|");
for (String sp:split) {
	System.out.println(sp);
}

//输出结果：
aaa
bbb
aaa
vvv
ccc

/*注意：由于“."和”|“都是转义字符，为了让JVM能够正确识别，需要加\\
 *因此该例子中的条件"\\.|\\|"是指按照“."或者”|“进行字符串分割
 */

​ split(String regex, int limit) ——根据匹配给定的正则表达式来拆分此字符串，limit是指指定将该字符串分为几部分。

String s = "aaa.bbb.aaa|vvv|ccc";
String[] split2 = s.split("\\.|\\|",3);
for (String sp:split2) {
	System.out.println(sp);
}

//输出结果：
aaa
bbb
aaa|vvv|ccc

---

​ strip() ——返回该字符串，并删除了所有前导和尾随的空格；

​ stripLeading() ——返回该字符串，并删除了所有前导的空格；

​ stripTrailing() ——返回该字符串，并删除所有尾随的空格。

String s = " aa  bb cc   ";
String s1 = s.strip();
String s2 = s.stripLeading();
String s3 = s.stripTrailing();
System.out.println("前缀"+s1+"后缀");
System.out.println("前缀"+s2+"后缀");
System.out.println("前缀"+s3+"后缀");

//输出结果：
前缀aa  bb cc后缀
前缀aa  bb cc   后缀
前缀 aa  bb cc后缀

​ trim() ——截取字符串中间的非空白字符，并且查看源码，其内部调用了subString()方法,详细解析可以参见博客：https://blog.csdn.net/leeqihe/article/details/81006611?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522160629227819195283067794%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=160629227819195283067794&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_click~default-2-81006611.first_rank_ecpm_v3_pc_rank_v2&utm_term=trim&spm=1018.2118.3001.4449

String str = "  www.google.com  ";
str = str.trim();
System.out.println(str);

//输出结果：
www.google.com

---

​ subSequence(int beginIndex, int endIndex)——将字符串从beginindex（包含）开始截取到endindex（不包含）。

​ substring(int beginIndex) ——将字符串从beginindex（包含）开始截取。

​ substring(int beginIndex, int endIndex)—— 将字符串从beginindex（包含）开始截取到endindex（不包含）。

String str = "abcdefg";
CharSequence c = str.subSequence(3, 5);
String ss = str.substring(1, 4);
String sss = str.substring(2);
System.out.println(c);
System.out.println(ss);
System.out.println(sss);

//输出结果：
de
bcd
cdefg

---

​ toCharArray() ——将此字符串转换为新的字符数组。

String str = "abcdefg";
char[] chars = str.toCharArray();
for (char cha:chars) {
	System.out.print(cha+"--");
}

//输出结果：
a--b--c--d--e--f--g--

---

​ toLowerCase() ——使用默认语言环境的规则将此 String所有字符转换为小写。

​ toUpperCase() ——使用默认语言环境的规则将此 String所有字符转换为大写。

​ 这两个方法均可以指定语言环境。

 String st = "ADfgFfgG";
 String st1 = st.toLowerCase();
 String st2 = st.toUpperCase();
 System.out.println(st1);
 System.out.println(st2);
 
 //输出结果：
 adfgffgg
 ADFGFFGG

---

​ valueOf() 是String的静态方法，可以直接调用，它的作用是将别的类型的参数以字符串形式进行展示，有以下几种类型：

//static valueOf(boolean b) ——返回 boolean参数的字符串表示形式。 

//static valueOf(char c) ——返回 char参数的字符串表示形式。 

//static valueOf(char[] data) ——返回 char数组参数的字符串表示形式。 

//static valueOf(char[] data, int offset, int count)—— 返回 char数组参数的特定子数组的字符串表示形式。 

//static valueOf(double d) ——返回 double参数的字符串表示形式。 

//static valueOf(float f) ——返回 float参数的字符串表示形式。 

//static valueOf(int i) ——返回 int参数的字符串表示形式。 

//static valueOf(long l) ——返回 long参数的字符串表示形式。 

//static valueOf(Object obj) ——返回 Object参数的字符串表示形式。

​ 代码示例如下：

//先创建其他类型的参数：
Boolean b = true;
char c = 'c';
char[] ch = {'a','b','c','d','b','c','d','b','c','d'};
double d = 1100.34;
float f = 343.33F;
int i = 100;
long l = 1243546675434L;
Object obj = "fedtferf";

//将其他类型的参数转化为String类型
String str1 = String.valueOf(b);
String str2 = String.valueOf(c);
String str3 = String.valueOf(ch);
String str4 = String.valueOf(ch,1,5);
String str5 = String.valueOf(d);
String str6 = String.valueOf(f);
String str7 = String.valueOf(i);
String str8 = String.valueOf(l);
String str9 = String.valueOf(obj);

System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
System.out.println(str4);
System.out.println(str5);
System.out.println(str6);
System.out.println(str7);
System.out.println(str8);
System.out.println(str9);

//输出结果：
true
c
abcdbcdbcd
bcdbc
1100.34
343.33
100
1243546675434
fedtferf

拼接字符串注意事项：

在字符串的拼接上，一共有以下三个方法：

1.直接使用“+”进行拼接

String a = "a";
String b = "b";
Stirng c = "c";
a = a+b+c;

如上图，字符串的拼接过程中，先对a和b进行拼接，然后再将c拼接进去，那么最后会产生两个没有指向栈内存的垃圾空间，本来按照JVM的机制会被垃圾回收器回收，但是由于字符串是存储在永久代中，因此垃圾回收器不能及时回收，则这两份垃圾会一直存在。

如果进行循环拼接100次，那么像示例这么简单的三个字符串拼接就能产生200份内存垃圾，这是非常不可取的，因此虽然直接使用“+"号拼接字符串很直观，但是我们应该尽量避免拼接字符串。

2.concat方法拼接

String a="a";
String b="b";
String c= a.concat(b);

3.使用Stringbuffer或Stringbuilder的append方法拼接

StringBuffer sb = new StringBuffer();
sb.append("a");
sb.append("b");

StringBuilder sbr = new StringBuilder();
sbr.append("c");
sbr.append("d");

也可以直接多个append拼接：

String ss1 = new StringBuffer().append("a").append("z").append("d").append("c").toString();

String ss2 = new StringBuilder().append("h").append("e").append("l").append("l").append("o").toString();

StringBuffer和StringBuilder是String的父类CharSquence的两个子类，它们就是为了解决字符串拼接的问题而设计的，因此在进行字符串拼接时，优先考虑使用该方法。

StringBuffer和StringBuilder的拼接原理：

​ 步骤一：通过无参构造创建StringBuffer和StringBuilder的实例化对象，此时系统会产生一个初始容量为16个字符的char数组；

​ 步骤二：往构造出来的容器内添加内容，使用append方法拼接，当char数组用满时，会自动扩容，也就是动态扩容算法。

​ 通过动态扩容，实现字符串在拼接时不会在内存中进行缓存，被缓存的数组可以被回收，而每次拼接产生的垃圾也会被及时回收。

Stringbuffer和Stringbuilder的区别在于，在多线程并发的情况下，StringBuilder允许多个线程同时处理同一内容，是线程不安全的；而StringBuffer则不允许，是线程安全的。