StringBuffer类

从String类的引入

以下代码会创建几个对象？ ------------5个对象

 String str="abc"; //"abc" str+="ccc"; //ccc //abcccc str+="dddd"; //"ddddd"   abccccddddd 

【分析】： 首先字符常量池创建对象abc，再创建ccc 为拼接后的结果创建对象abcccc ； 将str的引用指向abcccc 的地址；

我们如果对字符串进行拼接操作，每次拼接都会构建一个新的String对象，既耗时又浪费空间。而StringBuffer就可以解决这个问题，它是线程安全的可变字符序列。相当于一个字符容器，你可以不断的往容器中追加字符，在大量拼接字符串时，就可以使用长度可变的字符容器

StringBuffer类的构造方法

1. public StringBuffer(): 无参构造方法,构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符
2. public StringBuffer(int capacity): 指定容量的字符串缓冲区对象
3. public StringBuffer(String str): 指定字符串内容的字符串缓冲区对象

StringBuffer的成员方法：

1. public int capacity()：返回当前容量——理论值
2. public int length()：返回长度（字符数）——实际值
   注意：容器的长度length表示实际字符的个数，容量capacity表示容器的属性值（例如一个水杯容量500ml，装入100ml的水，容量依旧为500ml，长度就是100ml）

public class test1 { public static void main(String[] args) { //创建一个空的字符容器。 StringBuffer ss=new StringBuffer(); //获取容器的容量 一旦超过容量，可以自动扩容。 System.out.println(ss.capacity());//16 ss.append("1");//向容器中追加数据 System.out.println(ss.capacity());//16 //获取容器包含实际字符数：求容器的长度 System.out.println(ss.length());//1 ss.append("sssssssssssssssssssssssssssssss");//31个字符s //获取容器的容量 一旦超过容量，可以自动扩容。 System.out.println(ss.capacity());//34 System.out.println(ss.length());//32 //构建容器时，可以指定这个字符容器的容量 StringBuffer ss1=new StringBuffer(100); // 构建容器时，可以往容器中放入字符串 StringBuffer ss2=new StringBuffer("aaa"); } } 

StringBuffer的功能

• 容器对象实现某种功能返回字符串缓冲区本身是指：不创建新的对象返回的还是原来的那个容器对象，地址值不变。
• 只有截取功能与toString功能返回的类型是字符串，地址值改变。

添加功能

1. public StringBuffer append(String str): 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
2. public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

 //append("abc"); 往容器中追加数据，返回的还是原来的那个容器对象。 StringBuffer ss3=ss2.append("ssssss"); System.out.println(ss3 == ss2);//true // append :向容器中追加多种类型数据,可以采用链式不断追加数据 //拼串时使用字符串缓存区的append而不使用加号，不创建新对象并且可以拼接各种类型的字符串 StringBuffer ss4=ss3.append("aa").append(122).append(true).append(new char[]{'1', '2', '3'}); //StringBuffer重写了Object类的toString方法，不打印地址值，而是将所有数据整合为字符串的形式返回 System.out.println(ss4);//aaassssssaa122true123 

 //StringBuffer 里面的数据也是编有索引的。 StringBuffer sb = new StringBuffer("abc"); //在索引1处插入eee 返回原对象 sb.insert(1, "eee"); System.out.println(sb);////aeeebc 

删除功能

1. public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
2. public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身

接上段代码：

 //删除索引为0的字符 System.out.println(sb.deleteCharAt(0));//eeebc //根据起始索引和终止索引，删除容器中的一部分内容，返回的还是容器本身。 System.out.println(sb.delete(0, 2));//ebc  索引位置的查找包左不包右 //返回的还是容器本身 地址值不变 // System.out.println(sb==sb.delete(0,1));//true 

替换功能

1. public StringBuffer replace(int start,int end,String str): 从start开始到end用str替换

//根据起始索引和终止索引，替换容器中的一部分内容。返回的还是容器本身。 System.out.println(sb.replace(0, 2, "scq"));//scqc 索引位置的查找包左不包右 

查找功能

1. int indexOf (String str) 从头查找该字符串，在容器中第一次出现的索引，如果找不到就返回-1
2. int indexOf (String str,int fromIndex) 从指定索引处开始查找该字符串第一次出现的索引，如果找不到就返回-1
3. int lastIndexOf (String str) 从后往前找
4. int lastIndexOf (String str,int fromIndex)

