【Java】7 再识数组|数组的基本操作

欢迎来到爱书不爱输的程序猿的博客, 本博客致力于知识分享，与更多的人进行学习交流
目前,已开了以下专栏,欢迎关注与指导
1️⃣Java基础知识系统学习(持续更文中…)
2️⃣UML的应知应会(已更完)
3️⃣MySQL的应知应会(持续更文中…)
4️⃣算法与数据结构体系(持续更文中…)
5️⃣软考中级：软件设计师系列(持续更文中…)
还有更多文章在主页,欢迎访问爱书不爱输的程序猿

本文收录于Java基础知识系统学习专栏,次专栏是针对初学者打造,完成从0到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();                           //输出空格
		}
	}
}

• 使用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<length; 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<length; i++)
            if (a[i] != a2[i])
                return false;

        return true;
    }

• 可以看到,在for循环中比较的是值

6.3.2deepEquals()和equals()的区别

• deepEquals用于判定两个指定数组彼此是否深层相等
• equals用于判定两个数组是否相等，如果两个数组以相同顺序包含相同元素，则返回true，否则返回false
• 而且,由上述内容可知,如果要比较多维数组，则需要使用deepEquals()方法

7.参数与返回值

7.1 数组作为函数的参数

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}

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;
}