一、数组的基本操作
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