13.Java String 类与StringBuffer&StringBuilder类

字符串广泛应用 在 Java 编程中，在 Java 中字符串属于对象

Java 提供了 String 类来创建和操作字符串

1.String声明为final的，不可被继承
2.String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小
3.String内部定义了final char[] value用于存储字符串数据
4.String:代表不可变的字符序列

创建字符串

//1.第一种方式
String str = "Runoob";


//2.用构造函数创建字符串
String str2=new String("Runoob");


//String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上
String s1 = "Runoob";              // String 直接创建
String s2 = "Runoob";              // String 直接创建
String s3 = s1;                    // 相同引用
String s4 = new String("Runoob");   // String 对象创建
String s5 = new String("Runoob");   // String 对象创建


//String 类有 11 种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数
public class StringDemo{
   public static void main(String args[]){
      char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
      String helloString = new String(helloArray);  
      System.out.println( helloString );
   }
}

runoob

注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了

常用方法

1.int length()：返回字符串的长度：return value.length
2.char charAt(int index)：返回某索引处的字符return value[index]
3.boolean isEmpty()：判断是否是空字符串：return value.length==0
4.String toLowerCase()：使用默认语言环境，将String中的所有字符转换为小写
5.String toUpperCase()：使用默认语言环境，将String中的所有字符转换为大写
6.String trim()：返回字符串的副本，忽略前导空白和尾部空白
7.boolean equals(Object obj)：比较字符串的内容是否相同
8.boolean equals IgnoreCase(String anotherString)：与equals方法类似，忽略大小写
9.String concat(String str)：将指定字符串连接到此字符串的结尾。等价于用“+”
10.int compareTo(String anotherString)：比较两个字符串的大小
11.String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串
12.String substring(int beginIndex,int endIndex)：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串

1. boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
2. boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
3. boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
4. boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
5. int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
6. int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
7. int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
8. int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

注：indexOf和lastIndexOf方法如果未找到都是返回-1

替换：
1. String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
2. String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
3. String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
4. String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

匹配:
1.boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。

切片：
1. String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
2. String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

//1.直接创建方式
String str1 = "abc";
//2.提供一个 字符数组 参数来初始化字符串
char[] strarray = {'a','b','c'};
String str2 = new String(strarray);



1.字符串长度获取
int length()方法：返回字符串对象包含的字符数

int len = str.length();


2.连接字符串
String concat(String str)：连接两个字符串的方法或者直接用‘+’操作符来连接
//String对象的连接

str1.concat(str2);

"两个字符串连接结果："+str1+str2; 


3.字符串查找
int indexOf(String s)：字符串s在指定字符串中首次出现的索引位置，如果没有检索到字符串s，该方法返回-1
int lastIndexOf(String s)：字符串s在指定字符串中最后一次出现的索引位置，如果没有检索到字符串s，该方法返回-1；如果s是空字符串，则返回的结果与length方法的返回结果相同，即返回整个字符串的长度

int idx = str.indexOf("a");//字符a在str中首次出现的位置
int idx = str.lastIndexOf("a");


4.获取指定位置的字符串
char charAt(int index)方法：返回指定索引出的字符

String str = "abcde";
char thischar = str.charAt(3);//索引为3的thischar是"d"


5.获取子字符串
String substring()方法：实现截取字符串，利用字符串的下标索引来截取(字符串的下标是从0开始的，在字符串中空格占用一个索引位置)
substring(int beginIndex)：截取从指定索引位置开始到字符串结尾的子串
substring(int beginIndex, int endIndex)：从beginIndex开始，到endIndex结束(不包括endIndex)

String str = "abcde";
String substr1 = str.substring(2);//substr1为"cde"
String substr2 = str.substring(2,4);//substr2为"cd"


6.去除字符串首尾的空格()
String trim()方法 去除字符串首尾的空格()

String str = " ab cde ";
String str1 = str.trim();//str1为"ab cde"


7.字符串替换
String replace(char oldChar, char newChar)：将指定的字符/字符串oldchar全部替换成新的字符/字符串newChar
String replaceAll(String regex, String replacement)：使用给定的参数 replacement替换字符串所有匹配给定的正则表达式的子字符串
String replaceFirst(String regex, String replacement)：使用给定replacement 替换此字符串匹配给定的正则表达式的第一个子字符串
regex是正则表达式，替换成功返回替换的字符串，替换失败返回原字符串

String str = "abcde";
String newstr = str.replace("a","A");//newstr为"Abcde"


8.判断字符串的开始与结尾
boolean startsWith(String prefix)：判断此字符串是否以指定的后缀prefix开始
boolean startsWith(String prefix, int beginidx)：判断此字符串中从beginidx开始的子串是否以指定的后缀prefix开始
boolean endsWith(String suffix)：判断此字符串是否以指定的后缀suffix结束

String str = "abcde";
boolean res = str.startsWith("ab");//res为true
boolean res = str.StartsWith("bc",1);//res为true
boolean res = str.endsWith("de");//res为true


9.判断字符串是否相等
boolean equals(Object anObject)：将此字符串与指定的对象比较，区分大小写
boolean equalsIgnoreCase(String anotherString)：将此 String 与另一个 String 比较，不考虑大小写

