【本节目标】

1、理解数组基本概念

2、掌握数组的基本用法

3、数组与方法互操作

4、熟练掌握数组相关的常见问题和代码

1.数组的基本概念

1.1 为什么要使用数组

有一组类型相同的数据需要存放在一起，这就是所谓的数组。

1.2 什么是数组

数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。在java中，首先数组中存放的元素类型相同；其次，数组的空间是连在一起的；然后每个空间有自己的编号，起始位置的编号是0，即数组的下标。

1.3 数组的创建及初始化

1.3.1数组的创建

 例如：

int[] array1 = new int[66];
double[] array2 = new double[6];
String[] array3 = new String[3];

 1.3.2数组的初始化

初始化分为动态初始化与静态初始化

       1、动态初始化：在创建数组时，直接指定数组中元素的个数

int[] array = new int[10];

        2、静态初始化：在创建数组时不直接指定元素个数，而直接将具体的元素内容指定

int[] array1 = new int[]{1,2,3,4};
double[] array2 = new double[]{1.0,2.0,3.0,4.0};
String[] array3 = new String[]{"hello","java"};

【注】1、静态初始化可以简写，省略后面的new T [ ]。

           2、静态初始化时必须保证前后数据类型一致。

           3、如果不确定数组当中内容时，使用动态初始化，否则建议使用静态初始化。

           4、如果数组没有初始化，数组元素有其默认值。

类型	默认值
byte	0
short	0
int	0
long	0
float	0.0f
double	0.0
char	/u0000
boolean	false

           5、如果数组中存储元素类型为引用类型，默认值为null。

1.4 数组的使用 

1.4.1 数组元素的访问

数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过下标访问其任意位置的元素，也可以通过[ ]对数组中的元素进行修改。

【注】1、支持随机访问，即通过下标快速访问数组中任意位置的元素。

           2、下标从0开始，[0,N)坐闭右开，不能越界，否则编译器会报下标越界异常。

抛出java.lang.ArrayIndexOutofBoundsException异常。

1.4.2 遍历数组

遍历：是将数组中的所有元素都访问一遍，访问是指对数组中的元素进行某种操作。比如打印：

int[] array = new int[] {10,20,30,40,50};
for(int i = 0; i < array.length; i++){
    System.out.println(array[i]);
}

也可以用for-each(for循环的另外一种)遍历数组:

int[] array = {1,2,3};
for(int x : array){
    System.out.println(x);
}

2、数组是引用类型

2.1初始JVM的内存分布

这里只谈堆和虚拟机栈

堆：JVM所管理的最大内存，使用new创建的对象都是在堆上保存，堆是随着程序开始运行时而创建的，随着程序的推出而销毁，堆中的数据只要还有在使用的，就不会被销毁。

虚拟机栈：与方法调用相关的一些信息，每个方法执行的时候，都会创建一个栈帧，栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息，保存的都是与方法执行时相关的一些信息。

2.2 基本类型变量与引用类型变量的区别

基本数据类型创建的变量，称为基本变量，该变量空间中的直接存放的是其所对应的值；

而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。

public static void func(){
     int a = 10;
     int b = 20;
     int[] arr = new int[]{1,2,3};
}

 a,b是基本变量，因此其空间中保存的就是给该变量初始化的值。

array是数组类型的引用变量，其内部保存的内容是数组在堆空间中的首地址。（类似于指针）

2.3 再谈引用变量

    public static void main(String[] args) {
        int[] array = {1,2,3};
        System.out.println(array);//真实地址的哈希值
    }

public static void main(String[] args) {
        int[] array1 = {1,2,3,4,5};
        int[] array2 = array1;  //这个引用array2，指向了array1所指向的对象
        System.out.println("array1:" + Arrays.toString(array1));
        System.out.println("array2:" + Arrays.toString(array2));
}

上图代码中array1与array2是等价的，引用的是同一个数组。

    public static void main(String[] args) {
        int[] array1 = new int[3];
        array1[0] = 10;
        array1[1] = 20;
        array1[2] = 30;
        for (int x:array1) {
            System.out.print(x+" ");
        }
        System.out.println();
        System.out.println("====================");
        int[] array2 = new int[]{1,2,3,4,5};
        array2[0] = 100;
        array2[1] = 200;
        array1 = array2;  //让array1去引用array2引用的数组的空间，此时array1和array2实际是同一个数组。
        array1[2] = 300;
        array1[3] = 400;
        array2[4] = 500;
        for (int i = 0; i < array1.length; i++){
            System.out.print(array1[i]+" ");
        }
        System.out.println();
        System.out.println("====================");
        for (int i = 0; i < array2.length; i++){
            System.out.print(array2[i]+" ");
        }
    }

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

两个数组虽然里面的值一样，但地址不一样。

2.4认识null

null在java中表示“空引用”，也就是一个不指向对象的引用。

public static void main(String[] args) {
        int a = 0;
        System.out.println(a);
        int[] array = null;
        System.out.println(array[0]);
    }

 3、数组的应用场景

3.1 保存数据

public static void main(String[] args){
    int[] array = {1,2,3};
    for(int i = 0; i < array.length; ++i){
    System.out.println(array[i] + " ");
    }
}

3.2 作为函数的参数

1、参数传基本数据类型

    public static void func(int a){
        a = 20;
        System.out.println(a);
    }
    public static void main(String[] args) {
        int x = 10;
        func(x);
        System.out.println(x);
    }

在func方法中修改形参a的值，不影响实参x的值。

