JAVASE-12：StringBuffer和Arrays类常用方法和功能

1. 字符串缓冲区 StringBuffer

用+拼串效果不好 浪费时间和空间 因为字符串一单定义长度不能改变。

StringBuffer - - 线程安全的可变字符序列。相当于一个字符容器，可以不断地往容器中追加字符。

1.1 常用方法 功能

new StringBuffer() ：构造一个其中不带字符的字符串缓冲区 容量默认为16个字符

容器名.capacity()：获取容器容量 --16，一旦超过容量会自动扩容

容器名.length()：获取容器长度

容器名.append()：向容器中追加内容

new StringBuffer(100)：构造一个其中不带字符的字符串缓冲区 指定容量为100个字符

new StringBuffer(“asdasfasdw”)：构造一个其中带字符"asdasfasdw"的字符串缓冲区

容器名.toString()：StringBuffer重写了toString方法，然后把容器中的数据转换成字符串返回

public class MyTest2 {
    public static void main(String[] args) {
        /* StringBuffer();
        构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。*/

        //创建一个空的字符容器
        StringBuffer sb = new StringBuffer();
        //往容器中追加数据
        sb.append("abcaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
        //获取容器的容量 一旦超过容量，可以自动扩容
        int capacity = sb.capacity();
        System.out.println(capacity);// 57
        //获取容器的长度
        int length = sb.length();
        System.out.println(length);// 57

        //构建时，可以指定这个字符容器的容量
        StringBuffer sb1 = new StringBuffer(100);
        System.out.println(sb.capacity());

        //构建容器时，可以往容器中放入字符串
        StringBuffer sb2= new StringBuffer("abbcdfdfd");
        System.out.println(sb2.toString());//abbcdfdfd
        
        StringBuffer sb3 = new StringBuffer();
        //append("abc"); 往容器中追加数据，返回的还是原来的那个容器对象。
        StringBuffer sb4 = sb.append("abc");

        System.out.println(sb3==sb4);//true
        sb3.append(100).append(200).append(true).append(new char[]{'a','b','c'});
        //StringBuffer 重写了toString()方法，然后把容器中的数据转换成字符串返回
   		System.out.println(sb3.toString());//"abc100200trueabc"
    }
}

容器名.insert(索引，要追加的内容)：指定索引前向容器中追加内容

public class MyTest {
    public static void main(String[] args) {
        //StringBuffer 里面的数据也是编有索引的。
        StringBuffer sb = new StringBuffer("abc");
        sb.append("bbb").append("ccc");
        //insert(0, "eeee");  在容器中的指定位置，插入数据，返回的还是原来的容器。
        StringBuffer sb2 = sb.insert(1, "eeee");
        System.out.println(sb.toString());//aeeeebcbbbccc
        System.out.println(sb2.toString());//aeeeebcbbbccc
    }
}

容器名.deleteCharAt(索引)：删除索引处数据

容器名.delete(开始索引，结束索引)：删除某一段数据

容器名.indexOf(字符)：查找某个字符在字符串中第一次出现的索引，找不到则返回-1

容器名.replace(开始索引，结束索引，要替换的内容)：指定索引替换容器中的一部分内容

容器名.reverse()：反转

subString()：根据起止索引截取，返回值是String而不是容器本身了

1.2 String转换成StringBuffer

String str="abc";
//方式1：
StringBuffer sb = new StringBuffer(str);
//方式2：
StringBuffer sb2 = new StringBuffer();
sb2.append(str);
//方式3：
StringBuffer sb3 = new StringBuffer();
sb3.insert(0,str);

1.3 StringBuffer转换成String

StringBuffer sb4 = new StringBuffer("aaaaa");
//方式1：toString()
String s = sb4.toString();
//方式2：
String s1 = sb4.substring(0);
 //String 类中有一个构造方法
 String s2 = new String(sb4);

1.4 参数传递：String类型作为参数传递，还是属于值传递，会传递字符串的值

public class MyTest {
    public static void main(String[] args) {
        //引用类型作为参数传递，形参的改变会影响实参。
        String str = "abc";
        change(str);
        System.out.println(str);// 2.abc
        StringBuffer sb = new StringBuffer("Hello");
        change(sb);
        sb.reverse();
        System.out.println(sb);  // 3.呵呵哈哈olleH
    }

    private static void change(StringBuffer sb) {
        sb.append("哈哈").append("呵呵");
    }
    private static void change(String str) {
        str+="你好";
        System.out.println(str); // 1.abc你好
    }
}

1.5 StringBuilder和StringBuffer的区别：

StringBuffer 属于线程安全的字符序列

StringBuilder 线程不安全，但是效率更高

案例演示：把数组中的数据按照指定个格式拼接成一个字符串
举例：int[] arr = {1, 2, 3};
输出结果："[1, 2, 3]

package org.westos.demo;
public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        StringBuffer sb = new StringBuffer("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                sb.append(arr[i]).append("]");
            }else{
                sb.append(arr[i]).append(",");
            }
        }
        String s = sb.toString();
        System.out.println(s); // [1,2,3]
    }
}

---

---

2.Arrays类

工具类，方便操作数组。

Arrays.toString(arr); 把数组中的元素，转换成一个漂亮字符串

Arrays.sort(arr); 对数组排序

Arrays.binarySearch(arr,100); 二分查找所搜指定数组，以获得指定对象，数组元素必须有序，该方法返回要搜索元素的索引值

arr-要搜索的数组，100-要搜索的值

package org.westos.demo;
import java.util.Arrays;
public class MyTest {
    public static void main(String[] args) {
        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]
        int index = Arrays.binarySearch(arr, 6);
        System.out.println(index);//8
    }
}

Arrays.equals(arr1,arr2);比较两个数组是否相等，比较两个数组中的元素是否一样。

package org.westos.demo;
import java.util.Arrays;
public class MyTest {
    public static void main(String[] args) {
        int[] arr = {20, 20, 6, 8};
        int[] arr2 = {20, 20, 6, 8};
        boolean b = Arrays.equals(arr, arr2);
        System.out.println(b);//true
    }
}

Arrays.copyOf(要拷贝的数组，新的数组长度); 拷贝某个数组

Arrays.copyOfRange(要拷贝的数组，开始索引，终止索引); 拷贝开始索引，终止索引中间的元素，含头不含尾

package org.westos.demo;
import java.util.Arrays;
public class MyTest {
    public static void main(String[] args) {
        int[] arr = {20, 20, 6, 8,20,30,50,60};
        int[] ints = Arrays.copyOf(arr, 3);
        System.out.println(Arrays.toString(ints));//[20, 20, 6]
        int[] ints1 = Arrays.copyOfRange(arr, 3, 6);
        System.out.println(Arrays.toString(ints1));//[8, 20, 30]
    }
}