Java语言程序设计1 第六章：数组

一、理解

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

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

3. 数组的使用：

        (1) 声明数组：确定数据类型

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

             数据类型 数组名[];

             数据类型 []数组名;

             int[] a;

        (2) 分配空间：确定数组的长度

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

             a = new int[4];

4. 细节：

        (1) 数组下标：从0开始，依次为 0、1、2、3... 数组的长度-1

        (2) 访问数组时，采用数组名+下标，数组名[下标]

        (3) 操作数组时，给定的下标不在合理范围内，编 译通过，运行报错，错误信息为： java.lang.ArrayIndexOutOfBoundsExcepti on:(数组的下标越界)

        (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) 声明的同时并分配空间：

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

        (3) 显示初始化：

             数据类型[] 数组名= new 数据类型[]{值1, 值2,值3};

        (4) 显示初始化：

             数据类型[] 数组名= {值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.print(a[i]+"  ");

                        }

                System.out.println();

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

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

                int[] b = 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.print(a[i]+"  ");

                        }

        (2) 第二种方式：

             借助工具类： java.util.Arrays.copyOf(数组名,新数组的长度);

四、二维数组

        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]){

                        // 交换：借助第三遍历

                int temp = a[j];

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

                a[j+1] = temp;

                }

        }

                // 第i=2论：

                for(int j=0;j<2;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;

                        }

                 }

        // 第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.length;i++){

                        //内层循环，控制每一轮具体比较的内容

                for(int j=0;j< a.lengthi;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=0;i<a.length;i++){
                System.out.print(a[i]+"\t");

        }

        (2) 第二种：

        借助工具类 java.util.Arrays.sort(数组名);