二维数组的初始化与遍历

Dear 丶 2022-05-24 13:45 201阅读 0赞

这里主要写一些二维数组的简单总结，我对二维数组的理解是：“数组里面套数组”；对比一下一维数组，一维数组中的元素是基本类型的数值或者是引用，那么二维数组的元素即为一维数组，也就是数组中套数组。

这里主要分为两部分来说，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);
                }
            }
        }
    }