2、参数传数组类型（引用数据类型）

    public static void func1(int[] array){
        array = new int[]{11,12,13,14};
    }
    public static void func2(int[] arr){
        arr[0] = 199;
    }
    public static void main(String[] args) {
        int[] array1 ={1,2,3,4};
        func1(array1);
        System.out.println(Arrays.toString(array1));
        int[] arr = {100,99,88,77};
        func2(arr);
        System.out.println(Arrays.toString(arr));
    }

因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容。在Java里面都是按值传递，地址也是值。

3.3 作为函数的返回值

    //获取斐波那契数列的前n项
    public static int[] fib(int n){
        if(n <= 0){
            return null;
        }
        int[] array = new int[n];
        array[0] = array[1] = 1;
        for(int i = 2; i < n; ++i){
            array[i] = array[i-1] + array[i-2];
        }
        return array;
    }
    public static void main(String[] args) {
        int[] array = fib(5);
        for(int i = 0; i < array.length; i++){
            System.out.println(array[i]);
        }
    }

4、数组练习

4.1 数组转字符串

    //数组转字符串
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        String newArr = Arrays.toString(arr);
        System.out.println(newArr);
    }

Arrays.toString是Java里的java.util.Arrays包，打印数组比较方便。

4.2 数组拷贝

    //利用for循环遍历数组拷贝
    public static void main(String[] args) {
        int[] array = {1,2,3,4};
        int[] copy = new int[array.length];
        for (int i = 0; i < array.length; i++) {   //遍历数组
            copy[i] = array[i];
        }
        System.out.println(Arrays.toString(copy));
    }

   //使用Arrays.copyOf拷贝
    public static void main(String[] args) {
        int[] array = {1,2,3,4};
        int[] copy = Arrays.copyOf(array,array.length);
        System.out.println(Arrays.toString(copy));
    }

Arrays.copyOf是以后数组拷贝运用最广泛的。

    //使用array.clone拷贝数组
    public static void main(String[] args) {
        int[] array = {1,2,3,4};
        int[] copy = array.clone();
        System.out.println(Arrays.toString(copy));
        System.out.println(array);
        System.out.println(copy);
    }

    //使用Arrays.copyOfRange拷贝数组
     public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] ret = Arrays.copyOfRange(array,1,6);    //java里面的范围都是左闭右开
        System.out.println(Arrays.toString(ret));
    }

4.3 求数组中元素的平均值

    public static double avg(int[] array){
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        return sum * 1.0 / array.length;
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(avg(array));
    }

4.4 查找数组中指定元素（顺序查找）

   //顺序查找
    public static int search(int[] array,int key){
        for (int i = 0; i < array.length; i++) {
            if(array[i] == key){
                return i;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int index = search(array,4);
        if(index == -1){
            System.out.println("找不到！");
        }else{
            System.out.println("找到了，下标为："+index);
        }
    }

4.5 查找数组中的指定元素（二分查找）

前提是你查找的数据必须是有序的。

//二分查找
    public static int binarySearch(int[] array,int key){
        int left = 0;
        int right = array.length-1;
        while(left <= right){
            int mid = (left + right) / 2;
            if(array[mid] < key){
                left = mid + 1;
            }else if(array[mid] == key){
                return mid;
            }else{
                right = mid - 1;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int index = binarySearch(array,44);
        if(index == -1){
            System.out.println("找不到！");
        }else{
            System.out.println("找到了，下标为："+index);
        }
    }

//排序过后的查找、Arrays自带的查找
    public static int binarySearch(int[] array,int key){
        int left = 0;
        int right = array.length-1;
        while(left <= right){
            int mid = (left + right) / 2;
            if(array[mid] < key){
                left = mid + 1;
            }else if(array[mid] == key){
                return mid;
            }else{
                right = mid - 1;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] array = {1,2,33,4,5};
        Arrays.sort(array);//先将数组排序
        System.out.println("排序之后的数组: "+Arrays.toString(array));
        int index = Arrays.binarySearch(array,32);
        if(index == -1){
            System.out.println("找不到！");    //返回下标为:-(low+1)
        }else{
            System.out.println("找到了，下标为："+index);
        }
    }

【注】1、sort方法默认是升序排序

           2、对于现在的简单数据类型，目前还做不到降序。

           3、怎样做到指定的升序或降序，需要去学习后面的接口。

4.6 数组排序（冒泡排序）

    //冒泡排序法
    public static void bubbleSort(int[] array){
        //i表示趟数
        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 tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] array = {1,2,33,4,5};
        System.out.println("排序之前的数组: "+Arrays.toString(array));
        bubbleSort(array);
        System.out.println("排序之后的数组: "+Arrays.toString(array));
    }

    //冒泡排序法优化
    public static void bubbleSort(int[] array){
        for (int i = 0; i < array.length - 1; i++) {
            boolean flg = false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if(array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flg = true;
                }
            }
            if (flg == false){
                break;
            }
        }
    }
    public static void main(String[] args) {
        int[] array = {1,2,33,4,5};
        System.out.println("排序之前的数组: "+Arrays.toString(array));
        bubbleSort(array);
        System.out.println("排序之后的数组: "+Arrays.toString(array));
    }

4.7 数组逆序

public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void reverse(int[] arr){
        int left = 0;
        int right = arr.length - 1;
        while(left < right){
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
            left++;
            right--;
        }
    }

5、二维数组

基本语法：

数据类型[ ][ ]  数组名称 = new 数据类型 [行数][列数] {初始化数据}；

public static void main(String[] args) {
        int[][] arr = { {1,2,3,4},{5,6,7,8},{9,10,11,12} };
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
            System.out.println("");
        }
    }