Java 数组（二）基本操作

一、数组的基本操作

　　1、数组遍历【重点】

　　　　数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

　　　　 方式一：使用索引下标方式

 int[] array = { 15, 25, 30, 40, 50, 60, 75 };
 System.out.println(array[0]); //
 System.out.println(array[1]); //
 System.out.println(array[2]); //
 System.out.println(array[3]); //
 System.out.println(array[4]); //
 System.out.println(array[5]); //

　　　　这种方式需要依次根据索引进行频繁重复的操作，不推荐使用，只做了解。

　　　    方式二：使用 for 循环

 for (int i = 0; i < array.length; i++) {
       System.out.println(array[i]);
 }

　　　　对于一个数组，每次对每个元素的操作都是相同的，用循环是最好的方法。而且就算数组的长度发送了改变代码也不需要改动。

　　　　方式三：使用 foreach 循环

 for (int i: array){
    　　System.out.println(array[i]);
 }

　　　　　这种循环是增强形式的 for 循环，其中 i 即代表数组中的每一个元素。

　　2、数组获取最值元素

　　　　获取数组中最值的步骤：

• • • 　定义变量，保存数组0索引上的元素；
    • 遍历数组，获取数组中的每个元素；
    • 将遍历到的元素和保存数组 0 索引上值的变量进行比较；
    • 如果数组元素的值大于（小于）变量的值，变量记录新的值；
    • 数组循环遍历结束，变量保存的就是数组中的最大值（最小值）；

　　　　代码实现：

  int[] arr = { 5, 15, 2000, 10000, 100, 4000 };

  //定义最大值和最小值变量，保存数组中0索引的元素
   int min = arr[0];
   int max = arr[0];
   //遍历数组，取出每个元素
   for (int i = 0; i < arr.length; i++) {
       //遍历到的元素和变量max，min比较
       //如果数组元素大于max
       if (arr[i] > max) {
          //max记录住大值
           max = arr[i];
       }
       //如果数组元素小于min
       if(arr[i] < min) {
           //min记录住小值
           min = arr[i];
        }
    }
    System.out.println("数组最大值是： " + max);
    System.out.println("数组最小值是： " + min);

　　3、数组越界异常

　　　　创建数组，赋值3个元素，数组的索引就是0,1,2，没有3索引，因此我们不能访问数组中不存在的索引。

　　　　程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。

　　　　Demo：

 public static void main(String[] args) {
 　　int[] arr = {1,2,3};
 　　System.out.println(arr[3]);
 }

　　　　　程序运行结果：

　　4、数组空指针异常

　　　　如果只是声明了一个数组，并没有给它在内存中分配内存地址，运行的时候会抛出 NullPointerException 空指针异常。

