String类知识总结及常用方法

String

java.lang.String

在Java中，string是一个引用类型，它本身是一个class。

Java中可以直接表示字符串

String str = "hellow";

实际上字符串在string内部是通过一个char[]数组表示的。

• String是被final修饰的类，不能被继承；
• String实现了Serializable和Comparable接口，表示String支持序列化和可以比较大小；
• String底层是通过char类型的数据实现的，并且被final修饰，所以字符串的值创建之后就不可以被修改，具有不可变性。

初始化

这里只写了常用的，其他的一般不会用到

**String s=“…”; ：**直接赋值

String s="abc"

public String() ： 使用new的方式来获取一个字符串对象，使其表示一个不含任何内容的空字符（空参构造）

String s=new String();

public String(String original) ： 传递一个字符串，根据传递的字符串再创建一个字符串对象

String s=new String("abc");

public String(Char[ ] chs) ：传递一个字符数组，根据字符数组再创建一个字符串对象

char[] chs={'a','b','c'};
String s=new String(chs);

public String(byte[] chs) ：传递一个字节数组，根据字节数组再创建字符串对象

 byte[] bytes={97,98,99};
 String s=new String(bytes);    // 字符串s为"abc"

public String(char[] value,int offset,int count)：创建一个字符串对象 ，其中包含字符数组参数的子阵列中的字符。 offset参数是子阵列的第一个字符的索引， count参数指定子阵列的长度。字符数组的后续修改不会影响新创建的字符串。

char[] chs={'a','b','c'};
String s=new String(chs,0,1); 	// 字符串s为"a"

常用方法

1、toString()

toString() 方法：返回字符串本身，返回值为 String 类型

String str = new String("Hello World");
System.out.println("str = " + str);//Hello World

2、length()

length() 方法：返回字符串字符序列的长度（空格也算），返回值为 int 类型

String str = new String("Hello World");
System.out.println(str.length());//11

3、getBytes()

getBytes() 方法：将当前字符串内容转换为 byte 数组并返回，返回值为 byte[]，该方法的返回值可作为 String 构造方法的参数

//将String类型转换为byte数组类型并打印
//先将字符串拆分为字符，再将每个字符转换为byte类型，也就是获取所有字符的ASCII码
String str = new String("Hello World");
byte[] bytes = str.getBytes();
for (int i = 0; i < bytes.length; i++) {
	System.out.println("下标为" + i + "的元素为：" + bytes[i]);//打印的是每个字母对应的ASCII码
}

4、toCharArray()

toCharArray() 方法：将当前字符串内容转换为 char 数组并返回，返回值为 char[]，该方法的返回值可作为 String 构造方法的参数

String str = new String("Hello World");
char[] cArr = str.toCharArray();
for (int i = 0; i < str.length(); i++) {
    System.out.println("下标为" + i + "的元素为：" + cArr[i]);//打印的是每个字母
}

5、charAt(int index)

charAt(int index) 方法：用于返回字符串指定位置的字符，返回值为 char 类型，参数为 int 类型

String str = new String("Hello World");
for (int i = 0; i < str.length(); i++) {
    System.out.println("下标为" + i + "的元素为：" + str.charAt(i));//打印的是每个字母
}

6、isEmpty()

isEmpty() 方法：判断字符串是否为空，返回值为 boolean 类型，查看该方法的源码可知字符串的 length 为0则为空

注意：开发中判断字符串是否为空一般采用 org.apache.commons.lang3 下的 StringUtils 中的静态方法 isEmpty() 和 isBlank()；

StringUtils 类与 String 类的区别在于：StringUtils 类是 null 安全的，即如果输入参数 String 为 null，则不会抛出 NullPointerException 空指针异常，代码考虑更全面

String str1 = null;
String str2 = "";
String str3 = " ";
System.out.println(str2.isEmpty());//true
System.out.println(str3.isEmpty());//false
System.out.println(str1.isEmpty());//java.lang.NullPointerException

//拓展StringUtils.isBlank()和StringUtils.isEmpty()
StringUtils.isBlank(null)      = true
StringUtils.isBlank("")        = true
StringUtils.isBlank(" ")       = true

StringUtils.isEmpty(null)      = true
StringUtils.isEmpty("")        = true
StringUtils.isEmpty(" ")       = false

7、equals(Object anObject)

equals(Object anObject) 方法：比较字符串内容是否相等并返回，返回值为 boolean 类型

