第六章：数组

一、理解：

1、数组：一组连续的存储空间，可以存储多个相同类型的数据，而且乐意统一管理

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

3、数组的使用:

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

        数据类型【】 数组名；

        int[] a;//建议

        int a[];

        int  []a;

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

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

        a = new int [ 5 ]；

4、数组的基本语法：

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

（2）数组的访问：通过数组名+下标，数组名[下标]

（3）访问数组时指定的下标不在合法范围内，则编译通过，运行报错，错误信息为：

        java.lang.ArrayIndexOutfBoundsException(数组的下标越界）

（4）对数组元素进行一一访问，遍历

        //利用循环控制数组的下标

        for（int i=0；i<数组的长度；i++）{

                //数组名[ i ]访问

        }

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、实现数组扩容：

第一种方式：

package demo;

public class Test5{

        public static void main(String[] args){

                int[] a = {7,8,3,5,2};

                // 原来数组的长度

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

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

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

                }

                System.out.println();

                // 将 新的数据 20 存储到 a 数组 中，不够用，需要扩容

                // 1. 创建一个更大空间的新数组

                int[] b = new int[a.length*2];

                // 2. 将原数组元素一一赋值到新数组 中

                //   新 = 原 - 》 新 [0] = 原 [0] ， 新 [1] = 原 [1]

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

                        // 新 = 原

                        b[i] = a[i];

                }

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

                a = b;

                a[5] = 20;

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

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

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

                }

        }

}

第二种方式：

java.util.Arrays.copyOf( 原数组名 , 新数组 的长度);

a=java.util.Arrays.copyOf(a,a.length* 2);

四、二维数组[开发+面试+考试不重要，比赛时应用]

1、理解：类似于excel表格，由行和列组成

2、行和列的下标都是从0开始，行也称为高维，列称为低维

数据类型[ ] [ ]  数组名= new 数据类型[行数] [行列数]；

3、遍历二维数组，通过行和列进行访问

int [ ] [ ] a= new int [5] [4];

a [1] [2] =9;

a [3] [0] =5;

//遍历数组

//外层循环控制行

for（int i=0；i<a.length；i++）{

        //内层循环控制列

        for（int j=0；j<a[ i ].ength；j++）{

                System.out.println（a[ i ] [ j ]+" "）；

        }

}

五、数组的排列

1、排序：将数组中的元素按照一定规则进行存储

2、排列方式：[从小到大]

（1）冒泡排序方式：每次将相邻的两个数据进行一一比较，将较大的数据进行往后移

          // 循环：控制比较轮数

                for(int i=1;i<a.length;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.util.Arrays.sort(a); 借助工具类排序