String str1 = "abcde";
String str2 = str1;//字符串str1和str2都是一个字符串对象
String str3 = "ABCDE";
boolean isEqualed = str1.equals(str2);//返回true
boolean isEqualed = str1.equals(str3);//返回false
boolean isEqualed = str1.equlasIgnoreCase(str3);//返回true



10.比较两个字符串
int compareTo(Object o)：把这个字符串和另一个对象比较。
int compareTo(String anotherString)：按字典顺序比较两个字符串。
比较对应字符的大小(ASCII码顺序)，如果参数字符串等于此字符串，则返回值 0；如果此字符串小于字符串参数，则返回一个小于 0 的值；如果此字符串大于字符串参数，则返回一个大于 0 的值。

String str1 = "abcde";
String str2 = "abcde123";
String str3 = str1;
int res = str1.compareTo(str2);//res = -3
int res = str1.compareTo(str3);//res = 0
int res = str2.compareTo(str1);//res = 3


11.把字符串转换为相应的数值

String转int型
//第一种
int i = Integer.parseInt(String str)
//第二种
int i = Integer.valueOf(s).intValue();

String转long型
long l = Long.parseLong(String str);

String转double型：
double d = Double.valueOf(String str).doubleValue();//doubleValue()不要也可
double d = Double.parseDouble(str);

int转string型
//第一种
String s = String.valueOf(i)；
//第二种
String s = Integer.toString(i);
//第三种
String s = "" + i;


12.字符大小写转换
String toLowerCase()：将字符串中的所有字符从大写字母改写为小写字母
String toUpperCase()：将字符串中的所有字符从小写字母改写为大写字母

String str1 = "abcde";
String str2 = str1.toUpperCase();//str2 = "ABCDE";
String str3 = str2.toLowerCase();//str3 = "abcde";


13.字符串分割
String[] split()：根据匹配给定的正则表达式来拆分字符串，将分割后的结果存入字符数组中。
String[] split(String regex)：regex为正则表达式分隔符, . 、 $、 | 和 * 等转义字符，必须得加 \\；多个分隔符，可以用 | 作为连字符。
String[] split(String regex, int limit)：limit为分割份数

String str = "Hello World A.B.C"
String[] res = str.split(" ");//res = {"Hello","World","A.B.C"}
String[] res = str.split(" ",2);//res = {"Hello","World A.B.C"}
String[] res = str.split("\\.");//res = {"Hello World A","B","C"}

String str = "A=1 and B=2 or C=3"
String[] res = str.split("and|or");//res = {"A=1 "," B=2 "," C=3"}


13.字符数组与字符串的转换
public String(char[] value) ：通过char[]数组来创建字符串
char[] toCharArray()：将此字符串转换为一个新的字符数组

String str = "abcde";
char mychar[] = str.toCharArray();//char[0] = 'a'; char[1] = 'b'...


14.字符串与byte数组的转换
byte[] getBytes()

byte[] getBytes()：使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
byte[] getBytes(String charsetName)：使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中

byte[] Str2 = Str1.getBytes();

StringBuffer&StringBuilder

与String类最大的不同在于这两个类可以对字符串进行修改。
StringBuilder相较StringBuffer来说速度较快，多数情况下使用StringBuilder，但是StringBuilder的方法不是线性安全的（不能同步访问），所以在应用程序要求线程安全的情况下，必须使用StringBuffer

String、StringBuffer、StringBuilder三者的异同？

String:不可变的字符序列；底层使用char[]存储
StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

创建StringBuffer字符串

StringBuffer str = new StringBuffer("");

常用方法

1.StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
2.StringBuffer delete(int start,int end)：删除指定位置的内容
3.StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
4.StringBuffer insert(int offset, xxx)：在指定位置插入xxx
5.StringBuffer reverse() ：把当前字符序列逆转
6.public int indexOf(String str)
7.public String substring(int start,int end):返回一个从start开始到end索引结束的左闭右开区间的子字符串
8.public int length()
9.public char charAt(int n )
10.public void setCharAt(int n ,char ch)
                                                         
增：append(xxx)
删：delete(int start,int end)
改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
查：charAt(int n )
插：insert(int offset, xxx)
长度：length();
遍历：for() + charAt() / toString()   

1.添加字符(最常用方法)
public StringBuffer append(String s)：将指定的字符串追加到字符序列中

str.append("abc");//此时str为“abc”


2.删除字符串中的指定字符
public delete(int start,int end)：移除此序列中的子字符串的内容
public deleteCharAt(int i)：删除指定位置的字符

str.delete(0,1);//此时str为“c”
str.deleteCharAt(str.length()-1);//删除最后一个字符


3.反转字符串
public StringBuffer reverse()

str.reverse();


4.替换字符串中内容
replace(int start,int end,String str)：用String类型的字符串str替换此字符串的子字符串中的内容

String s = "1";
str.replace(1,1,s);//此时str为"a1c"


5.插入字符
public insert(int offset, int i)：将int参数形式的字符串表示形式插入此序列中

str.insert(1,2);


6.字符串长度
int length()：返回长度（字符数）
void setLength(int new Length)：设置字符序列的长度

str.length();
str.setLength(4);


7.当前容量
int capacity()：获取当前容量
void ensureCapacity(int minimumCapacity)：确保容量小于指定的最小值

str.capacity();


8.将其转变为String
String toString()

str.toString();//将StringBuffer类型的序列转变为String类型的字符串


9.设置指定索引处的字符
void setCharAt(int index，char ch)：将给定索引处的字符设置为ch