equalsIgnoreCase(String anotherString)方法：比较字符串内容是否相等并返回，返回值为 boolean 类型，不考虑大小写， 如：'A’和’a’是相等

String str = new String("Hello World");
//注意：开发中作比较一般常量值在前，变量值在后
System.out.println("hello world".equals(str));//false
System.out.println("hello world".equalsIgnoreCase(str));//true

8、compareTo(String anotherString)

compareTo(String anotherString) 方法：比较调用对象和参数对象的大小关系，返回值为 int 类型

compareToIgnoreCase(String str) 方法：比较调用对象和参数对象的大小关系，返回值为 int 类型，不考虑大小写，也就是’a’和’A’是相等的关系

比较大小的方法：例如 A.compareTo(B)，拿方法调用者(A)的字符依次与方法参数(B)的字符作比较，即用 A 的 ASCII码减去 B 的ASCII码；结果有三种：负整数、正整数、零。负整数即按字典顺序 A 在 B 之前，正整数即 A 在 B 之后，零则为字符串相等。

注意：比较出大小就不往后进行，即从第一个字符串开始比较，相同则比较下一个，直到比较出大小或比较到最后一个字符。

String str = "hello";
System.out.println(str.compareTo("world"));  // 'h' - 'w' => 104 - 119 => -15
System.out.println(str.compareTo("haha"));   // 'e' - 'a' => 101 - 97  => 4
System.out.println(str.compareTo("heihei")); // 'l' - 'i' => 108 - 105 => 3
System.out.println(str.compareTo("helloworld")); // 长度： 5 - 10 => -5
System.out.println(str.compareToIgnoreCase("HELLO")); // 0

9、contains(CharSequence s)

contains(CharSequence s) 方法：判断当前字符串是否包含参数指定的内容，返回值为 boolean 类型，参数CharSequence 为一个接口，CharSequence 是 char 值的可读序列，参数可以为String、StringBuilder、StringBuffer等类型

String str = "Give you some color to see see";
System.out.println(str.contains("some"));//true
System.out.println(str.contains("Some"));//false

10、trim()

trim() 方法：返回去掉前导和尾随空白的字符串，返回值为 String 类型

String str = " Hello World ";
System.out.println(str.trim());//Hello World
System.out.println(str.length());//13
System.out.println(str.trim().length());//11

11、toUpperCase() 和 toLowerCase()

toUpperCase() 方法：返回字符串的大写形式，返回值为 String 类型

toLowerCase() 方法：返回字符串的小写形式，返回值为 String 类型

此两种方法经常用于在对字符串做判断时使用，因为要判断的字符串可能为驼峰式或者不规则的方式，故先将判断的字符串转为大写或者小写，然后与常量去做比较。

String str = "Hello World";
System.out.println(str.toLowerCase());//hello world
System.out.println(str.toUpperCase());//HELLO WORLD

12、substring(…)

该方法有两个重载的方法，分别为：

substring(int beginIndex, int endIndex) 方法：返回字符串中从下标 beginIndex(包括) 开始到 endIndex(不包括) 结束的子字符串，返回值为 String 类型，参数为 int 类型

substring(int beginIndex) 方法：返回字符串中从下标 beginIndex(包括) 开始到字符串结尾的子字符串，返回值为 String 类型，参数为 int 类型

注意：Java 中涉及到区间的问题，一般都为 左边包括，右边不包括，即左开右闭，“[ x , y )”

String a = “123456anbdc”;
String b = a.subString(1);	//23456anbdc

String a = “123456anbdc”;
String b = a.subString(1，5);	2345

String a = “123456anbdc”;
String b = a.subString(1，a.indexOf(“b”));
//从下标为1的位置开始截取到指定字符串“b”的值,23456an

13、replace(…)

replace(char oldChar, char newChar) 方法：使用参数newChar替换此字符串中出现的所有参数oldChar，返回值为 String 类型，参数为 char 类型

replace(CharSequence target, CharSequence replacement) 方法：用新字符串replacement替换所有的旧字符串target，返回值为 String 类型，参数为 CharSequence 接口

System.out.println("Hello World".replace('o', 'e'));//Helle Werld
System.out.println("JonL".replace('q', 'x'));//JonL 无改变则返回原字符串
System.out.println("aaa".replace("aa", "b"));//ba

14、split(String regex)

split(String regex) 方法：参数regex为正则表达式，以regex所表示的字符串为分隔符，将字符串拆分成字符串数组，结尾的空字符串不包含在结果数组中，返回值为 String[] 类型，参数为 String 类型

