多维数组

多维数组
二维数组的定义： 二维数组就是存储一维数组(内存地址/引用)的数组

10.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];

0.3 二维数组的遍历

1. 普通 for 循环

   package com.bjsxt.array;

   public class TestArray {

   public static void main(String[] args) {

   //(1)数组可以存储基本数据类型和引用数据类型

   int [] arrA={11,22,33,44}; //一维数组，引用数据类型

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

System.out.println(arrA);
//(2)二维数组存储一维数组的数组

int [] [] arrB=new int[3][];

//使用二维数组去存储一维数组

arrB[0]=arrA;  //引用

System.out.println(arrB);

}

}

2. 加强 for 循环

package com.bjsxt.array;

 

public class TestArray2 {

public static void main(String[] args) {

//二维数组不是规则的矩阵

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

System.out.println(intA);

 

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

int [][]intB=new int[3][];

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

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

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

System.out.println(intB);

 

//声明一个二维数组，同时创建出一维数组，每个一维数组的长度均相同

//存储三个一维数组，每个一维数组的长度为4

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

System.out.println(intC);

 

}

}

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

 

package com.bj

sxt.array;



public class TestArray3 {

public static void main(String[] args) {

//二维数组

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

//(1)普通for循环

for(int i=0;i<intA.length;i++){ //0,1,2

for(int j=0;j<intA[i].length;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<arr.length;i++){

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

}

System.out.println();

}

System.out.println("\n--------------------------");

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

for(int j:intA[i]){//加强for

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

}

System.out.println();

}

}

}

10.4 多维数组 

二维数组是存储一维数组的数组 

三维数组，存储二维数组的数组 

四维数组，存储三维数组的数组 

 

2.对象数

组存储表格数据

2.1 使用对象数组存储表格数据

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

对象数组：使用数组存储对象（自定义对象）

package com.bjsxt.arrayobject;

public class TestArray {

public static void main(String[] args) {

//创建一个Person类型的数组，用于存储3个Person类型的对象

Person [] pers=new Person[3];

//创建Person类型的对象

Person p1=new Person("张三",
19, "男");

//将p1对象存储到Person类型的数组中

pers[0]=p1;

pers[1]=new Person("李四",
20, "女");

pers[2]=new Person("王五",28,"男");

 

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

System.out.println(pers[i]);

}

//对象数组中存储的是对象的引用（内存地址）

}

}

 

 

package com.bjsxt.arrayobject;

 

public class Person {

private String name;//姓名

private int age;//年龄

private String gender;//性别

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getGender() {

return gender;

}

public void setGender(String gender) {

this.gender = gender;

}

public Person(String name, int age, String gender) {

super();

this.name = name;

this.age = age;

this.gender = gender;

}

public Person() {

super();

}

 

@Override

public String toString() {

// TODO Auto-generated method stub

return name+"\t"+age+"\t"+gender;

}

}

3.数组的拷贝

3.1 地址的拷贝

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

 
int[] arrayB=new int[5];

 arrayB=array; 

3.2 值的拷贝

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

  
int[] arrayB=new int[5]; 

 
arrayB[0]=array[0];

 

 

package com.bjsxt.arraypro;

 

public class TestArrayCopy {

public static void main(String[] args) {

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

//创建一个数组

int [] arrB=new int[5];

System.out.println("拷贝地址（引用）之前");

System.out.println("arrA="+arrA);

System.out.println("arrB="+arrB);

 

 

//引用的拷贝

arrB=arrA;

System.out.println("拷贝地址（引用）之后 ");

System.out.println("arrA="+arrA);

System.out.println("arrB="+arrB);

}

}

package com.bjsxt.arraypro;

 

public class TestArrayCopy2 {

public static void main(String[] args) {

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

int [] arrB=new int[5];

//复制

/*arrB[0]=arrA[0];

arrB[1]=arrA[1];

arrB[2]=arrA[2];

arrB[3]=arrA[3];*/

System.out.println("赋值之前");

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

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

}

//两个数组的长度的最小值

int length=Math.min(arrA.length, arrB.length);

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

arrB[i]=arrA[i];

}

//遍历arrB数组

System.out.println("\n赋值之后");

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

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

}

 

}

}

package com.bjsxt.arraypro;

public class TestArrayCopy3 {

public static void main(String[] args) {

int [] arrA={11,22,33,44};//源数组

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

 

System.out.println("数组拷贝之前");

for(int num:arrB){

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

}

//拷贝

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

 

System.out.println("\n数组拷贝之后");

for(int num:arrB){

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

}

 

}

}