 //查找容器中该字符串第一次出现的索引，如果查找不到返回-1 System.out.println(sb.indexOf("e"));//0 

反转功能

1. public StringBuffer reverse(): 字符串反转

//反转,返回的还是容器本身 System.out.println(sb.reverse());//cqcs 

截取功能

1.public String substring(int start): 从指定位置截取到末尾
2. public String substring(int start,int end): 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

截取功能的注意事项

• 返回值类型不再是StringBuffer本身，而是一个字符串

 //根据起始索引和 终止索引，截取容器中一部分内容返回，注意返回的是String类型 使用字符串类接收 // 注意：substring返回的是一个字符串类型，不对原对象sb做出任何改变 String s1=sb.substring(0, 2); System.out.println(sb);//cqcs 没有改变 System.out.println(s1);//cq 索引位置的查找包左不包右 

StringBuffer和String的相互转换

String --> StringBuffer

1. 通过构造方法
2. 通过append()方法 空容器添加字符串
3. 通过insert()方法 空容器在0位置插入字符串

 String str="beauty"; //方式一:通过StringBuffer的构造方法传入字符串，转换为StringBuffer类型 StringBuffer ss1 = new StringBuffer(str); //方式二：通过StringBuffer的append方法追加字符串，就将一个字符串转换为StringBuffer类型 StringBuffer ss2=new StringBuffer().append(str); System.out.println(ss2);//beauty  //方式三：通过StringBuffer的insert方法按照指定位置插入字符串，将一个字符串转换为StringBuffer类型 StringBuffer ss3=new StringBuffer().insert(0,str); //toString方法返回值是一个字符串类型并将返回值打印出来， //但是ss3本身是一个StringBuffer类型，没有改变 System.out.println(ss3);//beauty 是一个字符串 

StringBuffer --> String

1. 使用substring方法
2. 通过String 类构造方法
3. 通过toString()方法

 //方式一： StringBuffer的toString方法是所有数据整合以字符串的形式返回 String str1=ss3.toString(); //方式二：StringBuffer的substring方法根据索引值 // 截取容器一部分内容或者全部，以字符串的形式返回 String str2=ss3.substring(0);//截取全部 System.out.println(str2);//beauty //方式三：String 类中有一个构造方法 直接将容器转换为字符串 String str4=new String(ss3); 

小练习：
一、把数组转成字符串
int[] arr = {1, 2, 3};
输出结果： “[1, 2, 3]”

