Java中Arrays数组工具类怎么用

发布时间：2021-12-13 09:10:36 作者：小新
来源：亿速云阅读：120

小编给大家分享一下Java中Arrays数组工具类怎么用，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！

方法一览表

方法名	简要描述
asList()	返回由指定数组支持的固定大小的列表。
sort()	将数组排序（升序）
parallelSort()	将指定的数组按升序排序
binarySearch()	使用二分搜索法快速查找指定的值（前提是数组必须是有序的）
compare()	按字典顺序比较两个数组
compareUnsigned()	按字典顺序比较两个数组，将数字元素处理为无符号
copyOf()	填充复制数组
copyOfRange()	将数组的指定范围复制到新数组
equals()	比较两个数组
deepEquals()	比较两个数组深度
toString()	将数组转换为字符串
deepToString()	将一个多维数组转换为字符串
fill()	将指定元素填充给数组每一个元素
mismatch()	查找并返回两个数组之间第一个不匹配的索引，如果未找到则返回-1
parallelPrefix()	使用提供的函数对数组元素进行操作
parallelSetAll()	使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素
setAll()	使用提供的生成器函数设置指定数组的所有元素以计算每个元素

快速定位详细操作

接下来我用代码一一举例演示。

asList()

功能：返回由指定数组支持的固定大小的列表

参数：asList(T… a)

返回值：一个列表

代码示例：

@Test
    public void asListTest() {
        List<String> ss = Arrays.asList("hello", "world");
//        List<String> ss1 = Arrays.asList("hello", "world",1);   报错，类型必须一直（泛型）
        System.out.println(ss);  //[hello, world]
        
//        ss.add("java");  //UnsupportedOperationException  会报错
//        ss.remove(1);   //UnsupportedOperationException  会报错
        
        System.out.println(ss.get(0));  //hello
        ss.set(0, "java");
        System.out.println(ss);  //[java, world]

    }

注意

将这一数组转换为列表后，对应的列表是不支持添加和删除操作的，否则会报错
但可以修改和获取元素

toString() 和 deepToString()

功能：将数组转换为字符串

参数：待转化数组

返回值：转化后的字符串

代码示例：

@Test
    public void asListTest() {
        List<String> ss = Arrays.asList("hello", "world");
//        List<String> ss1 = Arrays.asList("hello", "world",1);   报错，类型必须一直（泛型）
        System.out.println(ss);  //[hello, world]
        
//        ss.add("java");  //UnsupportedOperationException  会报错
//        ss.remove(1);   //UnsupportedOperationException  会报错
        
        System.out.println(ss.get(0));  //hello
        ss.set(0, "java");
        System.out.println(ss);  //[java, world]

    }

sort() 和 parallelSort()

功能：都是将数组排序（默认升序，支持lambda，泛型）
参数：

sort(Object[] a[, int fromIndex, int toIndex])
或者sort(T[] a[, int fromIndex, int toIndex,] Comparator<? super T> c)
parallelSort(Object[] a[, int fromIndex, int toIndex])
或者parallelSort(T[] a[, int fromIndex, int toIndex,] Comparator<?
super T> c)

返回值：无

代码示例：

@Test
    public void sortTest() {
        String[] str = {"abc", "add", "java", "hello", "javascript"};
        int[] ii = {1, 8, 99, 222, 35};

        System.out.println(Arrays.toString(str));
        System.out.println(Arrays.toString(ii));

        //单参数情况
        //Arrays.sort(str);  默认全排，字母会按照字母表顺序
        //Arrays.sort(ii);
        //System.out.println(Arrays.toString(str));  //[abc, add, hello, java, javascript]
        //System.out.println(Arrays.toString(ii));  //[1, 8, 35, 99, 222]

        //多参数情况
        //Arrays.sort(str,2,4);   只排列指定范围内的
        //Arrays.sort(ii,2,4);
        //System.out.println(Arrays.toString(str));  //[abc, add, hello, java, javascript]
        //System.out.println(Arrays.toString(ii));  //[1, 8, 99, 222, 35]

        //可传入lambda表达式(多参数情况可指定开始结束位置)
//        Arrays.sort(str, (a, b) -> b.compareTo(a));  //降序
//        System.out.println(Arrays.toString(str));  //[javascript, java, hello, add, abc]


        //parallelSort()方法目前我实验感觉与sort()相差无几，基本相似
        Arrays.parallelSort(str);
        System.out.println(Arrays.toString(str));  //[abc, add, hello, java, javascript]

        Arrays.parallelSort(str,(a,b)->b.compareTo(a));
        System.out.println(Arrays.toString(str));  //[javascript, java, hello, add, abc]
    }

