JavaSE 数组

数组

1.数组的定义

• 为什么要引入数组

之前在定义数据的时候大部分都是用变量来存储数据
程序中存在大量的数据，一般而言会创建多个变量存储这些数据，显得比较麻烦。

这些变量基本上是类型是共通的，就可以使用一个容器将所有的数字进行管理。类似于字符串。可以通过索引/角标来获取其中的某一个数字，

数组主要解决多变量多数据的存储问题，方便程序后期统一维护操作数据。

数组的本质是：数组是一系列空间大小相同，且地址连续的一片存储空间

• 空间大小相等：
  为了方便统一维护数据，必须得保证数据之间的类型是一样的。（多个同类型的变量空间连在一起）

• 变量空间的地址是连续：
  就是为了方便统一操作数据。好处在于，访问数据时会比较方便（快捷）

• 总结：

1. 数组就是一片地址连续且空间大小一致的存储空间。（但是每个空间中还是存的别的数据的地址）
2. 数组存在于堆内存中，堆中存储的数据都称之为对象 但凡在堆内存中创建的对象都有默认初始值 整数 默认0 浮点 默认 0.0 布尔类型 默认 false 引用数据类型（对象）null
3. 数组提供角标来访问数组当中的元素
4. 数组变量存的是数组在堆内存中首元素的地址
5. 数组通过角标来访问元素的计算方式是 所要访问的数据的地址=首元素地址+角标*数据类型大小
6. 数组一旦定义其长度不可改变。数组中有几个元素空间 == 数组的长度
7. 创建数组时，必须明确规定大小或者内容。
   数据类型[] 数组名 = new 数据类型[长度] 创建数组只指定长度但不指定内容
   数据类型[] 数组名=new 数据类型[]{1,2,3,4,5}；创建数组指定内容(指定长度)
   数据类型[] 数组名={1,2,3,4,5}; 创建数组指定内容(指定长度)

[]表示是一维数组，[]表示是一维数组

2.数组的内存分析

当一个数组对象没有任何变量引用它时，数组对象在堆内存中就没有存在的意义了。
所以该对象变成垃圾，由【垃圾回收器gc】处理。
【垃圾回收器】是JVM中的一个程序 专门用于负责处理堆内存中垃圾数据的。
垃圾的处理并不是及时的，有【gc】来控制，当垃圾堆攒到一定程度时才由【gc】来处理。
特殊的 在C/C++中 如果出现对象垃圾 必须由程序员手动处理 free()及时处理。

3.数组的常见错误

ArrayIndexOutOfBoundsException 数组角标越界
NullPointerException 空指针异常

4.基本数组操作

• 遍历

class Test{
    public static void main(String[] args){
        //遍历操作
        bianli();
    }
	public static void bianli(){
        int[] arr={1,2,3,4,5,6,7,8,9};//[0,8]
        //数组只有一个唯一的属性 length 数组的长度
        System.out.println(arr.length);
        for(int i=0;i<arr.length;i++){
       		System.out.println(arr[i]);
        }
    }	
}

• 最大值/最小值

import java.util.Scanner;
class Test{
    public static void main(String[] args){
    //最大值/最小值
        maxormin();
    }
	public static void maxormin(){
        //计算最大值或最小值的 值
        //计算最大值或最小值的 角标
        //需求 获取最大的值10 获取最小值的角标4
        int[] arr={10,2,8,3,1,6,4,7,9,5};
        int max=arr[0];
        int min_index=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<arr[min_index]){
                min_index=i;
            }
        }
        System.out.println("最大值"+max);
        System.out.println("最小值角标"+min_index);
    }
}

• 赋值

import java.util.Scanner;
class Test{
    public static void main(String[] args){
   		//赋值操作
        fuzhi();
    }
    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++){
            System.out.print(arr2[i]+" ");
        }
    }
}

5.查找操作

• 线性查找

class Test{
    public static void main(String[] args){
        //线性查找
        linearSearch();
    }
	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);
    }
}

• 二分查找

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=46;
        int index=-1;
        int min_index=0;
        int max_index=arr.length-1;
        int mid_index=(min_index+max_index)/2;
        while(arr[mid_index]!=key){
            if(key<arr[mid_index]){
                max_index=mid_index-1;
            }
            if(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);
    }
}

6.二维数组

二维数组就是一个由行和列组成的一个表格而已，也可称为矩阵Matrix。
我们在这个矩阵中访问元素的话，是根据元素的行角标和列角标所确定的
特别的，如果一个二维数组的行和列相等的话，也称之为是方阵
二维数组具体是在内存中如何存储的呢？
无论是二维数组，还是多维数组，它们本身就是一个一维数组。尤其对于二维数组而言，无非就是一个一维数组，只不过该一维数组中的每一个元素是另一个一维数组罢了。

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} 
};

matrix.length 表示的就是最外层那个一维数组的长度 行数
matrix[i] 表示的是最外层那个一维数组当中角标i的那个元素 只不过这个元素也是一个一维数组
matrix[i].length 表示的是这个一维数组元素的长度(当前行的长度)
matrix[i][j] 表示的就是这个一维数组元素中角标j的那个元素