Java数组

数组概述：
        1.一次性声明大量的用于存储数据的变量
        2.要求村储存的数据通常但是同类型数据
 


什么是数组：
        数组（array）是一种储存多个相同类型的数据的储存模型



数组的定义格式：
        格式一：
                数据类型 [] 变量名
        例如：
                int [] arr
                定义一个int 类型的数组，数组名是arr

        格式二：
                数据类型  变量名 []
        例如：
                int  arr []
                定义一个int 类型的变量，变量名是arr数组
        格式二不推荐使用


数组初始化的概述：
         1.Java中数组必须先初始化然后才能使用
         2.所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值


数组初始化方式：
        1.动态初始化
        2，静态初始化


动态初始化：
        初始化时只指定数组长度，由系统为数组分配初始化
        引用类型  初始化值   null
        整数类型  初始化值   0
        浮点类型  初始化值   0.0
        字符类型  初始化值   空
        布尔类型  初始化值   false
   格式：
        数据类型 [] 变量名 = new 数据类型 [数组长度]
   范例：
        int [] arr = new int [3];
     左边：
        int 说明数组中的元素类型int类型
        []  说明这是一个数组
        arr 数组名
     右边：
        new 为数组申请内存空间
        int 说明数组中的元素类型int类型
        []  说明这是一个数组
        3   数组长度，其实就是数组中的元素个数

 数组元素访问：
        1.1 数组变量访问方式
        1.2 数组名
        
        2.1 数组中保存的数据访问方式
        2.2 格式：数组名[索引]
        
        3.1 索引是数组中的编号方式
        3.2 索引用于访问数组中的数组使用，数组名[索引]等同于变量名。是一种特殊的变量名
        3.3 索引是从0开始的
        3.4 索引是连续的
        3.5 索引是逐一增加的，每次加1

        int [] arr = new int [3];
        System.out.println(arr);        //输出数组的地址
        System.out.println(arr[0]);    //输出数组中的元素

 

内存分配：
        Java程序运行时，需要在内存中分配空间，为了提高运算效率，就对空间进行不同区域的划分，         因为每一片区域都有特定的处理数据方式和内存管理方式

Java中内存分配：
        int [] arr = new int [3];

        栈内存：
                储存局部变量
        堆内存 
                储存new出来的内容（实体，对象）

       1.1  在运行时int [] arr 会在栈内存里开辟一个空间存储数据
       2.1  new int [3] 会在堆内容里开辟一个空间存储数据
       2.2  在数组初始化时，会为储存空间添加默认值，并生产内存地址
            引用类型  初始化值   null
            整数类型  初始化值   0
            浮点类型  初始化值   0.0
            字符类型  初始化值   空
            布尔类型  初始化值   false
       3.1 堆内存中的内存地址会赋值给 arr ,这样栈内存就可以通过内容地址找到堆内存中
           相对应的数据

多个数组指向相同：

ublic class lianxi {
    public static void main(String[] args) {
        int [] arr = new int [3];

        arr[0]=100;
        arr[1]=200;
        arr[2]=300;

        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        //定义第二个数组指向第一个数组
        int [] arr2 = arr;
        arr2 [0] = 111;
        arr2 [1] = 222;
        arr2 [2] = 333;

        System.out.println(arr);
        System.out.println(arr2[0]);
        System.out.println(arr2);
        System.out.println(arr2[0]);

    两个数组同时指向一个地址时，任意一个数组为元素赋值，那么这两个数组的元素值都会重新赋值

静态初始化：
   初始化时指定每个数组元素的初始值，由系统决定数组长度
格式：
   数据类型 [] 变量名 = new 数据类型 [] {数据1，数据2，数据3，...};
范例：
   int [] arr = new [] {1,2,3} 
简化格式(推荐格式)：
   数据类型 [] 变量名 ={数据1，数据2，数据3，...}   
范例：
   int [] arr ={1,2,3,...}

数组操作的小问题：
  索引越界：
    访问了数组中不存在的索引对应的元素，造成索引越界
  空指针：
    访问的数组已经不再指向堆内存的数据，造成空指针异常
  null:
    空值，应用数据类型的默认值，表示不指向任何有效对象

遍历格式：
    数组名.length  获取数组长度
    int [] arr = {.....};
        int max  = arr[0];
    for(int x = 0 ; x <arr.length; x++){
        if(arr [x] > max){
        max = arr[x];
                }
        }
    System.out.println(max)
    如果前面是动态初始化 ，使用length要在后面-1

获取最值（冒泡排序）：
    int [] arr = {15,85,99,6,3,28,77};
    int max = arr[0];
    for(int x = 1 ; x < arr.length; x++){
    System.out.println(max);
    }

二维数组举例：
        int [][] a = {{1,2},{3,4,0,9},{5,6,7}};
        Java中多维数组不必须是规则矩阵形式

        二维数组可以看成以数组为元素的数组。
        例如：
        int [][] a= {{1,2},{3,4,5,6},{7,8,9}};

        Java中多维数组的声明 堆内存和初始化应按从高维到 低维的顺序进行，
        例如：
        int [][] a= new int[3][];
        a[0] = new int[2];
        a[1] = new int[4];
        a[2] = new int[3];
        int t1[][] = new int[][4]; //非法
        int intA[][] = {{1,2},{2,3},{3,4,5}};
        int intB[3][2] = {{1,2},{2,3},{4,5}};//非法

总结:
 一维数组入门
    数组的特点：长度固定，连续空间，存储同一种类型数据
    数组内存分配图
    for-each循环：简单、主要用于遍历操作
 一维数组的应用
    数组优缺点
    优点：按照索引查询效率高
    缺点：添加删除元素效率低；按照内容查询效率低（无序）
 冒泡排序：
    基本的排序算法，理解排序规则，实现并完善排序代码
    数组类型做形参
 二维数组：
    实质是每个元素是一维数组的一维数组；二维数组内存分配