一、数组的基本操作
java.util 包的 Arrays 类包含了用来操作数组（如排序和搜索）的各种方法。
1.1 遍历数组
遍历数组就是获取数组中的每个元素。通常遍历数组都是使用 for 循环来实现。
遍历二维数组需使用双层 for 循环，通过数组的 length 属性可获得数组的长度。
实现将二位数组中的元素呈梯形输出 ：
public class Trap{
public static void main(String[] args){
int b[][] = new int[][]{ {1} , {2,3} , {4,5,6} }; //定义二维数组
for(int k = 0 ; k < b.length ; k++ ){
for(int c = 0 ; c < b[k].length ; c++){ //循环遍历二维数组中的每个元素
System.out.print(b[k][c]); //将数组中的元素输出
}
System.out.println(); //输出空格
}
}
}
运行结果为 ：
1 2 3 4 5 6
使用 foreach 语句遍历二维数组 ：
public class Tautog{
public static void main(String[] args){
int arr2[][] = { {4,3} , {1,2} }; //定义二维数组
System.out.println("数组中的元素是:");
for( int x[] : arr2){ //外层循环变量为一维数组
for( int e : x ){ //循环遍历每一个数组元素
if(e == x.length ){ //判断变量是否是二维数组中的最后一个元素
System.out.printl(e); //输出二维数组的最后一个元素
}else{
System.out.print(e + "、"); //如果不是最后一个元素
}
}
}
}
运行结果为 ：
数组中的元素是 : 4 、3 、 1 、 2
1.2 填充替换数组元素
数组中的元素定义完成后，可通过 Arrays 类的静态方法 fill() 方法来对数组中的元素进行替换。该方法通过各种重载形式可完成任意类型的数组元素的替换。以 int 型数组为例介绍 fill() 方法的使用方法。
（ 1 ）fill(int[] a , int value )
该方法可将指定的 int 值分配给 int 型数组的每个元素。
语法 ：fill ( int[] a , int value )
a ：要进行元素替换的数组 。
value ：要存储数组中所有元素的值 。
创建一维数组，通过 fill() 方法填充数组元素。
import java.util.Arrays;
public class Swap{
public static void main(String[] args){
int arr[] = new int[5]; //创建 int 型数组
Arrays.fill(arrr , 8); //使用同一个值对数组进行填充
for(int i = 0 ; i < arr.lrngth ; i++){ //循环遍历数组中的元素
System.out.println("第 " + i + "个元素是："+ arr[i]);
}
}
}
运行结果为 ：
第 0 个元素是：8 第 1 个元素是：8 第 2 个元素是：8 第 3 个元素是：8 第 4 个元素是：8
1.3 对数组进行排序
通过 Arrays 类的静态 sort() 方法可以实现对数组的排序。 sort() 方法提供了多种重载形式，可对任意类型的数组进行升序排序。
语法 ： Arrays.sort(object)
object ：指进行排序的数组名称 。
eg： 创建一维数组，将数组排序后输出 ：
import java.util.Arrays;
public class Taxis{
public static void main(String[] args){
int arr[] = new int[]{23,42,12,8}; //声明数组
Arrays.sort(arr); //将数组进行排序
for(int i = 0 ; i < arr.length ; i++){ //循环遍历排序后的数组
System.out.println(arr[i]);
}
}
} 运行结果为 ：
8 12 23 42
Java 中的 String 类型数组的排序算法是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母前面。
1.4 复制数组
Arrays 类的 copyOf() 方法与 copyOfRange() 方法可以实现对数组的复制。copyOf() 方法是复制数组至指定长度，copyOfRange() 方法则将指定数组的指定长度复制到一个新数组中。
（ 1 ）copyOf() 方法
该方法提供了多种重载形式，用于满足不同类型数组的复制。
语法 ： copyOf( arr , int newlength )
arr ：要进行复制的数组 。
newlength ：int 型常量，指复制后的新数组的长度。如果新数组的长度大于数组 arr 的长度，则用 0 填充（根据复制数组的类型来决定填充的值，整形数组用 0 填充，char 型数组则使用 null 填充）；如果复制后的数组长度小于数组 arr 的长度，则会从数组 arr 的第一个元素开始截取至满足新数组的长度为止。
eg：实现将数组复制得到一个长度为 5 的新数组，并将新数组输出。
import java.util.Arrays;
public class Cope{
public static void main(String[] args){
int arr[] = new int[]{23,42,12}; //定义数组
int newarr[] = Arrays.copyOf(arr,5); //复制数组 arr
for(int i = 0 ; i < newarr.length ; i++ ){ //循环变量复制后的新数组
System.out.println(newarr[i]); //输出新数组
}
}
}
运行结果为 ：
23 42 12 0 0
（ 2 ）copyOfRange() 方法
该方法提供了多种重载形式。
语法 ： copyOfRange(arr , int fromIndex , int toIndex )
arr ：要进行复制的数组对象 。
fromIndex ：指定开始复制数组的索引位置。fromIndex 必须在 0 至整个数组的长度之间。新数组包括索引是 fromIndex 的元素。
toIndex ：要复制范围的最后索引位置。可大于数组 arr 的长度。新数组不包括索引是 toIndex 的元素。
eg ： 创建一维数组，将数组中索引位置是 0~3 之间的元素复制到新数组中，输出新数组。
import java.util.Arrays;
public class Repeat{
public static void main(String[] args){
int arr[] = new int[]{23,42,12,84,10}; //定义数组
int newarr[] = Arrays.copyOfRange(arr , 0 ,3); //复制数组
for(int i = 0 ; i < newarr.length ; i++){ //循环遍历复制后的新数组
System.out.println(newarr[i]);
}
}
}
运行结果为 ：
23 42 12
1.5 数组查询
Arrays 类的 binarySearch() 方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch() 方法提供了多种重载形式，用于满足各种类型数组的查找需要。
两种参数类型 ：
（ 1 ）binarySearch(Object[] , Object key)
语法 ：binarySearch(Object[] a , Object key)
a ：要搜索的数组 。
key ：要搜索的值 。
如果 key 包含在数组中，则返回搜索值的索引；否则返回 -1 或 “ - ”(插入点)。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引。
eg ：查询数组元素
int arr[] = new int[]{4,25,10}; //创建并初始化数组
Arrays.sort(arr); //进行排序
int index = Arrays.binarySearch(arr, 0, 1, 8);
变量 index 的值是元素 " 8 "在数组 arr 中索引在 0~1 内的索引位置。由于在指定的范围内并不存在元素“ 8 ” ， index 的值是“ - ”(插入点)。如果对数组进行排序，元素“ 8 ”应该在“ 25 ”的前面。因此插入点应是元素“ 25 ”的索引值 2 ，所以 index 的值是 -2 。
如果数组中的所有元素都小于指定的键，则为 a.length(注意，这保证了当且仅当此键被找到时，返回的值将大于等于 0 )。
必须在进行此调用之前对数组进行排序（通过 sort() 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
eg ：创建一维数组，实现查找元素 4 在数组 ia 中的索引位置。
import java.util.Arrays;
public class Example{
public static void main(String[] args){
int ia[] = new int[]{1,8,9,4,5}; //定义数组
Arrays.sort(ia); //进行排序
int index = Arrays.binarySearch(ia,4); //查找数组 ia 中元素 4 的索引位置
System.out.println("4 的索引位置是："+index); //输出索引值
}
} 运行结果为 ：4 的索引位置是 1
（ 2 ）binarySearch(Object[] , int fromIndex , int toIndex ,Object key )
语法 ：binarySearch(Object[] a , int fromIndex ,int toIndex , Object key)
a ：要进行检索的数组 。
fromIndex ：指定范围的开始处索引（包含）。
toIndex ：指定范围的结束处索引（不包含）。
key ：要搜索的元素 。
在使用该方法之前同样要对数组进行排序，来获得准确的索引值。如果要搜索的元素 key 在指定的范围内，则返回搜索键的索引；否则返回 -1 或 “ - ”(插入点)。如果范围中的所有元素都小于指定的键，则为 toIndex （注意，这保证了当且仅当此键被找到时，返回的值将大于等于 0 ）。
如果指定的范围大于或等于数组的长度，则会报出 ArrayIndexOutOfBoundsException 异常。
eg ：创建 String 数组，实现查找元素 “ cd ”在指定范围的数组 str 中的索引位置。
import java.util.Arrays;
public class Rakel{
public static void main(String[] args){
String str[] = new String[]{"ab","cd","ef","yz"}; //定义 String 型数组
Arrays.sort(str); //排序
int index = Arrays.binarySearch(str, 0 ,2 ,"cd"); //在指定范围内搜索
System.out.println("cd 的索引位置是：" + index);
}
} 运行结果为 ： cd 的索引位置是： 1