第六章：数组

 一，理解：

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.ArrayIndexOutOfBoundsExcept ion(数组的下标越界)

  (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.println(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.println(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].length;j++){

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

                        }

                        System.out.println();

                }      

五、数组的排序

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

2. 排序方式：[从小到大]

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

  // 循环：控制比较轮数

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

        for(int j=0;j<a.length-j;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);借助工具类 排序