一、Arrays.asList( )方法
1）作用
把 数组类型 转换成 List类型
2）参数与返回值
返回值为 List<T> 类型
Arrays.asList(T... a)方法
【T... a为动态参数，可以写很多个】
【T为任意类型】
【蓝色字体为参数，紫色字体为返回值类型】
asList(T... a): List<T>-Arrays
3）举例
程序如下：
import java.util.Arrays;
import java.util.List;
public class L {
public static void main(String[] args) {
//"小乔","大乔","小爱" 为动态参数（String类型的）
List<String> a = Arrays.asList("小乔","大乔","小爱");
System.out.println("输出List类型a的值："+a);
}
}
运行结果如下：
输出List类型a的值：[小乔, 大乔, 小爱]
二、Arrays.toString( )方法
1）作用
快速打印数组内容
2）参数与返回值
Arrays.toString( )方法【以下表格是它的所有重载方法】
【蓝色字体为参数，紫色字体为返回值类型】
toString(boolean[] a): String-java.util.Arrays toString(byte[] a): String-java.util.Arrays toString(char[] a): String-java.util.Arrays toString(double[] a): String-java.util.Arrays toString(float[] a): String-java.util.Arrays toString(int[] a): String-java.util.Arrays toString(long[] a): String-java.util.Arrays toString(Object[] a): String-java.util.Arrays toString(short[] a): String-java.util.Arrays 上表可得： 返回值类型均为String类型
3）举例
程序如下：
import java.util.Arrays;
public class DaYin {
public static void main(String[] args) {
//定义字符串数组 name
String[] name = {"小明","小红","小芳"};
//定义int类型数组 age
int[] age = {12,11,13};
//定义double类型数组 grade
double[] grade = {98.7,99.5,96.9};
//使用Arrays工具类下的Arrays.toString()方法快速打印数组内容
System.out.println("数组 name："+Arrays.toString(name));
System.out.println("数组 age："+Arrays.toString(age));
System.out.println("数组 grade："+Arrays.toString(grade));
}
}
运行结果如下：
数组 name：[小明, 小红, 小芳]
数组 age：[12, 11, 13]
数组 grade：[98.7, 99.5, 96.9]
三、 Arrays.fill( )方法
1）作用
快速填充数组元素；快速替换数组元素
2）参数与返回值
Arrays.fill( )方法【以下表格是它的所有重载方法】
【val 表示去填充或者去替换的值】{int val 就表示一个int类型数}
【int fromIndex 表示部分要进行排序的数组元素开始下标位置】
【int toIndex 表示部分要进行排序的数组元素截止下标位置】
【蓝色字体为参数，紫色字体为返回值类型】
fill(boolean[] a, boolean val): void-java.util.Arrays fill(byte[] a, byte val): void-java.util.Arrays fill(char[] a, char val): void-java.util.Arrays fill(double[] a, double val): void-java.util.Arrays fill(float[] a, float val): void-java.util.Arrays fill(int[] a, int val): void-java.util.Arrays fill(long[] a, long val): void-java.util.Arrays fill(Object[] a, Object val): void-java.util.Arrays fill(short[] a, short val): void-java.util.Arrays fill(boolean[] a, int fromIndex , int toIndex , boolean val): void-java.util.Arrays fill(byte[] a, int fromIndex , int toIndex , byte val): void-java.util.Arrays fill(char[] a, int fromIndex , int toIndex , char val): void-java.util.Arrays fill(double[] a,int fromIndex , int toIndex , double val): void-java.util.Arrays fill(float[] a, int fromIndex , int toIndex ,float val): void-java.util.Arrays fill(int[] a, int fromIndex , int toIndex ,int val): void-java.util.Arrays fill(long[] a, int fromIndex , int toIndex ,long val): void-java.util.Arrays fill(Object[] a, int fromIndex , int toIndex ,Object val): void-java.util.Arrays fill(short[] a, int fromIndex , int toIndex ,short val): void-java.util.Arrays 上表可得： 返回值类型均为void类型
3）举例
程序如下
import java.util.Arrays;
public class F {
public static void main(String[] args) {
//快速填充数组元素
//定义一个int类型的数组array
int[] array = new int[8];//默认值为0
System.out.println("长度为8的int型数组array："+Arrays.toString(array));
//给array数组填充7为它的元素
Arrays.fill(array, 7);
System.out.println("array填充后："+Arrays.toString(array));
//替换数组元素
//定义一个int类型的数组 ns
int[] ns = {1,3,5,7,9};
System.out.println("ns数组"+Arrays.toString(ns));
//将ns元素全部替换为2
Arrays.fill(ns, 2);
//输出元素替换后的ns数组
//此时ns数组已经变成[2, 2, 2, 2, 2]
System.out.println("ns数组元素全部替换为2: "+Arrays.toString(ns));
//将ns元素【下标2到下标5(不包括5)】位置元素全部替换为6
Arrays.fill(ns, 2, 5, 6);
System.out.println("ns数组下标2到下标5位置元素全部替换为6: "+Arrays.toString(ns));
}
}
运行结果如下：
长度为8的int型数组array：[0, 0, 0, 0, 0, 0, 0, 0]
array填充后：[7, 7, 7, 7, 7, 7, 7, 7]
ns数组[1, 3, 5, 7, 9]
ns数组元素全部替换为2: [2, 2, 2, 2, 2]
ns数组下标2到下标5位置元素全部替换为6: [2, 2, 6, 6, 6]
四、 Arrays.copyOf( )方法
1）作用
复制数组内容（从头元素开始复制）
2）参数与返回值
综上表可得：返回值类型与被复制数组类型一致
Arrays.copyOf( )方法【以下表格是它的所有重载方法】
【original 表示数组名称 】
【newLength 表示数组要被复制的长度】
【T[] 表示任意类型数组】
【蓝色字体为参数，紫色字体为返回值类型】
copyOf(boolean[] original , int newLength): boolean[] - Arrays copyOf(byte[] original , int newLength): byte[] - Arrays copyOf(char[] original , int newLength): char[] - Arrays copyOf(double[] original , int newLength): double[] - Arrays copyOf(float[] original , int newLength): float[] - Arrays copyOf(int[] original , int newLength): int[] - Arrays copyOf(long[] original , int newLength): long[] - Arrays copyOf(short[] original , int newLength): short[] - Arrays copyOf(T[] original , int newLength): T[] - Arrays
3）举例
程序如下：
import java.util.Arrays;
public class copy {
public static void main(String[] args) {
//目的,复制数组元素到新的数组
//定义一个int类型的数组 ns
int[] ns = {1,3,5,7,9};
//复制数组ns的前两位元素到arr1
//Arrays.copyOf(ns, 2)，==>返回值为数组类型
//ns为需要被复制的数组名称
//2为需要从数组第一个元素开始数，需要复制的元素个数
int[] arr1 = Arrays.copyOf(ns, 2);
System.out.println("复制前两位元素："+Arrays.toString(arr1));
//复制数组ns的所有元素到array
//ns.length是数组ns的长度，返回int类型值
int[] array = Arrays.copyOf(ns, ns.length);
System.out.println("复制所有元素："+Arrays.toString(array));
}
}
运行结果如下：
复制前两位元素：[1, 3]
复制所有元素：[1, 3, 5, 7, 9]
五、Arrays.copyOfRange( )方法
1）作用
复制数组内容（自由选择下范围复制）
2）参数与返回值
综上表可得：返回值类型与被复制数组类型一致
Arrays.copyOfRange( )方法【以下表格是它的所有重载方法】
【original 表示数组名称 】
【int from 表示部分要进行排序的数组元素开始下标位置】
【int to 表示部分要进行排序的数组元素截止下标位置】
【T[] 表示任意类型数组】
【蓝色字体为参数，紫色字体为返回值类型】
copyOfRange(boolean[] original , int from , int to ): boolean[] - Arrays copyOfRange(byte[] original , int from , int to ): byte[] - Arrays copyOfRange(char[] original , int from , int to ): char[] - Arrays copyOfRange(double[] original , int from , int to ): double[] - Arrays copyOfRange(float[] original , int from , int to ): float[] - Arrays copyOfRange(int[] original , int from , int to ): int[] - Arrays copyOfRange(long[] original , int from , int to ): long[] - Arrays copyOfRange(short[] original , int from , int to ): short[] - Arrays copyOfRange(T[] original , int from , int to ): T[] - Arrays
3）举例
程序如下：
import java.util.Arrays;
public class copy {
public static void main(String[] args) {
//目的,复制数组元素到新的数组
//定义一个int类型的数组 ns
int[] ns = {1,3,5,7,9};
//复制数组ns的【第2个元素到第4个元素】到arr2
//【第2个元素到第4个元素】即【下标1到下标3】(不包括下标3位置)<==>[1,3)
//Arrays.copyOfRange(被复制数组名称, 起始下标位置, 终止下标位置)
int[] arr2 = Arrays.copyOfRange(ns, 1, 3);
System.out.println("复制下标1到下标3元素："+Arrays.toString(arr2));
}
}
运行结果如下：
复制下标1到下标3元素：[3, 5]
六、Arrays.sort( )方法
1）作用
对数组进行排序
2）参数与返回值
Arrays.sort( )方法【以下表格是它的所有重载方法】
【蓝色字体为参数，紫色字体为返回值类型】
【T[] 表示任意类型数组】
【int fromIndex 表示部分要进行排序的数组元素开始下标位置】
【int toIndex 表示部分要进行排序的数组元素截止下标位置】
【Comparator<? super T>c 比较器，可自行定义比较规则】
sort(byte[] a): void-Arrays sort(char[] a): void-Arrays sort(double[] a): void-Arrays sort(float[] a): void-Arrays sort(int[] a): void-Arrays sort(long[] a): void-Arrays sort(Object[] a): void-Arrays sort(short[] a): void-Arrays sort(T[] a, Comparator<? super T>c): void-Arrays sort(byte[] a,int fromIndex, int toIndex): void-Arrays sort(char[] a, int fromIndex, int toIndex): void-Arrays sort(double[] a, int fromIndex, int toIndex): void-Arrays sort(float[] a, int fromIndex, int toIndex): void-Arrays sort(int[] a,int fromIndex, int toIndex): void-Arrays sort(long[] a, int fromIndex, int toIndex): void-Arrays sort(Object[] a, int fromIndex, int toIndex): void-Arrays sort(short[] a, int fromIndex, int toIndex): void-Arrays sort(T[] a, int fromIndex, int toIndex, Comparator<? super T>c): void-Arrays 上表可得： 均无返回值类型限制，即返回任意类型，为void
3）举例
程序如下：
import java.util.Arrays;
public class PaiXu {
public static void main(String[] args) {
//定义三个int类型的数组ns,ns1和ns2
//ns,ns1无重复元素
int[] ns = {8,7,12,5,1,2,56,9};
int[] ns1 = {13,24,32,15,36,14,68};
//ns2有重复元素
int[] ns2 = {13,13,32,15,36,14,68};
//输出三数组排序前的元素内容
System.out.println("ns1排序前："+Arrays.toString(ns1));
System.out.println("ns2排序前："+Arrays.toString(ns2));
System.out.println("ns排序前："+Arrays.toString(ns));
//使用Arrays工具类下的Arrays.sort()方法对数组ns1和ns2进行排序
Arrays.sort(ns1);
Arrays.sort(ns2);
//使用Arrays工具类下的
//sort(int[] a, int fromIndex, int toIndex)
//方法对数组ns进行排序
//int fromIndex 表示截取的数组开始下标
//int toIndex 表示截取的数组截止下标
//Arrays.sort(ns, 1, 5)表示数组ns元素从下标1开始到下标5
//（不包括下标5位置的元素）截止的范围内元素的排序
Arrays.sort(ns, 1, 5);//即数组仅对下标1，2，3，4位置元素进行排序
//输出三数组排序后的元素内容
System.out.println("ns1排序后："+Arrays.toString(ns1));
System.out.println("ns2排序后："+Arrays.toString(ns2));
System.out.println("ns排序后："+Arrays.toString(ns));
}
}
运行结果如下：
ns1排序前：[13, 24, 32, 15, 36, 14, 68]
ns2排序前：[13, 13, 32, 15, 36, 14, 68]
ns排序前：[8, 7, 12, 5, 1, 2, 56, 9]
ns1排序后：[13, 14, 15, 24, 32, 36, 68]
ns2排序后：[13, 13, 14, 15, 32, 36, 68]
ns排序后：[8, 1, 5, 7, 12, 2, 56, 9]
七、Arrays.binarySearch( )方法
1）作用
在一个有序数组中，进行指定元素的查找
【为什么一定是 有序数组 呢？==> 因为通过调用Arrays工具类下的Arrays.binarySearch( )方法进行指定元素的查找，必须基于 二分查找法 实现，所以数组必须处于有序状态】
2）参数与返回值
Arrays.binarySearch( )方法【以下表格是它的所有重载方法】
【蓝色字体为参数，紫色字体为返回值类型】
【key 为指定元素】
【T[] 表示任意类型数组】
【int fromIndex 表示部分要进行排序的数组元素开始下标位置】
【int toIndex 表示部分要进行排序的数组元素截止下标位置】
【Comparator<? super T>c 比较器，可自行定义比较规则】
binarySearch(byte[] a,byte key): int-Arrays binarySearch(char[] a,char key): int-Arrays binarySearch(double[] a,double key): int-Arrays binarySearch(float[] a,float key): int-Arrays binarySearch(int[] a,int key): int-Arrays binarySearch(long[] a,long key): int-Arrays binarySearch(Object[] a,Object key): int-Arrays binarySearch(short[] ,short key): int-Arrays binarySearch(T[] a,T key, Comparator<? super T>c): int-Arrays binarySearch(byte[] a,int fromIndex, int toIndex,byte key): int-Arrays binarySearch(char[] a, int fromIndex, int toIndex,char key): int-Arrays binarySearch(double[] a, int fromIndex, int toIndex,double key): int-Arrays binarySearch(float[] a, int fromIndex, int toIndex,float key): int-Arrays binarySearch(int[] a,int fromIndex, int toIndex,int key): int-Arrays binarySearch(long[] a, int fromIndex, int toIndex,long key): int-Arrays binarySearch(Object[] a, int fromIndex, int toIndex,Object key): int-Arrays binarySearch(short[] a, int fromIndex, int toIndex,short key): int-Arrays binarySearch(T[] a, int fromIndex, int toIndex,T key, Comparator<? super T>c): int-Arrays 上表可得： 均无返回值类型限制，即返回任意类型，为int型
3）举例
程序如下：
import java.util.Arrays;
public class Find {
public static void main(String[] args) {
//定义一个int类型的数组array
int[] array = { 13,24,15,32,6,7,35,86 };
//需要查找的目标元素index和index1
int index = 32;//数组中存在该元素
int index1 = 8;//数组中不存在该元素
//先给数组排序，快速排序可用Arrays.sort()方法
Arrays.sort(array);
//排序后数组
System.out.println("排序后数组为："+Arrays.toString(array));
//再通过Arrays.binarySearch()方法查找数组中目标元素
int ans = Arrays.binarySearch(array, index);
int ans1 = Arrays.binarySearch(array, index1);
int ans2 = Arrays.binarySearch(array, 2, 6, 6);
int ans3 = Arrays.binarySearch(array, 2, 6, 13);
//输出查找结果
System.out.println("32在排序后数组的下标位置为："+ans);
//结果为负数，因为8这个元素并不在数组内
System.out.println("8在排序后数组查找到的下标位置为："+ans1);
System.out.println("6在“排序后数组下标2到下标6(不包括6)元素内”查找，下标位置为："+ans2);
System.out.println("13在“排序后数组下标2到下标6(不包括6)元素内”查找，下标位置为："+ans3);
}
}
运行结果如下：
排序后数组为：[6, 7, 13, 15, 24, 32, 35, 86]
32在排序后数组的下标位置为：5
8在排序后数组查找到的下标位置为：-3
6在“排序后数组下标2到下标6(不包括6)元素内”查找，下标位置为：-3
13在“排序后数组下标2到下标6(不包括6)元素内”查找，下标位置为：2
扫一扫
592
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
