这里主要写一些二维数组的简单总结，我对二维数组的理解是：“数组里面套数组”；对比一下一维数组，一维数组中的元素是基本类型的数值或者是引用，那么二维数组的元素即为一维数组，也就是数组中套数组。
这里主要分为两部分来说，1.基本类型的二维数组；2.引用类型的二维数组；其中，在内部会使用for循环和foreach循环进行遍历。废话不多说，直接上代码。
1.基本类型的二维数组
package com.google.array.array06;
/**
* 基本类型多维数组的使用
* 1.静态初始化
* 2.动态初始化
*/
public class BaseTypeTwoDimensionArray {
public static void main(String[] args){
/**
* arr[0][0]=1
arr[0][1]=2
arr[0][2]=3
arr[1][0]=4
arr[1][1]=5
arr[1][2]=6
arr[1][3]=7
arr[2][0]=8
arr[2][1]=9
arr[2][2]=10
arr[2][3]=11
arr[2][4]=12
*/
dynamicInit();
//1 2 3 4 5 6 7 8 9 10 11 12
staticInt();
}
/**
* 动态初始化基本类型的多维数组：
*/
public static void dynamicInit(){
int[] a1={1,2,3};
int[] a2={4,5,6,7};
int[] a3={8,9,10,11,12};
/**
* 我们要建立的数组的形式是：{{1,2,3},{4,5,6,7},{8,9,10,11,12}},即为{a1,a2,a3}
* 抽象出模型结构是：{{},{},{}}；
* 根据下方的定义：new int[3][]中的3指的是外层的"{}"内部有多少个"{}",易知，有a1,a2,a3这三个，所以是new int[3][],
* 至于[3]后面跟着的[]这个指的是a1,a2,a3中的元素的个数，由于a1,a2,a3中的元素个数不一致，所以[]内部不用填，若是填了，
* 则a1,a2,a3的元素个数必须保持一致；
*/
int[][] arr = new int[3][];
//给多维数组赋值：即为数组里面套数组
arr[0]=a1;
arr[1]=a2;
arr[2]=a3;
//arr[3]=a3; //这样同样会出现数组索引越界异常
//调用方法，遍历数组：
print01(arr);
}
/**
* 静态初始化基本类型的数组：
*/
public static void staticInt(){
int[][] arr={{1,2,3},{4,5,6,7},{8,9,10,11,12}};
print02(arr);
}
/**
* 使用普通的for循环遍历：
* 注意：arr.length和arr[i].length的写法：
* @param arr
*/
public static void print01(int[][] arr){
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
System.out.println("arr["+i+"]["+j+"]="+arr[i][j]);
}
}
}
/**
* 使用foreach循环遍历数组：
* @param arr
*/
public static void print02(int[][] arr){
for(int[] arr01:arr){
for(int a:arr01){
System.out.print(a+"\t");
}
}
}
}
2.引用类型的二维数组：
package com.google.array.array06;
public class Student {
private String name;
private int age;
public Student(){}
public Student(String name,int age){
this.name=name;
this.age=age;
}
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.google.array.array06;
/**
* 引用类型多维数组的使用：
*/
public class RefTypeTwoDimensionArray {
public static void main(String[] args){
/**
* studnt[0][0]=Student{name='琴酒', age=13}
studnt[1][0]=Student{name='雪莉', age=14}
studnt[1][1]=Student{name='朗姆', age=15}
*/
dynamicInit();
/**
* Student{name='琴酒', age=13}
Student{name='雪莉', age=14}
Student{name='朗姆', age=15}
*/
staticInt();
}
/**
* 动态初始化引用类型的多维数组：
*/
public static void dynamicInit(){
Student[] s1 = {new Student("琴酒",13)};
Student[] s2 = {new Student("雪莉",14),new Student("朗姆",15)};
//创建一个二维数组对象：
Student[][] student = new Student[2][];
//给二位数组赋值：
student[0]=s1;
student[1]=s2;
//循环遍历数组:
print01(student);
}
/**
* 静态初始化引用类型的数组：
*/
public static void staticInt(){
Student[][] student = {{new Student("琴酒",13)},{new Student("雪莉",14),new Student("朗姆",15)}};
print02(student);
}
/**
* 使用for循环遍历：
*/
public static void print01(Student[][] student){
for(int i=0;i<student.length;i++){
for(int j=0;j<student[i].length;j++){
System.out.println("student["+i+"]["+j+"]="+student[i][j]);
}
}
}
/**
* 使用foreach循环遍历数组
*/
public static void print02(Student[][] student){
for(Student[] s1:student){
for(Student s2:s1){
System.out.println(s2);
}
}
}
}