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(); //输出空格
}
}
}
使用for-each语句遍历数组
public class Tautog { // 创建类
public static void main(String[] args) { // 主方法
int arr2[][] = { { 4, 3 }, { 1, 2 } }; // 定义二维数组
System.out.println("数组中的元素是："); // 提示信息
int i = 0; // 外层循环计数器变量
for (int x[] : arr2) { // 外层循环变量为一维数组
i++; // 外层计数器递增
int j = 0; // 内层循环计数器
for (int e : x) { // 循环遍历每一个数组元素
j++; // 内层计数器递增
if (i == arr2.length && j == x.length) { // 判断变量是二维数组中的最后一个元素
System.out.print(e); // 输出二维数组的最后一个元素
} else
// 如果不是二维数组中的最后一个元素
System.out.print(e + "、"); // 输出信息
}
}
}
}
2.填充替换数组元素
数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。
该方法通过各种重载形式可完成对任意类型的数组元素的替换。
2.1 fill(int[] a,int value)
该方法可将指定的int值分配给int型数组的每个元素
//语法:
fill(int[] a, int value);
//a：要进行元素替换的数组
//value：要存储数组中所有元素的值
2.2 fill(int[] a,int fromIndex,int toIndex,int value)
该方法将指定的int值分配给int型数组指定范围中的每个元素
填充的范围从索引fromIndex（包括）一直到索引toIndex（不包括） [fromIndex,toIndex)
如果fromIndex == toIndex，则填充范围为空
//语法:
fill(int[] a, int fromIndex, int toIndex, int value);
//a：要进行填充的数组
//fromIndex：要使用指定值填充的第一个元素的索引（包括）
//toIndex：要使用指定值填充的最后一个元素的索引（不包括）
//value：要分配给数组指定范围中的每个元素的值
如果指定的索引位置大于或等于要进行填充的数组的长度，则会报出ArrayIndexOutOf-BoundsException
3.对数组进行排序
通过Arrays类的静态方法sort()可以实现对数组的排序
sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序
//语法:
Arrays.sort(object);
//object是指进行排序的数组名称
示例:
import java.util.Arrays; //导入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]); // 将排序后数组中的各个元素输出
}
}
}
上述实例是对整型数组进行排序。
Java中的String类型数组的排序算法是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母前面
4.复制数组
4.1copyOf()方法
//语法:
copyOf(arr, int newlength);
//arr：要进行复制的数组
//newlength：int型常量，指复制后的新数组的长度
如果新数组的长度大于数组arr的长度，则用0填充
根据复制数组的类型来决定填充的值，整型数组用0填充，char型数组则使用null来填充;
如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取至满足新数组长度为止。
示例:
import java.util.Arrays; //导入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]); // 将新数组输出
}
}
}
4.2copyOfRange()方法
//语法:
copyOfRange(arr, int formIndex, int toIndex);
//arr：要进行复制的数组对象
//formIndex：指定开始复制数组的索引位置。
//toIndex：要复制范围的最后索引位置
formIndex必须在0至整个数组的长度之间。新数组包括索引是formIndex的元素。
toIndex可大于数组arr的长度。新数组不包括索引是toIndex的元素
5.查询数组
Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象
该方法返回要搜索元素的索引值
5.1binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
//语法:
binarySearch(Object[] a, int fromIndex, int toIndex, Object key);
//a：要搜索的数组
//fromIndex：要搜索的第一个元素的索引（包含fromIndex）
//toIndex：要搜索的最后一个元素的索引（不包含toIndex）
//key：要搜索的值
如果key包含在数组中，则返回搜索值的索引；否则返回-1或"-"（插入点）。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引
进一步举例说明:
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。
在调用binarySearch(Object[] a, Object key)之前必须对数组进行排序（通过sort()方法）。
如果没有对数组进行排序，则结果是不确定的。
如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
5.2binarySearch(Object[],int fromIndex,inttoIndex,Object key)
在指定的范围内检索某一元素
//语法:
binarySearch(Object[] a, int fromIndex, int toIndex, Object key);
//a：要进行检索的数组
//fromIndex：指定范围的开始处索引（包含）
//toIndex：指定范围的结束处索引（不包含）
//key：要搜索的元素
使用该方法前，同样要对数组进行排序，这样才能获得准确的索引值。
如果要搜索的元素key在指定的范围内，则返回搜索键的索引；否则返回-1或"-"(插入点)
如果范围中的所有元素都小于指定的键，则插入点为toIndex
这保证了当且仅当此键被找到时，返回的值将大于等于0
6.数组比较
两个数组相等意味着其中的元素数量必须相同，并且每个相同位置的元素也必须相等可以用equals()方法来判断
对于基本类型，是由其包装类中的equals()方法来比较的，
例如:int元素实际是由Integer.equals()来负责比较
6.1Arrays类提供了 equals()方法来比较一维数组是否相等
int[] a1 = new int[] {1, 2, 3, 4};
int[] a2 = new int[] {1, 2, 3, 4};
System.out.println("a1 == a2: " + Arrays.equals(a1, a2));
a2[3] = 11;
System.out.println("a1 == a2: " + Arrays.equals(a1, a2));
6.2 Arrays类提供了 deepEquals()方法来比较多维数组
int myarr[][] = {{12,0},{45,10}};
int arr[][] = {{12,0},{45,10}};
System.out.println(Arrays.equals(myarr,arr)); //false
System.out.println(Arrays.deepEquals(myarr,arr)); //true
6.3 equals()与deepEquals()
6.3.1对于完全相同的数组 , 为何使用Arrays.equals()比较两个二维数组的结果是false?而比较一维数组的结果就是true?
首先,看二维数组使用Arrays.equals()方法时的源码
public static boolean equals(int[] a, int[] a2) {
if (a==a2)
return true; //1.如果名字相同，返回true
if (a==null || a2==null)
return false; //2.如果其中一个为空，返回false
int length = a.length;
if (a2.length != length)
return false; //3.如果两个数组长度不同，返回false
for (int i=0; i
Object o1 = a[i];
Object o2 = a2[i];
if (!(o1==null ? o2==null : o1.equals(o2)))
return false; //4.进行对比，不同，返回false
}
return true; //5.走到这一步就说明数组中每个元素都相等，返回true
}
很明显，在第4步的时候，因为在Java中，对象类型的变量（如Object）存储的是对象的引用（地址），而不是对象本身的值。
因此，在这个语句中，变量o1得到的是数组a中第i个元素的引用，而不是该元素的值。所以结果就是false
看一维数组使用Arrays.equals()方法时的源码
public static boolean equals(int[] a, int[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
for (int i=0; i
if (a[i] != a2[i])
return false;
return true;
}
可以看到,在for循环中比较的是值
6.3.2deepEquals()和equals()的区别
6.3.2deepEquals()和equals()的区别deepEquals用于判定两个指定数组彼此是否深层相等
equals用于判定两个数组是否相等，如果两个数组以相同顺序包含相同元素，则返回true，否则返回false
而且,由上述内容可知,如果要比较多维数组，则需要使用deepEquals()方法
7.参数与返回值
7.参数与返回值7.1 数组作为函数的参数
7.1 数组作为函数的参数public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
7.2数组作为函数的返回值
7.2数组作为函数的返回值public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
result[j] = list[i];
}
return result;
}