String str = "boo:and:foo";
String[] split = str.split(":");//结果为："boo", "and", "foo"
String[] split = str.split("o");//结果为："b", "", ":and:f"

15、startsWith(…) 和 endsWith(…)

startsWith(String prefix) 方法：判断字符串是否以参数字符串开头，返回值为 boolean 类型，参数为 String 类型

startsWith(String prefix, int toffset) 方法：从指定位置开始是否以参数字符串开头，返回值为 boolean 类型，参数 prefix 为 String 类型，toffset 为 int 类型

endsWith(String suffix) 方法：判断字符串是否以参数字符串结尾，返回值为 boolean 类型，参 数为 String 类型

String str = "Give you some color to see see";
System.out.println(str.startsWith("G"));//true
System.out.println(str.startsWith(" "));//false
System.out.println(str.startsWith("you", 5));//true
System.out.println(str.endsWith(" "));//false
System.out.println(str.endsWith("see"));//true

16、indexOf(…) 和 lastIndexOf(…)

方法声明	功能介绍
int indexOf(int ch)	用于返回当前字符串中参数 ch 指定的字符第一次出现的下标
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 指定字符出现的下标，若找不到返回-1
int lastIndexOf(String str)	返回 str 指定字符串最后一次出现的下标
int lastIndexOf(String str, int fromIndex)	用于从 fromIndex(包含) 位置开始反向搜索的第一次出现的下标

String str = "Good Good Study, Day Day Up!";
System.out.println(str.indexOf('g')); // -1  代表查找失败
System.out.println(str.indexOf('G')); // 0   该字符第一次出现的索引位置
System.out.println(str.indexOf('G', 0)); // 0
System.out.println(str.indexOf('G', 1)); // 5

// 查找字符串
System.out.println(str.indexOf("day")); // -1
System.out.println(str.indexOf("Day")); // 17   字符串中第一个字符的下标
System.out.println(str.indexOf("Day", 17)); // 17   字符串中第一个字符的下标
System.out.println(str.indexOf("Day", 18)); // 21   字符串中第一个字符的下标

// 字符串内容的反向查找
System.out.println(str.lastIndexOf("Day")); // 21
System.out.println(str.lastIndexOf("Day",  21)); // 21
System.out.println(str.lastIndexOf("Day", 20)); // 17
System.out.println(str.lastIndexOf("Day", 15)); // -1

16、join()

拼接字符串使用静态方法join(),它用指定的字符串连接字符串数组

String []arr = {"A","B","C"};
String s = String.join("***",arr);
//"A***B***C"

17、formatted()和format()

字符串提供了formatted()方法和format()静态方法，可以传入其他参数，替换站位符，然后生成新的字符串。

public class Main {
    public static void main(String[] args) {
        String s = "Hi %s, your score is %d!";	
        System.out.println(s.formatted("Alice", 80));	//Hi Allice, your score is 80!
        System.out.println(String.format("Hi %s, your score is %.2f!", "Bob", 59.5));	//Hi Bob, your score is 59.5!
    }
}

• %s：显示字符串；
• %d：显示整数；
• %x：显示十六进制整数；
• %f：显示浮点数。

占位符还可以带格式，例如%.2f表示显示两位小数。如果你不确定用啥占位符，那就始终用%s，因为%s可以显示任何数据类型。

类型转换

其他类型转换为字符串

要把任意基本类型或引用类型转换为字符串，可以使用静态方法valueOf()。这是一个重载方法，编译器会根据参数自动选择合适的方法：

String.valueOf(123); // "123"
String.valueOf(45.67); // "45.67"
String.valueOf(true); // "true"

valueOf(char[] data) 返回 char数组参数的字符串 char形式。

valueOf(char[] data, int offset, int count) 返回 char数组参数的特定子阵列的字符串 char形式。

char[] arr = new char[]{1,2,3};
String.valueOf(arr);	//"123"
String.valueOf(arr,0,1);	"1"

把字符串转换为其他类型

把字符串转换为int类型

int n1 = Integer.parseInt("123"); // 123
int n2 = Integer.parseInt("ff", 16); // 按十六进制转换，255

把字符串转换为boolean类型

boolean b1 = Boolean.parseBoolean("true"); // true
boolean b2 = Boolean.parseBoolean("FALSE"); // false

其他基本数据类型转换同上

转换为char[]

char[] cs = "Hello".toCharArray(); // String -> char[]
String s = new String(cs); // char[] -> String