binarySearch()

功能：使用二分搜索法快速查找指定的值（前提是数组必须是有序的，支持lambda表达式，泛型）
参数：binarySearch(Object[] a[, int fromIndex, int toIndex], Object key)

返回值：有则返回对应下标，无则返回负值

代码示例：

@Test
    public void binarySearchTest() {
        int[] a = {1, 5, 7, 4, 6, 7, 8, 4, 9, 0};
        Arrays.sort(a);  //必须先排序
        System.out.println(Arrays.toString(a));
        //[0, 1, 4, 4, 5, 6, 7, 7, 8, 9]
        System.out.println(Arrays.binarySearch(a, 4));  //2
        System.out.println(Arrays.binarySearch(a, 11));  //-11
        //也可指定范围查找,其查找机制是折半查找，每次缩小一半范围
    }

compare() 和 compareUnsigned()

功能：按字典顺序比较两个数组

参数：

compare(T[] a, 【int aFromIndex, int aToIndex】, T[] b,【 int bFromIndex, int bToIndex】,【 Comparator<? super T> cmp】)

返回值：

如果第一个和第二个数组相等并且包含相同顺序的相同元素，则值为0 ;
如果第一个数组按字典顺序小于第二个数组，则值小于0 ;
如果第一个数组按字典顺序大于第二个数组，则值大于0

代码示例：

@Test
    public void compareTest() {
        int[] a = {1, 2, 3, 4};
        int[] b = {1, 2, 3, 4, 5};
        int[] c = {1, 2, 3, 4, 5};
        String[] s1 = {"java","hello","c++"};
        String[] s2 = {"java","hello"};

//        System.out.println(Arrays.compare(a,b));  //-1
//        System.out.println(Arrays.compare(b,a));  //1
//        System.out.println(Arrays.compare(b,c));  //0

        System.out.println(Arrays.compare(s1,s2));  //1
        //也可划定范围去比较，或者传入lambda



//        System.out.println(Arrays.compareUnsigned(s1,s2));//报错
        System.out.println(Arrays.compareUnsigned(a,b));  //-1
    }

注意

compareUnsigned()只能比较byte(),short(),int(),long()数字型数组，可以划定比较范围，但不支持lambda

copyOf() 和 copyOfRange()

功能：复制填充数组

参数：

