1.5：数组

前言：菜鸟一枚，如有问题欢迎大家在评论区指出，我们一起学习。

1.5.1：数组的概念及在存储方式

概念：所谓数组(array)，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，以便统一管理他们，然后用编号区分他们，这个名字称为数组名，编号称为下标或索引(index)。组成数组的各个变量称为数组的元素(element)。数组中元素的个数称为数组的长度(length)。数组有一维和多维数组。

特点：数组的长度一旦确定就不能更改；数组在内存中是一片连续的空间；数组通过下标访问（下标从0开始）。

坑：

int a = 100;
int b = a;
// 此时a和b的值均为100
a = 200;
//此时a和b分别为200，100
b = 300;
// 此时a和b分别为 200，300


int[] a = new int [1]{1};
int[] b = a;
//此时a，b数组第一个元素均为1；
a[0] = 100;
//此时a，b两个数组第一个元素均为100；
b[0] = 200;
//此时a，b数组第一个元素均为200

疑问：为什么在执行int[] b = a过后，a和b任意一个改变另一个也会改变？因为数组不同于基本数据类型，基本数据类型存在栈中，而new创建的对象都在堆中。如果直接打印a，我们会发现得到的是一串地址，并不是打印的数组内容，这是因为a中存储的是数组的首地址。当我们把a赋给b时，实际上是更改b中存储的地址。因此，当我们改变其中任意一个时，另一个也会改变。

1.5.2：一维数组的声明及初始化

一维数组的声明：

int[] arr;
// 不推荐方式
int arr[]//c语言方式

一维数组的动态初始化：

// 数组后面赋值
int[] arr = new int [3];
//或者
int[] arr;
arr = new int[3];

使用动态初始化，不同类型的数组得到的默认值是不同的，具体如下图。

一维数组的静态初始化：

//数组在初始化就给定了值
int[] arr = new int[]{1,2,3,4};//数组长度根据元素确定，可以省略[]中的值，
//或者
int[] arr;
arr= new int[]{1,2,3,4};
//或者
int[] arr = {1,2,3,4};

1.5.3: 一维数组的使用及部分简单算法

数组的长度:

int[] arr = new int[]{1,2,3,4,5};
int index  = arr.length;

数组的排序（升序）：

int[] arr = new int[]{1,2,3,4,5};
Arrays.sort(arr);

数组的查找：

int[] arr = new int[]{1,2,3,4,5};
Arrays. binarySearch(arr，3);

二分查找的代码实现：首先找数组必须是已经排序的。第一步，找到数组的中间点，将中间点的元素与目标元素对比，若是比目标元素小，则中间点向右移动一格，并再次找右边的中间点；若是比目标元素大，则中间点向前移动一格，并再次找左边的中间点。一直执行此操作，直到找到该元素。

//升序数组的查找
import java.util.Scanner;

public class Test15ArrayBinarySearch {
    public static void main(String[] args){
        int[] arr = {8,15,23,35,45,56,75,85};
        Scanner input = new Scanner(System.in);
        System.out.print("请输入你要查找的值：");
        int target = input.nextInt();

        int index = -1;
        for(int left = 0,right = arr.length-1; left<=right; ){
            int mid = left + (right-left)/2;

            if(arr[mid] == target){
                index = mid;
                break;
            }else if(target > arr[mid]){
                left = mid+1;
            }else{
                right= mid-1;
            }
        }
        if(index!=-1){
            System.out.println("找到了，下标是"+index);
        }else{
            System.out.println("不存在");
        }

    }
}

数组的冒泡排序：依次比较相邻的两个数，将小数放到前面，大数放到后面。即第一趟，首先比较第1个和第2个元素，将小数放到前面，大数放到后面。然后比较第2个和第3个元素，将小数放到前面，大数放到后面。如此继续，直到比较最后两个数，将小数放到前面，大数放到后面。重复第一趟步骤，直至全部排序完成。

public class TestSeven {
    public static void main(String[] args) {
        int[] arry = {3, 8, 1, 4, 6, 2, 9, 7, 10, 24};
        for (int i = 0; i < arry.length - 1; i++) {
            for (int j = 0; j < arry.length - 1 - i; j++) {
                if (arry[j] > arry[j + 1]) {
                    int temp = arry[j];
                    arry[j] = arry[j + 1];
                    arry[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < arry.length; i++) {
            System.out.print(arry[i] + " ");
        }
    }
}

1.5.4：二维数组

概念：本质上就是元素为一维数组的一个数组。

二维数组的声明：

int[][] a;
//不推荐
int[] a [];
int a[][];

二维数组的初始化及打印：

//定义不规则二维数组
        int[][] array2 = new int[2][];//只初始化第一个数组
        array2[0] = new int[3];
        array2[1] = new int[4];



//定义规则二维数组（矩阵）
        int[][] array = new int[2][3]; //两个小矩阵，每个小矩阵有三个元素
// arrays.length是有几个小矩阵   arrays[i].length是第i 个小矩阵有几个元素
        array[0][0] = 1;//第一个小矩阵的第一个元素
        array[0][1] = 2;
        array[0][2] = 3;
        array[1][0] = 4;
        array[1][1] = 5;
        array[1][2] = 6;
//二维数组的打印
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }

坑：

//   x是一维数组，y是二维数组
        int[] x, y[];