字符串的本质是字符数组，是由字母、数字、汉字、下划线组成的一串字符。在 Java 中字符串属于对象。字符串是常量，内容用双引号括起来，在创建之后不能更改，但是可以使用其他变量重新赋值的方法进行更改。
目录
5.StringBuffer 与 StringBuilder
1.String类创建方式
String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上。
1.1直接创建
语法格式
String 字符串名 = "字符串";
String str = "Hello Java"1.2用 new 关键字创建
在 java.lang 包中的 String 类有多种重载的构造方法。
（1）public String()方法
该方法初始化的新创建的String类对象表示一个空字符序列。由于String是不可变的，此构选方法几乎不用。具体代码如下：
string s new String();注意：使用String声明的空字符串，它的值不是null（空值），而是""，它是实例化的字符串对象，它不包含任何字符。
（2）public String(String original)方法
该方法初始化的新创建的 String 类对象表示一个与参数相同的字符序列，即新创建的字符串是该参数字符串的副本。此构造方法一般也不用，除非需要original的显式副本。参数original是一个字符串。具体代码如下：
String s = new String("hello world")；
（3）public String(char[] value)方法
该方法分配一个新的String 类对象，使其表示字符数组参数中当前包含的字符序列。该字符数组的内容已被复制，后续对字符数组的修改不会影响新创建的字符串。字符数组value的值是字符串的初始值。使用一个带char型数组参数的构造函数创建字符串，具体代码如下：
char[l c=('i', 'a', 'v', 'a');
String s = new String(c);（4）public String(char[] value, int offset, int count)方法
该方法分配一个新的String类对象，它包含取自字符数组参数一个子数组的字符。offset参数是子数组第一个字符的索引，count参数指定子数组的长度。该子数组的内容已被复制，后续对字符数组的修改不会影响新创建的字符串。使用带3个参数的构造函数创建字符数组，具体代码如下：
char[] c = ('h', 'e', '1', 'l', 'o', 'j', 'a', 'v', 'a');
String s = new String(c, 3，5)；
c[5] = 'J'；2.String类的API应用
2.1String类的操作方法
| 方法 | 说明 |
|---|---|
| static String copyValueOf(char[] data) | 返回指定数组中表示该字符序列的 String。 |
| char charAt(int index) | 返回指定索引处的 char 值。 |
| contains(CharSequence chars) | 判断是否包含指定的字符系列。 |
| char[] toCharArray() | 将此字符串转换为一个新的字符数组。 |
| boolean contentEquals(StringBuffer sb) | 当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。 |
| boolean startsWith(String prefix) | 测试此字符串是否以指定的前缀开始。 |
| boolean endsWith(String suffix) | 测试此字符串是否以指定的后缀结束。 |
| boolean equals(Object anObject) | 将此字符串与指定的对象比较。 |
| boolean equalsIgnoreCase(String anotherString) | 将此 String 与另一个 String 比较，不考虑大小写。 |
| byte[] getBytes() | 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 |
| byte[] getBytes(String charsetName) | 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 |
| boolean matches(String regex) | 告知此字符串是否匹配给定的正则表达式。 |
| boolean regionMatches(int toffset, String other, int ooffset, int len) | 测试两个字符串区域是否相等。 |
| int length() | 返回此字符串的长度。 |
| int hashCode() | 返回此字符串的哈希码。 |
| int indexOf(String str) | 返回指定子字符串在此字符串中第一次出现处的索引。 |
| int indexOf(String str, int fromIndex) | 从指定的索引开始，返回指定子字符串在此字符串中第一次出现处的索引。 |
| int lastIndexOf(String str) | 返回指定子字符串在此字符串中最右边出现处的索引。 |
| int lastIndexOf(String str, int fromIndex) | 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。 |
| int compareTo(String anotherString) | 按字典顺序比较两个字符串。 |
| int compareToIgnoreCase(String str) | 按字典顺序比较两个字符串，不考虑大小写。 |
| isEmpty() | 判断字符串是否为空。 |
| void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) | 将字符从此字符串复制到目标字符数组。 |
| String concat(String str) | 将指定字符串连接到此字符串的结尾。 |
| String trim() | 返回字符串的副本，忽略前导空白和尾部空白。 |
| String toString() | 返回此对象本身（它已经是一个字符串！）。 |
| String replace(char oldChar, char newChar) | 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 |
| String replaceAll(String regex, String replacement) | 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 |
| String replaceFirst(String regex, String replacement) | 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。 |
| String[] split(String regex) | 根据给定正则表达式的匹配拆分此字符串。 |
| String[] split(String regex, int limit) | 根据匹配给定的正则表达式来拆分此字符串。 |
| String substring(int beginIndex) | 返回一个新的字符串，它是此字符串的一个子字符串。 |
| String toLowerCase() | 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 |
| String toUpperCase() | 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。 |
| static String valueOf(primitive data type x) | 返回给定data type类型x参数的字符串表示形式。 |
更多详细，参看 Java String API 文档。
2.2字符串基本操作
public class Test{
public static void main(String[] args){
String s = "hello world"; //字符串说明
System.out.println("字符串长度；" + s.length()); //获取字符串长度，即字符个数
System.out.println("字符串第一个字符：" + s.charAt(0));
System.out.println("字符 l 第一次出现的位置（索引）：" + s.indexOf('l'));
System.out.println("字符 l 最好一次出现的位置（索引）：" + s.lastIndexOf('l'));
}
}2.3替换和去除空格操作
public class Test{
public static void main(String[] args){
String s = " hello java ";
//替换操作
System.out.println("将 java 改成 world：" + s.replace("java", "world");
//去除空格
System.out.println("去除两端空格：" + s.trim());
System.out.println("去除所有空格：" + s.replace(" ", "");
}
}2.4截取和分割操作
public class Test{
public static void main(String[] args){
String str ="Java-PHP-Python";
//下面是字符串截取操作
System.out.println("从第6个字符截取到末尾的结果：" + str.substring(5));
System.out.println("从第6个字符截取到第8个字符的结果：" + str.substring(5，8));
//下面是字符串分割操作
System.out.print("分割后的字符串数组中的元素依次为：");
String[] strArray = str.split("-"); //将字符串转换为字符串数组
for (int i = 0; i < strArray.length; i++){
if (i != strArray.length- 1) {
//如果不是数组的最后一个元素，在元素后面加逗号
System.out.print(strArray[i] + ",");
}
else {
//数组的最后一个元素后面不加逗号
System.out.println(strArray[1]);
}
}
}
}2.5字符串判断操作
public class Test{
public static void main(String[] args){
//声明字符串
String s1 = "String";
String s2 = "Str";
System.out.println("判断是否以字符串 Str 开头：" + s1.startsWith("Str"));
System.out.println("判断是否以字串 ng 结尾：" + s1.endsWith("ng"));
System.out.println("判断是否包含字串 tri ：" + s1.contains("tri"));
System.out.println("判断字符串是否为空：" + s1.isEmpty());
System.out.println("判断两个字符串是否相等：" + s1.equals(s2));
}
}2.6字符串比较操作
public class Test{
public static void main(String[] args){
String str1 = "java";
String str2 = "script";
String str3 = "JAVA";
int compare1 = str1.compareTo(str2);
int compare2 = str1.compareToIgnoreCase(str3);
System.out.print1n("compareTo()方法：");
if(compare1 > 0){
System.out.printin("字符串 str1 大于字符串 str2");
}else if(compare1 < 0){
System.out.println("字符串 str1 小于字符串 str2");
}else{
System.out.println("字符串 str1 等于字符串 str2");
}
System.out.println("compareToIgnoreCase()方法：");
if(compare2 > 0){
System.out.println("字符串 str1 大于字符串 str3");
}else if(compare2 < 0){
System.out.println("字符串 str1 小于字符串 str3");
}else{
System.out.println("字符串 str1 等于字符串 str3");
}
}
}
// 输出结果：
// compareTo()方法：
// 字符串 str1 小于字符串 str2
// compareToIgnoreCase()方法：
// 字符串 str1 等于字符串 str3
3.字符串的类型转换
3.1字符串转换成数组
public class test{
public static void main(String[] args){
String str = "java develop,jsp develop,vb develop";
char[] c = str.toCharArray();
System.out.println("字符数组的长度：" + c.length);
System.out.println("char数组中的元素是：");
for(int i = 0; i < str.length(); i++){
System.out.print(c[i] + " ");
}
}
}3.2基本数据类型转换成字符串
使用 valueOf() 把其他数据类型转换为字符串类型。
public static String valueOf(boolean b);
public static String valueOf(char c);
public static String valueOf(int i);
public static String valueOf(long l);
public static String valueOf(float f);
public static String valueOf (double d);
public static String valueOf (Object obj);
public static String valueOf(char[] data)；
public static String valueOf (char[] data, int offset, int count);
3.3格式化字符串
输出格式化数字可以使用 printf() 和 format() 方法。
- String 类使用静态方法 format() 返回一个String 对象而不是 PrintStream 对象。
- String 类的静态方法 format() 能用来创建可复用的格式化字符串，而不是仅用于一次打印输出。
public class FormatTest{
public static void main(String[] args){
String str1 = String.format("32的八进制：%o", 32);
System.out.println(str1);
String str2 = String.format("字母G的小写是：%c%n", 'g');
System.out.print(str2);
String str3 = String.format("12>8的值：%b%n", 12>8);
System.out.print(str3);
String str4 = String.format("%l$d, %2$s, %3$f", 125, "ddd", 0.25);
System.out.println(str4);
}
}4.正则表达式
正则表达式是一种用于模式匹配和替换的规范，一个正则表达式就是由普通的字符及特殊字符（元字符）组成的文字模式，它可以描述在查找文字主体待匹配的一个或多个字符串。
4.1正则表达式的语法
java.util.regex 包是 Java 标准库中用于支持正则表达式操作的包。主要包括：
- Pattern 类：
pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。
- Matcher 类：
Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
- PatternSyntaxException：
PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。
在 Java 中，\\ 表示：要插入一个正则表达式的反斜线，其后的字符具有特殊的意义。Java 中正则表达式中则需要有两个反斜杠才能被解析为其他语言中的转义作用。
System.out.print("\\"); // 输出为 \
System.out.print("\\\\"); // 输出为 \\
| 元字符 | 说明 |
|---|---|
| \ | 将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如， n匹配字符 n。\n 匹配换行符。序列 \\\\ 匹配 \\ ，\\( 匹配 (。 |
| ^ | 匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与"\n"或"\r"之后的位置匹配。 |
| $ | 匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与"\n"或"\r"之前的位置匹配。 |
| * | 零次或多次匹配前面的字符或子表达式。例如，zo* 匹配"z"和"zoo"。* 等效于 {0,}。 |
| + | 一次或多次匹配前面的字符或子表达式。例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+ 等效于 {1,}。 |
| ? | 零次或一次匹配前面的字符或子表达式。例如，"do(es)?"匹配"do"或"does"中的"do"。? 等效于 {0,1}。 |
| {n} | n 是非负整数。正好匹配 n 次。例如，"o{2}"与"Bob"中的"o"不匹配，但与"food"中的两个"o"匹配。 |
| {n,} | n 是非负整数。至少匹配 n 次。例如，"o{2,}"不匹配"Bob"中的"o"，而匹配"foooood"中的所有 o。"o{1,}"等效于"o+"。"o{0,}"等效于"o*"。 |
| {n,m} | m 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如，"o{1,3}"匹配"fooooood"中的头三个 o。'o{0,1}' 等效于 'o?'。注意：您不能将空格插入逗号和数字之间。 |
| ? | 当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如，在字符串"oooo"中，"o+?"只匹配单个"o"，而"o+"匹配所有"o"。 |
| . | 匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符，请使用诸如"[\s\S]"之类的模式。 |
| (pattern) | 匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用"\("或者"\)"。 |
| (?:pattern) | 匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用"or"字符 (|) 组合模式部件的情况很有用。例如，'industr(?:y|ies) 是比 'industry|industries' 更经济的表达式。 |
| (?=pattern) | 执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?=95|98|NT|2000)' 匹配"Windows 2000"中的"Windows"，但不匹配"Windows 3.1"中的"Windows"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。 |
| (?!pattern) | 执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?!95|98|NT|2000)' 匹配"Windows 3.1"中的 "Windows"，但不匹配"Windows 2000"中的"Windows"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。 |
| x|y | 匹配 x 或 y。例如，'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"。 |
| [xyz] | 字符集。匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"。 |
| [^xyz] | 反向字符集。匹配未包含的任何字符。例如，"[^abc]"匹配"plain"中"p"，"l"，"i"，"n"。 |
| [a-z] | 字符范围。匹配指定范围内的任何字符。例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母。 |
| [^a-z] | 反向范围字符。匹配不在指定的范围内的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。 |
| \b | 匹配一个字边界，即字与空格间的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。 |
| \B | 非字边界匹配。"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"。 |
| \cx | 匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是"c"字符本身。 |
| \d | 数字字符匹配。等效于 [0-9]。 |
| \D | 非数字字符匹配。等效于 [^0-9]。 |
| \f | 换页符匹配。等效于 \x0c 和 \cL。 |
| \n | 换行符匹配。等效于 \x0a 和 \cJ。 |
| \r | 匹配一个回车符。等效于 \x0d 和 \cM。 |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。 |
| \S | 匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。 |
| \t | 制表符匹配。与 \x09 和 \cI 等效。 |
| \v | 垂直制表符匹配。与 \x0b 和 \cK 等效。 |
| \w | 匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。 |
| \W | 与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。 |
| \xn | 匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，"\x41"匹配"A"。"\x041"与"\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。 |
| \num | 匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，"(.)\1"匹配两个连续的相同字符。 |
| \n | 标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。 |
| \nm | 标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 \nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)。 |
| \nml | 当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。 |
| \un | 匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。 |
4.2正则表达式的实例
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test{
public static void main(String[] args){
//要验证的字符串
String str = "abcdefg";
//正则表达式规则
String regEx = "ABC*";
//编译正则表达式
Pattern pattern = Pattern.compile(regEx);
//忽略大小写的写法
//Pattern pattern = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(str);
//查找字符串中是否有匹配正则表达式的字符或字符串
boolean rs = matcher.find();
System.out.println(rs);
}
}
//判断字符串 abcdefg 中是否含有 ABC* ，*表示通配，即以 ABC 开头的任意长字符串
//运行结果是false5.StringBuffer 与 StringBuilder
除了 String类 提供创建和处理字符串的方法外，还有StringBuffer类 和 StringBuilder类。当对字符串进行修改的时候，需要使用 StringBuffer类 和 StringBuilder类。和 String 类不同的是，StringBuffer类 和 StringBuilder类 的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder 和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
- String类：操作少量数据时。
- StringBuilder类：在单线程操作字符串缓冲区情况下操作大量数据时。
- StringBuffer类：在多线程操作字符串缓冲区情况下操作大量数据时。
5.1StringBuffer 类的创建
（1）StringBuilder() 构造方法
该构造方法创建一个空的字符串缓冲区，初始容量为16个字符。
语法格式
public StringBuilder()
（2）StringBuilder(int capacity) 构造方法
该构造方法创建一个空的字符串缓冲区，并指定初始容量是 capacity 的字符串缓冲区。
语法格式
public StringBuilder (int capacity)
（3）StringBuilder(String str) 构造方法
该构造方法创建一个字符串缓冲区，并将其内容初始化为指定的字符串 str 。该字符串的初始容量为16 加上字符串 str 的长度。
语法格式
public StringBuilder(String str)
public class Test{
public static void main(String[] args){
//定义空的字符缓冲区
StringBuilder sb1 = new StringBuilder();
//定义指定长度的字符缓冲区
StringBuilder sb2 = new StringBuilder(12);
//创建指定字符串的缓冲区
StringBuilder sb3 = new StringBuilder("java buffer");
}
}5.2StringBuffer 类的方法
| 方法 | 说明 |
|---|---|
| public StringBuffer append(String s) | 将指定的字符串追加到此字符序列。 |
| public StringBuffer reverse() | 将此字符序列用其反转形式取代。 |
| public delete(int start, int end) | 移除此序列的子字符串中的字符。 |
| public insert(int offset, int i) | 将 int 参数的字符串表示形式插入此序列中。 |
| insert(int offset, String str) | 将 str 参数的字符串插入此序列中。 |
| replace(int start, int end, String str) | 使用给定 String 中的字符替换此序列的子字符串中的字符。 |
| int capacity() | 返回当前容量。 |
| char charAt(int index) | 返回此序列中指定索引处的 char 值。 |
| void setCharAt(int index, char ch) | 将给定索引处的字符设置为 ch。 |
6.字符串的解析
在 java.lang 包中有一个 String.split() 方法，可以将字符串解析为一个数组。
语法结构
public String[] split(String regex)
参数regex是分隔符的正则表达式。示例如下：
public class Test{
public static void main(String[] args){
String ss = "one little, two little, three little.";
String[] str = ss.split("[ ,.]");
for (String s: str) {
System.out.println(s);
}
}
}本例使用正则表达式将字符串 ss 分解成了数组，正则表达式的模式是空格、英文逗号和英文，即按照空格、英文逗号和英文句号对字符串 ss 中的字符进行解析和分割。
标签：字符,匹配,String,int,字符串,Java,public From： https://blog.csdn.net/weixin_74417251/article/details/142894292