Java中Arrays数组工具类怎么用

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

方法一览表

快速定位详细操作

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

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数组工具类怎么用”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注编程网精选频道！