Java中Arrays数组工具类的基本使用详解

更新时间：2021年12月12日 10:22:29 作者：soberw-

Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用" 而不是 "不能"),这篇文章主要给大家介绍了关于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 11之后新增的，或者我看漏的，文中如有错误，还请指出，大家一起进步！

总结

到此这篇关于Java中Arrays数组工具类的基本使用的文章就介绍到这了,更多相关Java Arrays数组工具类使用内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java 中 Class Path 和 Package的使用详解
这篇文章主要介绍了Java 中 Class Path和Package的使用详解，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的朋友可以参考一下
2022-08-08
基于Spring整合mybatis的mapper生成过程
这篇文章主要介绍了Spring整合mybatis的mapper生成过程，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2023-03-03
java字符串的合并
合并两个字符串，如：str1 ="001,002,003,004,006",str2 = "001,002,005" 合并后应该是"001,002,003,004,005,006"。
2008-10-10
Java中的三元运算(三目运算)以后用得到！
Java提供了一个三元运算符,可以同时操作3个表达式,下面这篇文章主要给大家介绍了关于Java中三元运算(三目运算)的相关资料,文中通过代码介绍的非常详细,需要的朋友可以参考下
2023-10-10
Java实现学生选课管理系统
这篇文章主要为大家详细介绍了Java实现学生选课管理系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-07-07
java使用Filter实现自动登录的方法
这篇文章主要为大家详细介绍了java使用Filter实现自动登录的方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2017-04-04
秒懂Java枚举类型(enum)
这篇文章主要介绍了秒懂Java枚举类型(enum),本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2020-12-12
springboot 通过博途获取plc点位的数据代码实现
这篇文章主要介绍了springboot 通过博途获取plc点位的数据的代码实现,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
2023-08-08
springboot X-Accel-Redirect 大文件下载实现
本文主要介绍了springboot X-Accel-Redirect 大文件下载实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-06-06
SpringBoot整合SpringSession实现分布式登录详情
这篇文章主要介绍了SpringBoot整合SpringSession实现分布式登录详情，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的朋友可以参考一下
2022-08-08