1.二维数组：二维数组就是存储一维数组(内存地址/引用)的数组

2.二维数组的初始化

1) int intA[][]={{1,2},{2,3},{3,4,5}};

2) int [][] intB=new int[3][5];

3) int []intC []=new int[3][];

intC[0]=new int[2];

intC[1]=new int[3];

intC[2]=new int[5];

1 public classTestArray2 {2 public static voidmain(String[] args) {3 //二维数组不是规则的矩阵

4 int [] intA[] ={{1,2},{2,3,4},{3,4,5,6}};5 System.out.println(intA);//[[I@5e265ba4 两个[[表示是二维的 I表示数组是int型 @5e265ba4是内存地址6

7 //声明一一个二维数组，用于存储3个一维数组，每一个一维数据存多少个数组，不知道 ，null

8 int [][]intB=new int[3][];9 intB[0]=new int[3]; //3

10 intB[1]=new int[]{1,2,3,4}; //3

11 intB[2]=new int[2]; //2

12 System.out.println(intB[1]);//[I@156643d4

13 System.out.println(intB[1][1]);//214

15 //声明一个二维数组，同时创建出一维数组，每个一维数组的长度均相同16 //存储三个一维数组，每个一维数组的长度为4

17 int []intC[]=new int[3][4];18 System.out.println(intC);19

20 }21 }

3.二维数组的遍历

1) 普通 for 循环

2) 加强 for 循环

3) 普通 for 循环+加强 for 循环

public classTestArray3 {public static voidmain(String[] args) {//二维数组

int [] intA[] ={{1,2},{2,3,4},{3,4,5,6}};//(1)普通for循环

for(int i=0;i

for(int j=0;j

System.out.print(intA[i][j]+"\t");

}

System.out.println();

}//(2)加强for循环

System.out.println("\n=========================");for(int[] arr:intA){ //int[]二维数组中元素的类型, arr迭代变量, intA二维组的名称

for(int i:arr){ //int，一维数组中元素的类型，i,迭代变量,arr，一维数组的名称

System.out.print(i+"\t");

}

System.out.println();

}//(3)普通与加强for循环的混搭

System.out.println("\n-------------------------");for(int [] arr:intA){//加强for

for(int i=0;i

System.out.print(arr[i]+"\t");

}

System.out.println();

}

System.out.println("\n--------------------------");for(int i=0;i

System.out.print(j+"\t");

}

System.out.println();

}

}

}

View Code

4.对象数组存储表格数据

张三 　　19　　 男

李四 　　20　　 女

王五 　　28 　　男

数组存基本数据类型，也可以存引用数据类型

对象数组：使用数组存储对象(自定义对象)

