Java 数组（二）基本操作

一、数组的基本操作

　　1、数组遍历【重点】

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

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

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

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

　　　    方式二：使用 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;
}

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