 int[] arr = {1,2}; //方法一： //StringBuffer ss6=new StringBuffer(); //System.out.println(new StringBuffer().append('[').append(1).append(',').append(2).append(']')); //方法二： //注意： StringBuffer的构造方法中输入字符串类型来当做字符串容器， //其余类型例如字符型均会转为数值作为定义容器容量的值 int[] arr = {1,2}; StringBuffer str=new StringBuffer("["); for (int i = 0; i < arr.length; i++) { if (i==arr.length-1) str=str.append(arr[i]).append(']'); else str=str.append(arr[i]).append(','); } System.out.println(str); } } 

二、字符串的反转
键盘录入"abc"
输出结果：“cba”

//对一个字符串进行反转,toString()返回一个字符串类型 sout下默认可以不写 //System.out.println(new StringBuffer("abc").reverse());//cba System.out.println(new StringBuffer("abc").reverse().toString());//cba 

StringBuffer和StringBuilder的区别

StringBuffer

• StringBuffer （单线程）线程安全的字符序列，效率低

• 适用于多线程下大量数据，效率低，线程安全；

StringBuilder

• StringBuffer （多线程）线程不安全的字符序列，效率高
• 此类提供一个与 StringBuffer 兼容的 API，但不保证同步。
• 适用于单线程下大量数据，效率高，线程非安全；

String和StringBuffer分别作为参数传递

• String类虽然是引用类型，但是创建的对象字符串，长度一旦被定义就不可以改变，是一个常量，所以在做传递的时候，完全可以将其看成基本数据类型数据进行传递，属于值传递。会这把字符串的值传递过去
• StringBuffer类作为参数传递 是引用类型传递，形参的改变会影响实参。

public class MyTest { public static void main(String[] args) { String str = "abc"; change(str); System.out.println(str);//abc  StringBuffer sb = new StringBuffer("Hello"); change(sb); sb.reverse(); System.out.println(sb); //呵呵哈哈olleH } //引用类型作为参数传递，形参的改变会影响实参。 private static void change(StringBuffer sb) { sb.append("哈哈").append("呵呵"); } //注意：String 类型作为参数传递，属于值传递。会这把字符串的值传递过去 private static void change(String str) { str+="你好"; System.out.println(str); //abc你好 } } 

Arrays类

针对数组进行操作的工具类。提供了排序，查找等功能。

Aarrays的成员方法

public static String toString(int[] a) ： 把数组中的元素，转换成一个漂亮字符串。

int[] arr={10,20,30}; String s = Arrays.toString(arr); System.out.println(s);//[10,20,30] 

二分查找前：数组元素必须有序
public static void sort(int[] a) ： 排序
public static int binarySearch(int[] a,int key) ： 二分法查找指定byte类型数组中的元素位置

 int[] arr = {20, 20, 6, 8, 9, 1, 2, 3, 4, 90, 100, 3, 0, -1, -2, 6, 9}; Arrays.sort(arr); System.out.println(Arrays.toString(arr)); //[-2, -1, 0, 1, 2, 3, 3, 4, 6, 6, 8, 9, 9, 20, 20, 90, 100] //二分查找:数组元素必须有序 char[] chars={'a','b','a','c'}; Arrays.sort(chars);//sort方法返回为空 ,但是对于原数组已经排列。 System.out.println(chars); //aabc System.out.println(Arrays.binarySearch(chars, 'a')); //1 返回中间的索引 

static boolean equals(int[] a, int[] a2) ： 比较两个数组的长度与各个数组的元素对应位置是否相同

//定义两个数组元素相同，数组长度相同，但是元素对应位置不同，所以两个数组不相等 int[] arr = {20, 20, 6, 8}; int[] arr2 = {6, 20, 20, 8}; //比较两个数组中的元素是否一样。 boolean b = Arrays.equals(arr, arr2); System.out.println(b);//false  int[] arr =null; int[] arr2=null;//arr与arr2的地址值均为null 因此相等 System.out.println(Arrays.equals(arr, arr2));//true 

static int[] copyOf(int[] original, int newLength) ： 复制旧数组中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制旧数组
static int[] copyOfRange(int[] original, int from, int to)： 复制旧数组中的指定范围间的几个元素到新数组中

 int[] arr = {20, 20, 6, 8,20,30,50,60}; // 从0开始复制旧数组 指定新数组长度 int[] ints = Arrays.copyOf(arr, 3); //打印数组直接调用toStrng方法 不需要再遍历 System.out.println(Arrays.toString(ints));//[20, 20, 6] //3 起始索引，6 终止索引 含头不含尾 int[] ints1 = Arrays.copyOfRange(arr, 3, 6); System.out.println(Arrays.toString(ints1));//[8, 20, 30]  索引包左不包右 

本文地址：https://blog.csdn.net/qq_44241861/article/details/107684084

如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！