copyOf(int[] original, int newLength)…
copyOf(T[] original, int newLength)
copyOfRange(int[] original, int from, int to）…
copyOfRange(T[] original, int from, int to)
copyOfRange(U[] original, int from, int to, 类<? extends T[]> newType)

返回值：复制填充后的数组

代码示例：

@Test
    public void copyOfTest() {

        //copyOf

        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
        int[] arr1 = Arrays.copyOf(arr, 5);  //拷贝长度为5，第二个参数为新数组的长度
        int[] arr2 = Arrays.copyOf(arr, 15);
        System.out.println(Arrays.toString(arr1));  //[1, 2, 3, 4, 5]
        System.out.println(Arrays.toString(arr2));  //[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0]

        arr[0] = 20;   //改变原数组
        System.out.println(Arrays.toString(arr));     //原数组改变
        System.out.println(Arrays.toString(arr1));   //复制后的数组不变

        String[] str = {"java","hello","world"};
        String[] str1 = Arrays.copyOf(str,2);
        String[] str2 = Arrays.copyOf(str,5);
        System.out.println(Arrays.toString(str1));  //[java, hello]
        System.out.println(Arrays.toString(str2));  //[java, hello, world, null, null]




        //copyOfRange()

        int[] arrs = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
        int[] arr3 = Arrays.copyOfRange(arrs,2,8);   //[3, 4, 5, 6, 7, 8]
        int[] arr4 = Arrays.copyOfRange(arrs,5,15);  //[6, 7, 8, 9, 0, 0, 0, 0, 0, 0]
        System.out.println(Arrays.toString(arr3));
        System.out.println(Arrays.toString(arr4));
        arrs[6] = 99;  //改变原数组
        System.out.println(Arrays.toString(arrs));   //[1, 2, 3, 4, 5, 6, 99, 8, 9, 0]  原数组改变
        System.out.println(Arrays.toString(arr3));   //[3, 4, 5, 6, 7, 8]  复制后的不会随着改变

    }

注意

copyOf()是从原数组0位置开始拷贝指定长度到新数组
copyOfRange()是从原数组中指定范围拷贝到新数组
如果指定长度或者范围超出原数组范围，则超出部分会补上此数据类型的默认值，如String类型会补null，int型会补0

equals()

功能：比较两个数组

参数：

equals(int[] a,【 int aFromIndex, int aToIndex】, int[] b,【 int bFromIndex, int bToIndex】)…
equals(T[] a, 【int aFromIndex, int aToIndex】, T[] b,【 int bFromIndex, int bToIndex】, Comparator<? super T> cmp)

返回值：boolean

代码示例：

@Test
    public void equalsTest() {
        int[] a = {1, 2, 3, 4, 5, 6};
        int[] b = {6, 5, 3, 4, 2, 1};

        System.out.println(Arrays.equals(a, b));   //false
        System.out.println(Arrays.equals(a, 2, 3, b, 2, 3));  //指定比较范围  true
    }

deepEquals()

功能：比较两个数组的深度

参数：deepEquals(Object[] a1, Object[] a2)

返回值：boolean

代码示例：

@Test
    public void deepEqualsTest() {
        String[] s1 = {"java", "hello", "c++"};
        String[] s2 = {"java", "hello"};
        String[] s3 = {"java", "hello", "c++"};
        System.out.println(Arrays.deepEquals(s1, s2));  //false
        System.out.println(Arrays.deepEquals(s1, s3));  //true

        String[][] s4 = {{"hello"}, {"java"}, {"c++"}, {"python"}};
        String[][] s5 = {{"hello"}, {"java"}, {"c++"}, {"python"}};
        System.out.println(Arrays.deepEquals(s4, s5));  //true
        System.out.println(Arrays.equals(s4, s5));    //false
        
        int[] a = {1,2};
        int[] b = {1,2};
//        System.out.println(Arrays.deepEquals(a,b));  //报错
        
    }

比较equals()和deepEquals()方法

相同点

两者都是比较数组是否相等的方法

不同点

equals默认从头比较到尾，也可以指定范围，但是deepEquals不能指定范围
可以比较多维数组，equals不能
deepEquals不支持比较基本类型数组，equals支持

fill()

功能：将指定元素填充给数组每一个元素

参数：fill(int[] a, 【int fromIndex, int toIndex】, int val)

返回值：无

代码示例：

@Test
    public void fillTest() {
        String[] a = {"a", "b", "c", "d", "e", "f"};
        System.out.println(Arrays.toString(a));  //[a, b, c, d, e, f]
        Arrays.fill(a, "java");
        System.out.println(Arrays.toString(a));  //[java, java, java, java, java, java]

        String[] b = {"a", "b", "c", "d", "e", "f"};
        System.out.println(Arrays.toString(b));  //[a, b, c, d, e, f]
        Arrays.fill(b, 2, 5, "java");
        System.out.println(Arrays.toString(b));  //[a, b, java, java, java, f]
        
        //默认全填充，也可以指定范围，会改变原数组
    }

mismatch()

功能：查找并返回两个数组之间第一个不匹配的索引，如果未找到则返回-1
参数：

mismatch(int[] a, 【int aFromIndex, int aToIndex】, int[] b,【 int bFromIndex, int bToIndex】)
mismatch(T[] a, 【int aFromIndex, int aToIndex】, T[] b,【 int bFromIndex, int bToIndex】, Comparator<? super T> cmp)

返回值：两个数组之间第一个不匹配的索引，未找到不匹配则返回-1。

代码示例：

@Test
    public void mismatchTest() {
        String[] s1 = {"java", "c++", "html", "css", "Javascript", "world"};
        String[] s2 = {"world", "c++", "html", "css", "Javascript"};
        System.out.println(Arrays.mismatch(s1, s2)); //0
        System.out.println(Arrays.mismatch(s1, 1, 4, s2, 1, 4));  //-1
        System.out.println(Arrays.mismatch(s1, 1, 5, s2, 1, 4));  //3

    }

parallelPrefix()

功能：使用提供的函数并行地累积给定数组的每个元素。
参数：

parallelPrefix(int[] array, 【int fromIndex, int toIndex】, IntBinaryOperator op)
parallelPrefix(T[] array, 【int fromIndex, int toIndex】, BinaryOperator op)

返回值：无

代码示例：

 @Test
    public void parallelPrefixTest() {
        String[] s1 = {"java", "c++", "html", "css", "Javascript", "world"};
        System.out.println(Arrays.toString(s1));   //[java, c++, html, css, Javascript, world]
        Arrays.parallelPrefix(s1, String::concat);
        System.out.println(Arrays.toString(s1));   //[java, javac++, javac++html, javac++htmlcss, javac++htmlcssJavascript, javac++htmlcssJavascriptworld]

        int[] a = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(a));  //[1, 2, 3, 4, 5]
        Arrays.parallelPrefix(a, (x, y) -> x * y);
        System.out.println(Arrays.toString(a));  //[1, 2, 6, 24, 120]
        Arrays.parallelPrefix(a, 2, 4, (x, y) -> x / y);
        System.out.println(Arrays.toString(a));  //[1, 2, 6, 0, 120]  也可指定范围
    }