public classPerson {private String name;//姓名

private int age;//年龄

private String gender;//性别//重写toString以打印想要的输出 否则只会打印对象的内存地址

@OverridepublicString toString() {//TODO Auto-generated method stub

return name+"\t"+age+"\t"+gender;//}public Person(String name, intage, String gender) {super();this.name =name;this.age =age;this.gender =gender;

}publicPerson() {super();

}publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public intgetAge() {returnage;

}public void setAge(intage) {this.age =age;

}publicString getGender() {returngender;

}public voidsetGender(String gender) {this.gender =gender;

}

View Code

1 public classTestArray {2 public static voidmain(String[] args) {3 //创建一个Person类型的数组，用于存储3个Person类型的对象

4 Person [] pers=new Person[3];5 //创建Person类型的对象

6 Person p1=new Person("张三", 19, "男");7 //将p1对象存储到Person类型的数组中

8 pers[0]=p1;9

10 pers[1]=new Person("李四", 20, "女");11 pers[2]=new Person("王五",28,"男");12

13 for(int i=0;i

17 }18 }

5.数组拷贝

地址的拷贝

int[]array={11,22,33,44};

int[] arrayB=new int[5];

arrayB=array   //两个数组指向同一内存

值的拷贝

int[]array={11,22,33,44};

int[] arrayB=new int[5];

arrayB[0]=array[0];

System 类中的 arraycopy(…)方法：快速，数组大时用次方法。

1 public classTestArrayCopy3 {2 public static voidmain(String[] args) {3 int [] arrA={11,22,33,44};//源数组

4 int [] arrB=new int[5];//目标数组

5

6 System.out.println("数组拷贝之前");7 for(intnum:arrB){8 System.out.print(num+"\t");9 }10 //0 0 0 0 011 //拷贝

12 System.arraycopy(arrA, 0, arrB, 1, 2);13

14 System.out.println("\n数组拷贝之后");15 for(intnum:arrB){16 System.out.print(num+"\t");17 }18 //0 11 22 0 0

19 }20 }

数组是最为常见的一种数据结构，分为一级数组，二维数组以及多维数组。是把相同数据类型的元素，用一个标识符封装到一起的基本类型数据序列或对象序列。

目录

一维数组

创建一维数组

给一维数组赋值

获取数组的长度

常见错误

二维数组

创建二维数组

给二维数组赋值

二维数组的使用场景

多维数组

不规则数组

数组的基本操作

遍历数组

填充和批量替换数组元素

难点解答

为什么数组索引从0开始？

多维数组的长度

一维数组

数组元素的数据类型决定了数组的数据类型，可以是基本数据类型和其他引用类型。符号 “[ ]” 指明该变量是一个数组类型变量。单个 “[ ]” 表示是一维数组。

创建一维数组

声明一维数组有两种方式：

数组元素类型 数组名字[];

int a[];

数组元素类型[] 数组名字;

int[] b;

声明数组后，还不能访问他的任何元素，因为声明数组只是给出了数组名字和元素的数据类型，并未分配内存空间。

在声明数组的时候可以为数组分配内存空间，这种就是将声明和内存分配在一起执行。

数组元素类型 数组名 = new 数组元素类型[数组元素的个数];

int month[] = new int[12];

给一维数组赋值

数组可以与基本数据类型一样进行初始化操作，也就是赋初值，数组的初始化可分别初始化数组中的每一个元素。

数组的初始化有以下3种形式:

int a[] = {1,2,3}; // 第一种方式

int[] b = new int[]{4,5,6}; // 第二种方式

int c[] = new int[3]; // 第三种方式

c[0] = 7;// 第一个元素赋值

c[1] = 8;// 第二个元素赋值

c[2] = 9;// 第三个元素赋值

获取数组的长度

有时候数组分配空间我们没有指明这个时候就可以通过arr.lenth来获取长度。

int a[] = {1,2,3};

System.out.println(a.length);

常见错误

二维数组

二维数组常用于表示二维表，第一个元素代表元素所在的行，第二个下标代表元素所在的列。

创建二维数组

声明二维数组有两种方式：

数组元素类型 数组名字[][];

int tdarr1[][];

数组元素类型[ ][ ] 数组名字；

int[][] tdarr2;

和一维数组一样，二维数组在声明的时候没有分配内存空间，同样要使用new关键字来分配内存 ，然后才可以访问元素。

分配内存有两种方式:

int a[][];

a = new int[2][3];// 直接分配行列

int b[][];

b = new int[2][];// 先分配行,不分配列

b[0] = new int[2];// 给第一行分配列

b[1] = new int[2];// 给第二行分配列

注意:创建二维数组可以只声明行的长度，而不声明列的长度。行的长度是必须得声明的！！！

给二维数组赋值

int tdarr1[][] = {{1,3,5},{4,6,7}}; // 第一种方式

int tdarr2[][] = new int[][] {{1,3,5},{4,6,7}}; // 第二种方式

int tdarr3[][] = new int[2][3];// 第三种方式

tdarr3[0] = new int[] {1,2,3};// 给第一行分配一个一维数组

tdarr3[1][0] = 63;// 给第二行第一列赋值为63

tdarr3[1][0] = 10;// 给第二行第一列赋值为10

tdarr3[1][0] = 7;// 给第二行第一列赋值为7

从这个例子可以看出，二维数组每一个元素也是一个数组，所以第一种直接赋值方式，在大括号内还有大括号，因为每一个元素都是一个一维数组；第二种使用new的方法与一维数组相似。第三种比较特殊，在分配内存空间后，还有两种赋值方式，给某一行直接赋值一个一维数组，或者给某一行的每一个元素分别赋值。

二维数组的使用场景

public static void main(String[] args) {

char arr[][] = new char[4][];// 创建二维数组,数组长度(行)为4

arr[0] = new char[] { '春', '眠', '不', '觉', '晓' };// 为每一行赋值

arr[1] = new char[] { '处', '处', '闻', '啼', '鸟' };

arr[2] = new char[] { '夜', '来', '风', '雨', '声' };

arr[3] = new char[] { '花', '落', '知', '多', '少' };

System.out.println("---横版---");

for (int i = 0; i < 4; i++) {// 循环4行

for (int j = 0; j < 5; j++) {// 循环5列

System.out.print(arr[i][j]);// 输出数组中的元素

}

if (i % 2 == 0) {

System.out.print("，");// 如果是1,3句输出逗号

} else {

System.out.print("。");// 如果是2,4句输出句号

}

// i行结束则换行(注意在哪个循环内执行)

System.out.println();

}

System.out.println();

System.out.println("---竖版---");

for (int j = 0; j < 5; j++) {// 列变行

for (int i = 3; i >= 0; i--) {// 行变列，反序输出

System.out.print(arr[i][j]);// 输出数组中的元素

}

System.out.println();// 换行

}

// 第5行单独输出标点符号

System.out.println("。，。，");// 输出最后的标点

}

运行效果:

多维数组

比一维数组维数高的叫多维数组，理论上二维数组也属于多维数组，Java也支持三维数组，四维等多维数组。创建其他多维数组的方法与二维数组类似。

int a1[][][] = new int[3][4][5];// 创建三维数组

char b1[][][][] = new char[6][7][8][9];// 创建四维数组

不规则数组

java中支持不规则数组，例如二维数组中，不同行的元素个数可以不同:

int a[][] = new int[3][];// 创建二维数组，指定行数，不指定列数

a[0] = new int[5];// 第一行分配5个元素

a[1] = new int[3];// 第二行分配3个元素

a[2] = new int[4];// 第三行分配4个元素

输出不规则二维数组中的所有元素代码示例:

public static void main(String[] args) {

int a[][] = new int[3][];// 创建二维数组，指定行数，不指定列数

a[0] = new int[] {52,64,85,12,3,64};// 第一行分配6个元素

a[1] = new int[] {41,99,2};// 第二行分配3个元素

a[2] = new int[] {285,61,278,2};// 第三行分配4个元素

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

System.out.print("a[" + i +"]中有" + a[i].length + "个元素，分别是：");

for (int tmp : a[i]) {//foreach循环输出元素

System.out.print(tmp + " ");

}

System.out.println();

}

}

输出结果:

数组的基本操作

遍历一维数组很简单，也很好理解，遍历二维数组需要使用双层for循环，通过数组的length属性可获得数组的长度。

遍历数组

代码示例：

public static void main(String[] args) {

int b[][] = new int[][] {{1},{2,3},{4,5,6}}; // 定义二维数组

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

for (int j = 0; j < b[i].length; j++) {

System.out.print(b[i][j]);

}

System.out.println();

}

}

输出结果:

本语法有一个语法需要掌握:如果有一个二维数组a[][],a.length返回的是数组的行数，a[0].length返回的是第一行的列数量。同理，a[n]返回的是第n+1行的列数量，由于二维数组可能是不规则数组，因此在遍历二维数组的时候最好使用length属性控制循环次数。

填充和批量替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法fill()方法来对数组中的元素进行分配，起到填充和替换的效果，fill()方法可以将制定的int值分配给int型数组的每个元素。

语法如下:

Array.fill(int[] a , int value)

a:要进行元素分配的数组

value:要存储数组中所有元素的值

代码示例:

public static void main(String[] args) {

int arr[] = new int[5];

arr[0] = 9;

Arrays.fill(arr, 8);

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

System.out.println("第" + i + "个元素是: " + arr[i]);

}

}

输出结果:

难点解答

为什么数组索引从0开始？

这是继承了汇编语言的传统，从0开始便于计算机做二进制运算和查找。

多维数组的长度

length属性只能表示一个一维数组的长度，二维数组使用的时候其实是将二维数组转为了 “一维数组[一维数组]” 的形式，即一维数组元素仍然是一个一维数组。