• 数组的定义

数组定义：数组也就是有序的元素序列，当有多个类型相同的数据时，我们就可以用数组将所有的数字放在一起统一管理，相当于一个特定的容器。数组类似于字符串，都是通过索引/角标来获取元素的。

数组的本质：

1.数组就是一系列空间大小相等且地址连续的一片存储空间，为了方便统一维护我们的数据，必须得保证数据之间的类型是一样的。

2.数组存在于堆内存中，但凡在堆中存储的数据都称之为对象，但凡在堆内存中创建的对象都会有默认初始值

整数类型默认0

浮点类型默认0.0

引用数据类型(对象)默认null

注意：

1.数组提供角标来访问数组当中的元素

2.数组变量存的就是数组在堆内存中首元素的地址

3.数组通过角标来访问元素的具体计算方式是 所要访问数据的地址=首元素地址+角标*数据类型大小

4.数组一旦定义下来，其长度不可改变；数组中的地址数目就是数组的长度。

 数组的创建（三种形式）：

//必须确定数组的长度或者内容

数据类型[] 数组名=new 数据类型[长度];

数据类型[] 数组名=new 数据类型[]{具体内容}；

数据类型[] 数组名={具体内容};

//数组的命名方式
int[] arr1 = new int[4];
int[] arr2 = new int[]{1,2,3,4};
int[] arr3 = {1,2,3,4};

• 数组常见错误

1.ArrayIndexOutOfBoundsException 数组角标越界（超过数组最大下标）

2.NullPointerException 空指针异常（对象未初始化或为空时）

• 基本数组操作

1.遍历  2.赋值  3.查找最大值/最小值

以上三个问题代码如下：

import java.util.Scanner;
class Test05{
    public static void main(String[] args){
        bianli();

        fuzhi();

        
        Min_Max();
    }
    //遍历操作
    public static void bianli(){
        int[] arr={1,7,4,7,8,9,4,1};
        //数组只有一个唯一的属性 length 数组的长度
        //通过数组长度作为结束，遍历数组
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
    //赋值操作
    public static void fuzhi(){
        Scanner scanner=new Scanner(System.in);
        // System.out.print("请输入10个数字：");
        int[] arr2=new int[10];
        for(int i=0;i<arr2.length;i++){
            System.out.print("请输入1个数字：");
            arr2[i]=scanner.nextInt();
        }
        for(int i=0;i<arr2.length;i++){//for循环遍历数组时赋值
            System.out.print(arr2[i]+" ");
        }
    }
    //查最大最小值
    public static void Min_Max(){
        int[] arr={1,7,4,7,8,9,4,1};
        int max=arr[0];
        int min=arr[0];
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<min){
                min=arr[i];
            }
        }
        System.out.println("最大值"+max);
        System.out.println("最小值"+min);

    }
}

• 二维数组

定义：维数组本质上是以数组作为数组元素的数组，也就是一个由行和列组成的一个表格而已，矩阵也称为是一个二维数组。

注意，矩阵——>二维数组；二维数组不一定是矩阵。特别的：如果一个二维数组的行和列相等的话，也称之为是方阵

访问元素：我们在这个矩阵中访问元素的话，是根据元素的行角标和列角标所确定的 。

存储方式：二维数组本身可以看成一个一维数组，这个一维数组里面每个元素又是一个一维数组。见下图。

定义数组：

①int[][]  matrix=new int[3][4];//创建一个3行4列的二维数组，元素默认都是0

②int[][] matrix=new int[][]{//创建个指定元素的二维数组
    {1,2,3,4} ,
    {5,6,7,8} ,
    {9,10,11,12}

};

③int[][] matrix={//锯齿矩阵（并不是标准的矩阵）/二维数组
    {1,2,3,4} ,
    {5,6,7} ,
    {8,9},
    {10}
};

• 查找操作

1.线性查找

2.二分查找（数组必须有序）

3.斐波那契查找

 通过两张张动图来理解前两种种查找方式：

线性检索和二分检索求 23 的位置：

线性检索和二分检索求 1的位置

注：转载http://codingpy.com/article/10-gifs-to-understand-some-programming-concepts/

class Test06{
    public static void main(String[] args){
        //线性查找
        linearSearch();
        //二分查找
        binarySearch();
    }
    public static void binarySearch(){
        //二分查找有个前提 数组必须有序
        /* 
        最好情况 查46 1次就出来了
        最坏情况 查12/60 O(logn)
        */
        int[] arr={12,17,21,32,38,41,46,49,50,50,51,59,60};
        int key=17;//查找的数字
        int index=-1;//默认找不到为-1
        int min_index=0;//最小值下标初始为0
        int max_index=arr.length-1;//最大值下标初始为arr.length-1
        int mid_index=(min_index+max_index)/2;//中间值下标计算
        while(arr[mid_index]!=key){//中间值不是查找值是进行循环

            if(key<arr[mid_index]){//当key<arr[mid_index]更新最大下标
                max_index=mid_index-1;
            }
            if(arr[mid_index]<key){//当arr[mid_index]<key更新最小下标
                min_index=mid_index+1;
            }
            if(min_index>max_index){//找不到直接退出循环
                index=-1;
                break;
            }
            mid_index=(min_index+max_index)/2;//更新中间下标
        }
        System.out.println(mid_index);

    }

    public static void linearSearch(){
        /* 
        最好情况 查10 1次就出来了
        最坏情况 查5  10次才出来
        当数组的长度越大的话 最坏情况越差
        时间复杂度(最坏情况) O(n) 线性阶
        */
        int[] arr={10,2,8,3,1,6,4,7,9,5};
        int key=11;
        int index=-1;   //key元素不存在
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                index=i;
                break;
            }
        }
        System.out.println(index);
    }
}

关于数组中的几种排序问题，放在下个博客中讲解。