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

⽬录

⽅法⼀览表快速定位详细操作

asList()toString() 和 deepToString()sort() 和 parallelSort()binarySearch()compare() 和 compareUnsigned()copyOf() 和 copyOfRange()equals()deepEquals()⽐较equals()和deepEquals()⽅法 fill()mismatch()parallelPrefix()setAll() 和 parallelSetAll()总结

⽅法⼀览表

⽅法名asList()sort()parallelSort()binarySearch()compare()compareUnsigned()

copyOf()copyOfRange()

equals()deepEquals()toString()deepToString()

fill()mismatch()parallelPrefix()parallelSetAll()

setAll()

简要描述

返回由指定数组⽀持的固定⼤⼩的列表。

将数组排序（升序）将指定的数组按升序排序

使⽤⼆分搜索法快速查找指定的值（前提是数组必须是有序的）

按字典顺序⽐较两个数组

按字典顺序⽐较两个数组，将数字元素处理为⽆符号

填充复制数组

将数组的指定范围复制到新数组

⽐较两个数组⽐较两个数组深度将数组转换为字符串将⼀个数组转换为字符串将指定元素填充给数组每⼀个元素

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

使⽤提供的函数对数组元素进⾏操作

使⽤提供的⽣成器函数并⾏设置指定数组的所有元素以计算每个元素使⽤提供的⽣成器函数设置指定数组的所有元素以计算每个元素

快速定位详细操作

接下来我⽤代码⼀⼀举例演⽰。

asList()

功能：返回由指定数组⽀持的固定⼤⼩的列表参数：asList(T… a)返回值：⼀个列表代码⽰例：

@Test

public void asListTest() {

List ss = Arrays.asList(\"hello\

// List ss1 = Arrays.asList(\"hello\报错，类型必须⼀直（泛型） 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 ss = Arrays.asList(\"hello\

// List ss1 = Arrays.asList(\"hello\报错，类型必须⼀直（泛型） 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 c)parallelSort(Object[] a[, int fromIndex, int toIndex])

或者parallelSort(T[] a[, int fromIndex, int toIndex,] Comparator c)返回值：⽆代码⽰例：

@Test

public void sortTest() {

String[] str = {\"abc\ 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 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\ String[] s2 = {\"java\

// 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, 类 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\ 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 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\ String[] s2 = {\"java\

String[] s3 = {\"java\

System.out.println(Arrays.deepEquals(s1, s2)); //false System.out.println(Arrays.deepEquals(s1, s3)); //true String[][] s4 = {{\"hello\ String[][] s5 = {{\"hello\ 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\

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\

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 cmp)返回值：两个数组之间第⼀个不匹配的索引，未找到不匹配则返回-1。代码⽰例：

@Test

public void mismatchTest() {

String[] s1 = {\"java\ String[] s2 = {\"world\ 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\

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 generator)setAll(T[] array, IntFunction generator)返回值：⽆代码⽰例：

@Test

public void parallelPrefixTest() {

String[] s1 = {\"java\

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数组⼯具类使⽤内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！