第六章：数组

一、理解

        1.数组：一次性的定义多个同类型的变量，可以存储多个数据，而且可以对多个变量进行统一管理

        2.数组的重要因素：数据类型、数组的长度

        3.数组的使用

                （1）声明数组：确定数据类型

                        数据类型 [ ] 数组名；// 建议

                        数据类型 数组名 [ ] ；

                        数据类型 [ ] 数组名；

                        int [ ] a;

                （2）分配空间：确定数组的长度

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

                        a=new int [ 4 ] ；

        4.细节：

                （1）数组下标：从0开始，以此为0、1、2、3...数组的长度-1

                （2）访问数组时，采用数组名+下标，数组名[下标]

                （3）操作数组时，给定的下标不在合理范围内，编译通过，运行报错，错误信息为：

                        java.lang.ArrayIndexOutOfBoundsException：（数组的下标越界）

                （4）/ / 对数组元素进行——，称为数组遍历

                        for(int i=0;i<5;i++) {

                        System.out.println("i="+i+"对应的元素为："+ages[i])；

                        }

                （5）获取数组的长度：数组名.length

        5.数组的默认值：

                整数类型：0

                小数类型：0.0

                布尔类型：false

                字符类型：空字符

                引用类型：null        

        6.数组 不同定义方式：

                （1）先声明，在分配空间；

                        数据类型 [ ] 数组名；

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

                （2）声明的同时并分配空间：

                        数据类型 [ ] 数组名=呢哇数据类型 [长度] ；

                （3）下那是初始化：

                        数据类型 [ ] 数组名={值1，值2，值3}；

                        注意：数组的声明和初始化一起完成

二、数组的内存

        1.数组在内存种空间是连续的

        2.数组类型的变量，存储使数组内存空间的首地址

        3.寻址方式：首地址+下标*数据类型字节数

三、数组的扩容

        1.思想：

                （1）船舰一个更大的空间的新数组，通常为原数组的2倍

                （2）将原数组的内容进行——赋值到新的数组中  

                （3）新地址覆盖旧地址

        2.扩容的实现：

                （1）第一种方式：

                                int [ ] a={4,7,3}; / / 数组的长度为

                                        System.out.println("数组的长度为："+a.length);

                                        for(int i=0;i<a.length;i++){

                                                System.out.println(a[i]+"");

                                        }

                                        System.out.println();

                                        / / 将数据8存储到a数组中，不够用，扩容

                                        / / 1.创建一个更大长度的数组

                                        int [ ] n=new

                                        int[a.length*2];

                                        / / 2.将原数组的内容——赋值新数组中

                                        for(int i=0;i<a.length;i++){

                                        / / 新数组中=原数组中内容

                                        b[i]=a[i];

                                        }

                                        / / 3.新的地址覆盖旧的地址

                                        a=b;

                                        System.out.println("扩容后的长度为："+a.length);

                                        for(int i=0;i<a.length;i++){

                                                System.out.println(a[i]+"");

                                        }

                （2）第二种方式：借助工具类：

                                        java.unlil.Arrays.copy0f(数组名，新数组的长度)；

四、二维数组

        1.二维数组：类似于excel表格，有行和列构成

        2.行标和列标都是从0开始，访问二维数组通过行和列进行访问：数组名 [ 行下标/高纬 ] [ 列下标/低维 ]

        3.二维数组的定义：数据类型  [ ] [ ] 数组名=new 数据类型 [ 行数 ] [ 列数 ] ；

                                        int [ ] [ ] a=new int [ 4 ] [ 3 ]; / / 4行3列二维数组

五、数组的排序

        1.排序：将数组中元素按照一定的排序顺序进行存储

        2.排列方式：从大到小

                （1）冒泡顺序：每次将相邻的两个元素进行一一比较，较大的值往后放

                                        int [ ] a = { 9,4,5,2,6,3,1,9 } ；

                                                /* 从此小到大进行排序

                                                      冒泡排序：每次将相邻的两个元素进行一一比较，较大的值往后

                                下标：  0    1    2    3

                                元素：  9    4    5    2

-------------------------------------------------------第一轮-----------------------------------------------------

                                a0~a1   4   9   5   2  

                                a1~a2   4   5   9   2

                                a2~a3   4   5   2   9  (最大值)

-------------------------------------------------------第二轮-----------------------------------------------------

                                a0~a1   4   5   2   9  

                                a1~a2   4   2   5   9

-------------------------------------------------------第三轮-----------------------------------------------------

                                a0~a1   2   4   5   9

                                */

                        // 第 i=1 轮：使用 a [ j ] 代表第一个比较项，相邻的一项 a [ j+1 ] 

                        /* for(int j=0;j<3;j++){

                        / / x=4-i=a.length-i

                        / / 使用 a [ j ] 和 a [ j+1 ] 进行比较

                                If（a [ j ] 和 a [ j+1 ] 进行比较）

                                if ( a [ j ] < a [ j+1 ] ){

                                / / 交换：借助第三遍历

                                int temp = a [ j ] ; 

                                a [ j ] = a [ j+1 ] ;

                                a [ j+1 ] = temp ;

                        }        

                }

                / /第 i=3 轮

                for(int j=0;j<1;j++){

                        // 使用 a [ j ] 和a[ j+1 ]进行比较

                        if (a [ j ] > a [ j+1 ] ){

                        // 交换:借助第三遍历

                        int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp;
                }
        }

                                */
                        // 外层循环控制比较的轮数
                        for(int i=1;i<a.1ength;i++){
                        // 内层循环，控制每一轮具体比较的内容
                        for(int j=0;j< a.length-i;j++){
                        // 使用 a[j] 和 a[j+1]进行比较
                        if(a[j] > a[j+1]){
                        // 交换:借助第三遍历
                        int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp;

                        }

               }

                （2）第二种：借助工具类

                                java.unil.Arrays.sort（数组名）；