一维数组与二维数组的使用方法

在介绍一维数组和二维数组之前，先理解数组概念

数组的概述

数组的理解：数组（Array），是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名， 并通过编号的方式对这些数据进行统一管理。

数据相关的概念：

>数组名

>元素

>角标，下标，索引

>数组的长度：元素的个数

数组的分类：

①按照维数：一维数组，二维数组......

②按照数组元素的类型：基本数据类型元素的数组、引用数组类型元素的

一维数组：

①一位数组的声明和初始化

②如何调用数组的 指定位置的元素

③如何获取数组的长度

④如何遍历数组

⑤数组元素的默认初始化值

⑥数组的内存解析

public class ArrayTest {
    
    public static void main(String[] args) {
        
       //变量的声明和初始化
        int num;//声明
        num = 20;//初始化
        int id = 1001;//声明+ 初始化
        
        //1，一维数组的声明和初始化
        int[] ids;//声明
        //1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行
        ids = new int[]{1001,1002,1003,1004};
        //1.2动态初始化：数组的初始化和数组元素的赋值操作分开进行
        String[] names = new String[5];
        
        //错误的写法：
        //int[] arr1 =new int[];
        //int[5] arr2 = new int[5];
        //int arr3 = new int[3]{1,2,3};
        
        //也是正确的写法：
        int[] arr4 = {1,2,3,4,5};//类型推断
        
        //总结：数组一旦初始化完成，其长度就确定了
        
        //2.如何调用数组的指定位置的元素：通过角标的方式调用。
        //数组的角标（或索引）从0开始，到数组的长度-1结束。
        names[0] ="asd";
        names[1] ="qwe";
        names[2] ="zxc";
        names[3] ="rty";
        names[4] ="fgh";//charAt(0);
        //names[5] ="vbn";
        
        //3,如何获取数组的长度：
        //属性：length
        System.out.println(names.length);    //输出5
        System.out.println(ids.length);        //输出4
        
        
        //4.如何遍历数组
    /*    System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);
        System.out.println(names[3]);
        System.out.println(names[4]);
        */
        
        for(int i =0;i < names.length;i++) {
            System.out.println(names[i]);
        }
    }
}

二维数组：

理解：对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素存在。

其实，从数组底层的运行机制来看，并没有多维数组。

二维数组的使用：

①二维数组的声明和初始化

②如何调用数组的指定位置的元素

③如何获取数组的长度

④如何遍历数组

⑤数组元素的默认初始化值:见ArrayTest3

⑥数组的内存解析:见ArrayTest3

二维数组的使用：

规定：二维数组分为外层数组的元素，内层数组的元素

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

外层元素：arr[0],arr[1]等

内层元素:arry[0][0],arr[1][2]等

数组元素的默认初始化:

针对于初始化方式一：比如int[][] arr = new int[4][3];

外层元素的初始化值为：地址值

内层元素的初始化值为：与一维数组初始化情况相同

针对初始化方式二：比如：int[][] arr = new int [4][];

外层元素的初始化值为：null

内层元素的初始化值为：不能调用，否则报错。

例1：

public class ArrayTest2 {
        public static void main(String[] args) {
            //1.二维数组的声明和初始化
            int[] arr = new int [] {1,2,3};//一维数组
            //静态初始化
            int[][] arr1 = new int[][] {{1,2,3},{4,5},{6,7,8}};
            //动态初始化1
            String[][]    arr2 = new String[3][2];
            //动态初始化2
            String[][] arr3 =new String[3][];
            
            //错误的情况

//            String[][]    arr4 = new String[][2];
//            String[][]    arr5 = new String[][];
//            int[][] arr6 = new int[4][3] {{1,2,3},{4,5},{6,7,8}};

            //也是正确的写法：
            int[] arr4[] = new int[][] {{1,2,3},{4,5},{6,7,8}};
            int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//类型推断

            //2.如何调用数组的指定位置的元素
            System.out.println(arr1[0][1]);//输出：2
            System.out.println(arr2[1][1]);//输出：null
            
            arr3[1] = new String[4];//在1行里面，再建4列
            System.out.println(arr3[1][0]);
            
            //3.获取数组的长度
            System.out.println(arr4.length);//3
            System.out.println(arr4[0].length);//3
            System.out.println(arr4[1].length);//2
            
            //4.如何遍历二维数组
            for(int i =0;i < arr4.length;i++) {
                
                for(int j = 0;j < arr4[i].length;i++) {
                    System.out.println(arr4[i][j] + "  ");
                }
                System.out.println();
            }
        }
}

例2

public class ArrayTest3 {
    public static void main(String[] args) {
        
        int[][] arr = new int[4][3];
        System.out.println(arr[0]);//[I@15db9742
        System.out.println(arr[0][0]);//0
        
        //System.out.println(arr);//地址值
        
        System.out.println("*************");
        float[][] arr1 = new float[4][3];
        System.out.println(arr1[0]);//地址值
        System.out.println(arr[0][0]);//0.0
        
        System.out.println("*************");
        
        String[][] arr2 = new String[4][2];
        System.out.println(arr2[1]);//地址值
        System.out.println(arr2[1][1]);// null
        
        System.out.println("*************");
        
        double[][] arr3 = new double[4][];
        System.out.println(arr3[1]);//null
    //    System.out.println(arr3[1][0]);//报错
    }
}

关于数组的例题：

算法的考查：求数值型数组元素中元素的最大值，最小值，平均数，总和等

* 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，

* 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。

* 要求：所有随机数都是两位数。

* [10,99]

public class ArrayTest1 {
    public static void main(String[] args) {
        int[] arr = new int[10];
          
        for(int i = 0;i < arr.length;i++) {
           /*  公式(int)(Math.random() * (99-10+1)+10
           * random是一个double型的值  [0,1*/
            arr[i] =(int)(Math.random() * (99-10+1)+10) ;
        }
        //遍历
        for(int i =0;i < arr.length;i++) {
            System.out.println(arr[i] + "\t");
        }
        System.out.println();
        
        //求数组元素的最大值
        int maxValue = arr[0];
        for(int i = 1;i < arr.length;i++) {
            if(maxValue < arr[i]) {
                maxValue = arr[i];
            }
        }
        System.out.println("最大值" + maxValue);
        //求数组元素的最小值
        int minValue = arr[0];
        for(int i= 1;i <arr.length;i++) {
            if(minValue > arr[i]) {
                minValue = arr[i];
            }
        }
        System.out.println("最小值" + maxValue);
        //求数组元素的总和
        int sum = 0;
        for(int i = 0;i <arr.length;i++) {
            sum += arr[i];
        }
        System.out.println("总和为" +sum);
        //求数组元素的平均数
        int avgValue = sum / arr.length;
        System.out.println("平均数为：" +avgValue);
        
    }
}