---

StringBuilder

Java编译器对String做了特殊处理，使得我们可以直接用“+”拼接字符串。

String s = "";
for (int i = 0; i < 1000; i++) {
    s = s + "," + i;
}

虽然可以直接拼接字符串，但是，在循环中，每次循环都会创建新的字符串对象，然后扔掉旧的字符串。这样，绝大部分字符串都是临时对象，不但浪费内存，还会影响GC效率。

Java标准库提供了StringBuilder类，它是一个可变对象，可以预分配缓冲区，这样，往StringBuilder中新增字符时，不会创建新的临时对象：

StringBuilder sb = new StringBuilder(1024);
for (int i = 0; i < 1000; i++) {
    sb.append(',');
    sb.append(i);
}
String s = sb.toString();

StringBuilder还可以进行链式操作：

public class Main {
    public static void main(String[] args) {
        var sb = new StringBuilder(1024);
        sb.append("Mr ")
          .append("Bob")
          .append("!")
          .insert(0, "Hello, ");
        System.out.println(sb.toString());
    }
}

如果我们查看StringBuilder的源码，可以发现，进行链式操作的关键是，定义的append()方法会返回this，这样，就可以不断调用自身的其他方法。

构造方法

创建为空

StringBuilder str = new StringBuilder();

在创建时添加初始字符串

StringBuilder str = new StringBuilder("abc");

在创建时添加初始长度

StringBuilder str = new StringBuilder(初始长度);

成员方法

public StringBuilder append(任意类型)

追加数据：给原有的字符串尾部加入新字符串

str.append("just");

insert()

向指定位置插入数据

每次加入新字符串之后都会改变字符串中字符的地址。插入后原来指定位置的数据向后移。

str.insert(0,"you");

deleteCharAt()

删除指定位置的数据

str.deleteCharAt(index);

delete()

删除指定范围的数据左闭右开

str.delete(beginIndex,endIndex);

public int length()

返回长度（字符出现的个数）

public String toString()

返回一个字符串（拼接后的结果），实现将StringBuilder转换为String。

public StringBuilder reverse()

返回相反的字符序列

---

StringJoiner

构造方法

指定拼接时的间隔符号

public StringJoiner(间隔符号)

StringJoiner str = new StringJoiner(",");

指定拼接时的间隔符号、开始符号、结束符号

public StringJoiner(间隔符号，开始符号，结束符号)

StringJoiner str = new StringJoiner(",","[","]");

成员方法

public StringJoiner add(添加的内容)

添加数据，并返回对象本身

public int length()

返回长度(字符出现的个数)

public String toString

返回一个字符串（拼接之后的结果），实现将StringJoiner转换为String。

aaa—bbb—ccc

=aaa,bbb,ccc.

链式操作

当我们在调用一个方法时，不需要用变量接收它的结果，可以继续调用其他方法

public class Main {
    public static void main(String[] args) {
        var sb = new StringBuilder(1024);
        sb.append("Mr ").append("Bob").append("!").insert(0, "Hello, ");
    System.out.println(sb.toString());
    }
}

进行链式操作的关键是，定义的append()方法会返回this，这样，就可以不断调用自身的其他方法。(add同理)

StringUtils

简介