setAll() 和 parallelSetAll()

功能：使用提供的生成器函数设置指定数组的所有元素以计算每个元素。
参数：

parallelSetAll(T[] array, IntFunction<? extends T> generator)
setAll(T[] array, IntFunction<? extends T> generator)

返回值：无

代码示例：

 @Test
    public void parallelPrefixTest() {
        String[] s1 = {"java", "c++", "html", "css", "Javascript", "world"};
        System.out.println(Arrays.toString(s1));   //[java, c++, html, css, Javascript, world]
        Arrays.parallelPrefix(s1, String::concat);
        System.out.println(Arrays.toString(s1));   //[java, javac++, javac++html, javac++htmlcss, javac++htmlcssJavascript, javac++htmlcssJavascriptworld]

        int[] a = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(a));  //[1, 2, 3, 4, 5]
        Arrays.parallelPrefix(a, (x, y) -> x * y);
        System.out.println(Arrays.toString(a));  //[1, 2, 6, 24, 120]
        Arrays.parallelPrefix(a, 2, 4, (x, y) -> x / y);
        System.out.println(Arrays.toString(a));  //[1, 2, 6, 0, 120]  也可指定范围
    }

以上是“Java中Arrays数组工具类怎么用”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注亿速云行业资讯频道！

Java中Arrays数组工具类怎么用

方法一览表

快速定位详细操作

asList()

toString() 和 deepToString()

sort() 和 parallelSort()

binarySearch()

compare() 和 compareUnsigned()

copyOf() 和 copyOfRange()

equals()

deepEquals()

比较equals()和deepEquals()方法

fill()

mismatch()

parallelPrefix()

setAll() 和 parallelSetAll()

相关阅读