第六章：数组

一，理解

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

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

3. 数组的使用： 

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

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

数据类型 数组名[];  

数据类型 []数组名;    

  int[] a;

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

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

    a = new int[4];

4.细节

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

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

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

(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将数据 8 存储到 a数组中，不够 用，扩容

// 1. 创建一个更大长度的数组 int[] b = new int[a.length*2];

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

中

for(int i=0;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-j=a.length-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=2抡： for(int j=0;j<2;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;

}

}

// 第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.println(a[i]+"\t");

}

(2) 第二种：借助工具类

java.util.Arrays.sort(数组名);