StringUtils是org.apache.commons.lang包中的一个工具类，提供了130多个静态方法（static）操作String类型。并且StringUtils对于null是安全的(即如果输入参数String为null则不会抛出NullPointerException，而是做了相应处理。
使用时需要先添加maven依赖：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.11</version>
</dependency>

常用方法

public static boolean isEmpty(String str)

判断某字符串是否为空，为空的标准是str == null 或 str.length() == 0

StringUtils.isEmpty(null);     //null，结果为true
StringUtils.isEmpty("");       //""中什么也不写，结果为true
StringUtils.isEmpty("  ");     //"   "中间是空格，结果为false
StringUtils.isEmpty("aaa");    //正常字符串，结果为false

public static boolean isNotEmpty(String str)

判断某字符串是否非空，等于!isEmpty(String str)

StringUtils.isNotEmpty(null);    //null结果为false
StringUtils.isNotEmpty("");      //""中什么也不写，结果为false
StringUtils.isNotEmpty("  ");    //"   "中间是空格，结果为true
StringUtils.isNotEmpty("bob");   //正常字符串，结果为true

public static boolean isBlank(String str)

判断某字符串是否为空或长度为0或由空白符(whitespace)空格构成，与isEmpty区别就是 字符串内容是空格 返回值也是true

StringUtils.isBlank(null);           //true
StringUtils.isBlank("");             //true
StringUtils.isBlank(" ");            //true
StringUtils.isBlank("       ");      //true
StringUtils.isBlank("\t \n \f \r");  //true
StringUtils.isBlank("aaa");          //false

public static boolean isNotBlank(String str)

判断某字符串是否不为空且长度不为0且不由空白符(whitespace)构成，
等于!isBlank(String str)

public static String trim(String str)

用于删除字符串的头尾空白符

StringUtils.trim(null);   						//结果：null
StringUtils.trim("");    					    //结果：
StringUtils.trim(" ");    						//结果：
StringUtils.trim("     \b \t \n \f \r    ");	//结果：
StringUtils.trim("     \n\tss   \b");			//结果：ss
StringUtils.trim(" d   d dd     ");				//结果：d   d dd
StringUtils.trim("dd     ");       				//结果：dd
StringUtils.trim("     dd       ");				//结果：dd

public static String trimToNull(String str)

去掉字符串两端的控制符（除去ASCII码中127号）和空格;
与trim区别在于：如果字符串去掉空白符或制表符之后，结果变为null或""，则返回null。

控制符：在ASCII码中，第0～31号及第127号(共33个)是控制字符或通讯专用字符，如：LF（换行）、CR（回车）、FF（换页）、DEL（删除）、BS（退格)、BEL（振铃）等；通讯专用字符：SOH（文头）、EOT（文尾）、ACK（确认）等。
空格：ASCII码的编号为32

public static String trimToEmpty(String str)

去掉字符串两端的控制符和空格;
与trim区别在于：如果字符串去掉空白符或制表符之后，结果变为null或"“，则返回”"。

public static boolean equals(String str1, String str2)

比较两个字符串是否相等，如果两个均为空则也认为相等。

StringUtils.equals(" ", " ");    //两个字符串都是相等数量空格。true
StringUtils.equals(" ", "     ");//两个字符串都是空格，但空格数量不等。false
StringUtils.equals(null,null);   //两个字符串都是null。true
StringUtils.equals(" ",null);    //一个字符串为空，一个字符串为null。false

public static boolean equalsIgnoreCase(String str1, String str2)

比较两个字符串是否相等，不区分大小写，如果两个均为空则也认为相等（同equals方法）。

public static int indexOf(String str, char c)
返回字符c在字符串str中第一次出现的位置。(下标从0开始)
如果c没有在str中出现则返回-1。

public static int indexOf(String str, char c, int startPos)
返回字符c从startPos开始在字符串str中第一次出现的位置。(下标从0开始)
如果从startPos开始c没有在str中出现则返回-1，
如果str为null或""，则也返回-1

public static int indexOf(String str, String searchStr)
返回字符串searchStr在字符串str中第一次出现的位置。
如果str为null或searchStr为null则返回-1，
如果searchStr为"",且str为不为null，则返回0。

public static int IndexOf(String str, String searchStr, int startPos)
返回字符串searchStr从startPos开始在字符串str中第一次出现的位置。(下标从0开始)
如果 str=null 或 searchStr=null 则返回-1。

System.out.println(StringUtils.indexOf("aabb", null,1));  //-1
System.out.println(StringUtils.indexOf(null, "aa",1));    //-1
System.out.println(StringUtils.indexOf("aabbccdd", "cc",1));  //4

public static int ordinalIndexOf(String str, String searchStr, int ordinal)
返回字符串searchStr在字符串str中第ordinal次出现的位置。
如果str=null或searchStr=null或ordinal<=0则返回-1

public static int lastIndexOf(String str, char c)
字符c在字符串str中最后一次出现的下标（具体用法同indexOf方法）

public static boolean contains(String str, char searchChar)
判断字符串str中是否包含字符searchChar。
如果str为null或""，返回false；
如果searchChar不在str中，返回false。

public static boolean contains(String str, String searchStr)
判断字符串str中是否包含字符串searchStr。
如果searchChar不在str中，返回false。

StringUtils.contains("", "");      //true
StringUtils.contains("dfg", "");   //true
StringUtils.contains("dfg", "d");  //true

public static boolean containsIgnoreCase(String str, String searchStr)
判断字符串str是否包含字符串searchStr，不区分大小写。