　　　　Demo：

 public static void main(String[] args) {
 　　int[] arr = {1,2,3};
 　　arr = null;
 　　System.out.println(arr[0]);
 ｝

　　　　　程序运行结果：

　　5、填充替换数组元素

　　　　数组完成声明后，可以通过 Arrays 类的静态方法 fill() 来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。下面是两种参数类型

　　　　方式一：

　　　　　　语法格式：

fill(int[] array,int value)

　　　　　　　 该方法可将指定的 int 值分配给 int 型数组的每个元素。

• • • 　array：要进行元素替换的数组；
    • value：要存储数组中所有元素的值；

　　　　Demo:

  public static void main(String[] args) {
        int[] array = new int[5];
        Arrays.fill(array,8);
         for (int i:array) {
             System.out.println(i);
         }

 }

　　　　方式二：

　　　　　　语法格式：

fill(int[] array,int fromindex,int toindex,value)

　　　　　　该方法将指定的 int 值分配给int 类型数组指定范围中的每个元素。填充范围从索引 fromIndex（包含）到索引 toindex(不包含)。如果 fromindex == toindex,则填充范围为空。

• • • 　array：要进行填充的数组；
    • fromindex：使用指定值填充的第一个元素的索引（包括）；
    • toindex：使用指定值填充的第二个元素的所有（不包括）；
    • value：要进行填充的值；

　　　　Demo：

 public static void main(String[] args) {
        int[] array = new int[]{5,15,25,35,45,55,65,75,85,95};
        Arrays.fill(array,2,6,8);
         for (int i : array) {
             System.out.println(i);
         }
  }

　　　　Tips：如果指定的索引位置大于或等于要进行填充的数组的长度，则会报出 ArrayIndexOutofBoundsException （数组越界异常）。

　　6、对数组进行排序

　　　　可以通过 Arrays 类的静态 sort() 方法可以实现对数组的排序。该方法提供了多种重载形式，可对任意类型的数组进行升序排序。

　　　　语法格式：

Arrays.sort(Object)   // Object 是进行排序的数组名称

　　7、复制数组

　　　　Arrays 类的 copyOf() 方法与 copyOfRange() 方法可以实现对数组的复制。copyOf() 方法的复制数组至指定长度，copyOfRange() 方法则将指定数组的指定长度复制到一个新数组中。

　　　　（1）copyOf 方法

　　　　　　该方法提供了多种重载形式，用于满足不同类型数组的复制。

　　　　　　语法格式：

copyOf(array,int newlength);

• • • array：要进行复制的数组；
    • newlength：int型常量，指复制后的新数组的长度。如果新数组的长度大于数组 array 的长度，则根据不同类型的数组用各自的默认值填充（如int类型用0填充），如果复制后的数组长度小于数组 array 的长度，则会从数组 array 的第一个元素开始截取至满足新数组长度为止。

　　　　Demo：

  public static void main(String[] args) {
         int[] array = new int[]{12,15,17};
         int[] newarray = Arrays.copyOf(array,5);

         for (int i:newarray) {
             System.out.println(i);
         }
  }

　　　　（2）copyOfRange 方法

　　　　　　格式语法：

copyOfRange(array,int fromIndex,int toIndex)

• • • 　　array：要进行辅助的数组对象；
    • fromIndex：指定开始复制数组的索引位置，fromindex 必须在 0 至整个数组的长度之间。新数组包括索引是 fromIndex 的元素。
    • toIndex：要复制范围的最后索引，可大于数组 array 的长度。新数组不包括索引是 toIndex 的元素。

　　　　　　Demo：

 public static void main(String[] args) {
         int[] array = new int[]{12,15,17};
         int[] newarray = Arrays.copyOfRange(array,1,5);

         for (int i:newarray) {
             System.out.println(i);
         }
 }

　　8、数组查询

　　　　Arrays 类的 binarySearch() 方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索的元素的索引值。

　　　　（1）binarySearch(Object[],Object key)

　　　　　　语法格式：

binarySearch(Object[] array,Object key)

• • • array：要搜索的数组；
    • key：要搜索的值；
    • 如果 key 包含在数组中，则返回索引值的索引，否则返回 -1 或“-”（插入点）。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引。

　　　　　　Demo：

  public static void main(String[] args) {
       int[] array = new int[]{4,25,12,15,17};
       int index = Arrays.binarySearch(array,8);
       System.out.println(index);
  }

　　　　　　Tips：在进行调用之前对数组进行排序（通过 sort() 方法，如果没有对数组排序，结果是不确定的）

　　　　（2）binarySearch(Object[],int fromIndex,int toIndex,Object key)

　　　　　　该方法在指定的范围内检索某一元素。

　　　　　　语法格式：

binarySearch(Object[] array,int fromIndex,int toIndex,Object key)

• • • array：要进行检索的数组
    • fromIndex：指定范围的开始处索引（包含）
    • toIndex：指定范围的结束处索引（不包含）
    • key：要搜索的元素。

　　　　Tips：如果范围中的所有元素都小于指定的键，则为 toIndex。

二、数组排序算法

　　1、冒泡排序

　　　　冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将小数往前放、大数往后放，类似于水中气泡往上升的动作，所以称作冒泡排序。

　　　　基本思想：对比相邻的元素值。

　　　　参考：冒泡排序

　　　　　代码实现：

 int array[] = {12,58,3,46,18,43};
         for (int i = 0; i < array.length - 1; i++) {
             for (int j = 0; j < array.length - 1 - i; j++) {
                 if (array[j] > array[j + 1]) {
                     int temp = array[j];
                     array[j] = array[j + 1];
                     array[j + 1] = temp;
                 }
             }
             System.out.println("第" + i + "次排序结果：" + Arrays.toString(array));
         }

　　2、反转排序

　　　　数组的反转：数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1

　　　　实现思想：数组最远端的元素互换位置

• • • 　实现反转，就需要将数组最远端元素位置交换
    • 定义两个变量，保存数组的最小索引和最大索引
    • 两个索引上的元素交换位置
    • 最小索引++，最大索引--，再次交换位置
    • 最小索引超过了最大索引，数组反转操作结束

　　　　流程图：

　　　　

　　　　　　代码实现：

 public static void main(String[] args) {
 　　int[] arr = { 1, 2, 3, 4, 5 };
 　　/*
 　　循环中定义变量min=0最小索引
 　　max=arr.length‐1最大索引
 　　min++,max‐‐
 　　*/
 　　for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) {
 　　//利用第三方变量完成数组中的元素交换
 　　int temp = arr[min];
 　　arr[min] = arr[max];
 　　arr[max] = temp;
 　　}
 　　// 反转后，遍历数组
 　　for (int i = 0; i < arr.length; i++) {
16　　 System.out.println(arr[i]);
17　　 }
 }

三、数组作为方法参数和返回值

　　1、数组作为方法参数

　　　　数组作为方法参数传递，传递的参数是 数组内存的地址。

　　　Demo：

 public static void main(String[] args) {
 　　int[] arr = { 1, 3, 5, 7, 9 };
 　　//调用方法，传递数组
 　　printArray(arr);
 }
 /*
 创建方法，方法接收数组类型的参数
 进行数组的遍历
 */
 public static void printArray(int[] arr) {
 　　for (int i = 0; i < arr.length; i++) {
 　　　　System.out.println(arr[i]);
 　　}
 }

　　Tips：方法的参数为基本类型时,传递的是 数据值. 方法的参数为引用类型时,传递的是 地址值.。

　　2、数组作为方法返回值

　　　　数组作为方法的返回值，返回的是 数组的内存地址

　　　 Demo：

 public static void main(String[] args) {
 　　//调用方法，接收数组的返回值
 　　//接收到的是数组的内存地址
 　　int[] arr = getArray();
 　　for (int i = 0; i < arr.length; i++) {
 　　　　System.out.println(arr[i]);
 　　}
 }
 /*
 创建方法，返回值是数组类型
 return返回数组的地址
 */
 public static int[] getArray() {
 　　int[] arr = { 1, 3, 5, 7, 9 };
 　　//返回数组的地址，返回到调用者
 　　return arr;
 }

　　总结：任何数据类型都能作为方法的参数类型，或者返回值类型