06.JAVA常用类方法（StringBuilder与StringBuffer、Arrays与Array比较和常用方法+代码示例）

StringBuilder

基本介绍

概述：可变的字符串类，可视为一个容器，StringBuilder对象中的内容是可变的，也可称之为字符串缓冲类。其常用的成员方法根据有无返回值可以分为查询和删改两大类。

构造方法：StringBuilder( ) ； StringBuilder( str )

PS：StringBuilder 是 AbstractStringBuilder 类的子类，AbstractStringBuilder 的另一个子类是 StringBuffer，两个子类的常用方法基本相同，区别在于 StringBuffer 支持线程安全。

StringBuilder、StringBuffer和String区别：

	String	StringBuilder	StringBuffer
是否可变	否	可	可
线程安全	支持	不支持	支持
性能比较	最低	最高	适中

常用查询

概述：查询类方法有返回值的，都不对 stringBuilder 本身内容进行修改。

方法	描述
stringBuilder.length( )	返回 int，获取字符串的长度
stringBuilder.indexOf( str )	返回 int，返回 str 串在 stringBuilder 中首次出现的索引
stringBuilder.charAt( index )	返回 char，返回指定索引位置的字符
stringBuilder.substring( start, end )	返回 String，返回指定范围内的子字符串，前包后不包
stringBuilder.toString( )	返回 String，将 stringBuilder 类型转换为 String 类型
stringBuilder.reverse( )	反转字符串，将内元素顺序前后颠倒
stringBuilder.delete( start, end )	删除 stringBuilder 指定范围内的字符串，前包后不包
stringBuilder.append( str )	将指定字符串 str 追加到 stringBuilder 的末尾
stringBuilder.insert( offset, str )	从 offset 开始插入字符串 str
stringBuilder.replace( start, end, str )	用 str 替换 stringBuilder 指定范围内的字符串，前包后不包

// 使用有参构造器，将一个字符串转为 StringBuilder 对象
StringBuilder stringBuilder = new StringBuilder("Hello");

// 获取字符串长度，输出: 5
int length = stringBuilder.length();

// 获取指定索引位置的字符，出: l
char ch = stringBuilder.charAt(2);

// 获取子字符串，输出: lle
String substring = stringBuilder.substring(1, 4);

// 查找字符串第一次出现的索引位置，输出: Index of 'l': 2
int index = stringBuilder.indexOf("l");

常用删改

概述：即对 StringBuilder 变量本身进行操作，可以不设置用于接收返回值的变量（也可以设置）。

方法	描述
stringBuilder.reverse( )	反转字符串，将内元素顺序前后颠倒
stringBuilder.delete( start, end )	删除 stringBuilder 指定范围内的字符串，前包后不包
stringBuilder.append( str )	将指定字符串 str 追加到 stringBuilder 的末尾
stringBuilder.insert( offset, str )	从 offset 开始插入字符串 str
stringBuilder.replace( start, end, str )	用 str 替换 stringBuilder 指定范围内的字符串，前包后不包

// 创建一个空的 StringBuilder 对象
StringBuilder stringBuilder = new StringBuilder();

// 在 StringBuilder 中追加字符串，输出: Hello
stringBuilder.append("Hello");

// 反转字符串，输出：olleH
stringBuilder.reverse();

// 在指定位置插入字符串（先再次反转），输出: He---llo
stringBuilder.reverse().insert(2, "---");

// 替换指定范围内的字符串，输出: He123llo
stringBuilder.replace(2, 5, "123");

// 删除指定范围内的字符，输出: Hello
stringBuilder.delete(2, 5);

Arrays与Array

对比介绍

Arrays：全类名 java.util.Arrays，是一个实用工具类，提供了操作数组的静态方法，包括排序、比较、搜索、复制、填充、类型转换等操作，都有传入参数。

Array：全类名 java.lang.reflect.Array，是一个反射类，用于动态创建和操作数组。提供了用于创建新数组、获取和设置数组元素值、获取数组长度等方法，以及一些与数组相关的静态方法，如判断对象是否为数组、获取数组的组件类型等（通常需要使用反射技术）。

Array方法

方法	描述
Array.newInstance( Cla, len )	创建一个数组，元素类型为 Cla 类，长度为 len
Array.get( arr, index )	获取 arr 中索引为 index 的元素的值
Array.getLength( arr )	获取数组 arr 的长度
Array.getComponentType( Arr )	获取指定数组的组件类型，输入为类，
Array.set( arr, index, value)	将 arr 中索引为 index 的元素的值设为 value

import java.lang.reflect.Array;
public class ArrayExample {
    public static void main(String[] args) {
        int[] arr = new int[5];

        // 创建一个新的数组，长度为3
        int[] newArray = (int[]) Array.newInstance(int.class, 3);

        // 获取和设置数组元素值，获取并打印0索引处元素，输出: 10
        Array.set(arr, 0, 10);
        System.out.println((int) Array.get(arr, 0));

        // 获取数组长度，输出: length: 5
        int length = Array.getLength(arr);
        System.out.println("length: " + length); 

        // 获取数组的组件类型,输出: int；int
        Class<?> componentType1 = arr.getClass().getComponentType();
        // 或者
        Class<?> componentType2 = Array.getComponentType(arr.getClass());
        System.out.println(componentType1 + ";" + componentType2); 
    }
}

Arrays方法

概述：因为是一个实用工具类，即是对一个数组进行操作，因此一定有传入参数，方法直接通过类名进行调用（静态的）。

方法	描述
Arrays.equals( arr1, arr2 )	返回 boolean，判断数组 arr1 和 arr2 是否相等
Arrays.binarySearch( arr, key)	返回 int，在已排序 arr 中，用二分法获取指定元素 key 的索引
Arrays.sort( arr )	对 arr 数组进行排序，数组需实现 Comparable 接口
Arrays.fill( arr, value )	将 arr 数组中的所有元素的值都设置为指定的值 key
Arrays.copyOf( old, newLen )	将 old 数组复制到一个新数组中，并指定新数组的长度为 newLen
Arrays.asList( arr )	将数组转换为列表类型，返回 List
Arrays.toString( arr )	将数组转换为字符串类型，返回 String

import java.util.Arrays;
public class ArraysExample {
    public static void main(String[] args) {
        Integer[] arr = {5, 2, 8, 1, 9};

        // 对数组进行排序，结果：[1, 2, 5, 8, 9]
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr)); 

        // 在已排序的数组中使用二分查找算法搜索指定元素，结果：2
        int index = Arrays.binarySearch(arr, 5);
        System.out.println(index); 

        // 将一个数组复制到一个新数组中，结果：[1, 2, 5]
        Integer[] copiedArr = Arrays.copyOf(arr, 3);
        System.out.println(Arrays.toString(copiedArr)); 

        // 将数组中的所有元素设置为指定的值，结果：[0, 0, 0, 0, 0]
        Arrays.fill(arr, 0);
        System.out.println(Arrays.toString(arr)); 

        // 将数组转换为字符串形式输出
        String arrString = Arrays.toString(arr);

        // 比较两个数组是否相等，结果：true
        Integer[] arr1 = {1, 2, 3};
        Integer[] arr2 = {1, 2, 3};
        boolean isEqual = Arrays.equals(arr1, arr2);
        System.out.println(isEqual);

        // 将给定数组转换为固定大小的列表
        Integer[] arr3 = {1, 2, 3};
        List<Integer> list = Arrays.asList(arr3);
    }
}