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

本文收录于Java基础知识系统学习专栏,次专栏是针对初学者打造,完成从0到1的跨越

再识数组

    • 1.遍历数组
    • 2.填充替换数组元素
      • 2.1 fill(int[] a,int value)
      • 2.2 fill(int[] a,int fromIndex,int toIndex,int value)
    • 3.对数组进行排序
    • 4.复制数组
      • 4.1copyOf()方法
      • 4.2copyOfRange()方法
    • 5.查询数组
      • 5.1binarySearch(Object[] a, int fromIndex, int toIndex, Object key)
      • 5.2binarySearch(Object[],int fromIndex,inttoIndex,Object key)
    • 6.数组比较
      • 6.1Arrays类提供了 `equals()方法来比较一维数组`是否相等
      • 6.2 Arrays类提供了 `deepEquals()方法来比较多维数组`
      • 6.3 equals()与deepEquals()
        • 6.3.1对于完全相同的数组 , 为何使用Arrays.equals()比较两个二维数组的结果是false?而比较一维数组的结果就是true?
        • 6.3.2deepEquals()和equals()的区别
    • 7.参数与返回值
      • 7.1 数组作为函数的参数
      • 7.2数组作为函数的返回值

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); // 复制数组arrfor (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));   //falseSystem.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;}