public static int indexOfAny(String str, Char … searchChar )
找出字符searchChars中的r任何字符第一次出现在字符串str中的位置。
如果字符数组中的字符都不在字符串中，则返回-1
如果字符串为null或""，则返回-1

StringUtils.indexOfAny("sdfdadad", "d", "a");    //1

public static String substring(String str, int startPos)
得到字符串str的子串。
如果startPos小于0，子串取逆序的前|startPos|位
如果str为null或""，则返回它本身

StringUtils.substring("aaabbbcccddd", 3);   //bbbcccddd
StringUtils.substring("aaabbbcccddd", -3);  //ddd
StringUtils.substring("", 3);				//
StringUtils.substring(null, 3);				//null

public static String substring(String str, int start, int end)
得到字符串str的子串。
如果str为null或""，则返回它本身

public static String[ ] split(String str)
把字符串拆分成一个字符串数组，用空格(whitespace)作为分隔符。
如果字符串为null，返回null
如果字符串为""，返回空数组{}

 // 打印结果为ab cd efg ，数组a为{ab,cd,ef}
String[] arrs = StringUtils.split("ab cd efg");
for (String a : arrs) {
     System.out.print(a+" ");
}

public static String[ ] split(String str, char separatorChar)
把字符串拆分成一个字符串数组，用指定的字符separatorChar作为分隔符。(结果字符串数组把separatorChar丢掉)
如果字符串为null，返回null
如果字符串为""，返回空数组{}

  // 打印结果为aa bb cc
String[] arrs02 = StringUtils.split("aaybbyccy",'y');
for (String a : arrs02) {
     System.out.print(a+"");
}

public static String[ ] split(String str, String separatorChars)
把字符串拆分成一个字符串数组，用指定的字符串separatorChars作为分隔符。
如果字符串str为null，返回null
如果字符串str为""，返回空数组{}
如果separatorChars为null，则默认为空白符

  // 打印结果为aa bb cc
String[] arrs03 = StringUtils.split("aayybbyyccy","yy");
for (String a : arrs03) {
      System.out.print(a+" ");
}

public static String join(Object[ ] array)
把数组中的元素连接成一个字符串返回。

   // 打印结果：asdfsdw32e
System.out.println(StringUtils.join('a', "sdfsd", "w32e"));

public static String join(Object[ ] array, char separator)
把数组中的元素连接成一个字符串返回，把分隔符separator也加上。

// 打印结果：a bb ccc
Object[] obj = {'a',"bb","ccc"};
System.out.println(StringUtils.join(obj," "));

public static String replace(String text, String searchString, String replacement)
在字符串text中用replacement代替searchString，替换所有。

// 结果bbbbbb
StringUtils.replace("aaabbb", "a", "b");
// 结果aaabbb；searchSting在字符串中不存在，则不替换
StringUtils.replace("aaabbb", "f", "b");

public static String repeat(String str, int repeat)
重复字符串repeat次，组合成一个新串返回。
如果字符串str为null或"“，则返回它本身
如果repeat小于0，则返回”".

// 结果abcabcabc
System.out.println(StringUtils.repeat("abc", 3));

public static String swapCase(String str)
把字符串中的字符大写转换为小写，小写转换为大写。

 // 结果AAABBBaaabbb
System.out.println(StringUtils.swapCase("aaabbbAAABBB"));

public static int countMatches(String str, String sub)
计算字符串sub在字符串str中出现的次数。
如果str为null或""，则返回0

 // 结果 2
System.out.println(StringUtils.countMatches("aaaa", "aa"));

public static String replace(String text, String searchString, String replacement)**
在字符串text中用replacement代替searchString，替换所有。

// 结果bbbbbb
StringUtils.replace("aaabbb", "a", "b");
// 结果aaabbb；searchSting在字符串中不存在，则不替换
StringUtils.replace("aaabbb", "f", "b");

public static String repeat(String str, int repeat)
重复字符串repeat次，组合成一个新串返回。
如果字符串str为null或"“，则返回它本身
如果repeat小于0，则返回”".

// 结果abcabcabc
System.out.println(StringUtils.repeat("abc", 3));

public static String swapCase(String str)
把字符串中的字符大写转换为小写，小写转换为大写。

 // 结果AAABBBaaabbb
System.out.println(StringUtils.swapCase("aaabbbAAABBB"));

public static int countMatches(String str, String sub)
计算字符串sub在字符串str中出现的次数。
如果str为null或""，则返回0

 // 结果 2
System.out.println(StringUtils.countMatches("aaaa", "aa"));