Java一维数组、二维数组

一、 一维数组

数组的特点: 存储多个数据

1. 只能存储同一种数据类型的数据
2. 数组一旦创建,长度固定,不可变化
3. 数组中可以存储重复元素

1.1 图解

1. 方法进栈
2. 数组再堆中创建
3. 创建出的数组是连续空间,分配内存地址,分配下标,下标从0开始,连续空间内有初始值
   

1.2 静态创建

 public static void main(String[] args) {
        /** 动态创建:
         *      创建时只指定长度,后续运行时再赋值
         *      数据类型[] 数组名 = new 数据类型[长度];
         *  静态创建:
         *      在创建数组的同时直接指定数组元素,长度由系统自己计算
         *      数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
         *  静态创建简化:
         *      数据类型[] 数组名 = {元素1,元素2,...};
         *
         *
         */
        // 存储张三,李四,王五的姓名
        String[] nameArr = new String[]{"张三","李四","王五"};
        // 取值
        System.out.println(nameArr[0] );
        System.out.println(nameArr[1] );
        System.out.println(nameArr[2] );

        // 赋值 : 会将之前的值覆盖
        nameArr[0] = "张三丰";
        nameArr[1] = "李思思";
        nameArr[2] = "王莽";

        System.out.println(nameArr[0] );
        System.out.println(nameArr[1] );
        System.out.println(nameArr[2] );

        char[] charArr = {'a','b','c','d'};
        for (int i = 0; i < charArr.length; i++) {
            System.out.println(charArr[i] );
        }

    }

1.3 动态创建

  public static void main(String[] args) {
        /** Array : 数组是引用数据类型
         * 数组声明:
         *      数据类型[] 数组名;
         * 数组创建:
         *      数组名 = new 数据类型[长度];
         * 数组取值
         *      数据类型 变量 = 数组名[下标];
         * 数组赋值
         *      数组名[下标] = 值;
         *
         */
//        int[] arr;
//        arr = new int[3];
        /**
         * 创建数组,分配下标,下标从0开始,
         * 最大长度-1
         * 且有默认初始值
         */
        int[] arr = new int[3];

        // 取值
        int a = arr[0];
        System.out.println("[0] = " + a );

        // 赋值
        arr[0] = 18;

        // 再次取值
        int a2 = arr[0];
        System.out.println("[0] = " + a2 );

        /**
         * 创建数组,存储5名同学的成绩
         * 99.8 59.9 60.0 100.0 87.5
         * 后.分别输出他们的成绩
         */
        double[] scoreArr = new double[6];
        // 赋值 - 下标不要超过长度-1,否则抛出异常
        // 数组下标越界
        scoreArr[0] = 19.8;
        scoreArr[1] = 29.9;
        scoreArr[2] = 39.9;
        scoreArr[3] = 49.9;
        scoreArr[4] = 59.9;
        scoreArr[5] = 69.9;
//        scoreArr[5] = 89.9;

        // 取值
        double v1 = scoreArr[0];
        double v2 = scoreArr[1];
        double v3 = scoreArr[2];
        double v4 = scoreArr[3];
        double v5 = scoreArr[4];

        System.out.println(v1 );
        System.out.println(v2 );
        System.out.println(v3 );
        System.out.println(v4 );
        System.out.println(v5 );

        // 数组的长度属性
        int length = scoreArr.length;

        /**
         * 数组的遍历: 将元素一个一个的取出
         */
        for (int i = 0;i < length;i++) {
            System.out.println(scoreArr[i] );
        }
    }

练习

1. 找出数组的最大值

 int[] arr = new int[5];
        arr[0] = 30;
        arr[1] = 4;
        arr[2] = 2;
        arr[3] = 50;
        arr[4] = 1;

        int max = arr[0];
        for(int i = 1;i < arr.length;i++) {
            if(arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println("max = "+max );

2. 数组求和

 int sum = 0;
        for(int i = 1;i < arr.length;i++) {
            sum += arr[i];
        }
        System.out.println("和 = "+sum );

冒泡排序

int[] arr = { 5, 4, 3, 2, 1 };
        for (int j = 0; j < arr.length - 1; j++) {
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i + 1];
                    arr[i + 1] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));

Arrays 工具类

1. 构造方法被私有,不能创建对象
2. 其中的所以方法都是静态的
3. 方法调用: Arrays.方法名();
4. String str = Arrays.toString(一维数组);
   
   将数组中的元素以字符串的形式返回
5. Arrays.sort(一维数组); 将数组按照从小到大的顺序排序

int[] arr1 = {4,2,1,3};
String r1 = Arrays.toString(arr1);
System.out.println("排序前: "+r1 );

// 排序
Arrays.sort(arr1);

System.out.println("排序后: "+Arrays.toString(arr1) );

二、 二维数组

1. 二维数组是：元素是一维数组的数组是二维数组。
2. 二维数组的每个元素是一维数组。

2.1 图解

2.2 动态创建-取值-赋值-遍历

 public static void main(String[] args) {
        /**
         * 二维数组: 数组的元素是一维数组.
         * 声明:
         *      数据类型[][] 数组名 ;
         * 动态创建:
         *      给定长度,不指定元素.
         *      数组名 = = new 数据类型[二维数组的长度][一维数组的长度];
         * 取值:
         *      数据类型 变量 = 二维数组名[二维数组下标][一维数组下标];
         * 赋值:(给二维数组中的一维数组的元素赋值)
         *      二维数组名[二维数组下标][一维数组下标] = 值;
         * ---------------
         * 扩展:
         *     只是给二维数组赋值:
         *      二维数组名[二维数组的下标] = 一维数组;
         */
        /**
         * 创建了一个长度为3的二维数组,
         * 其中每个一维数组的长度是2
         */
        int[][] arr = new int[3][2];

        // 取出二维数组的第一个元素
        System.out.println(arr[0] );
        System.out.println(arr[1] );
        System.out.println(arr[2] );

        // 取值

        // 取出二维数组中第一个一维数组中第一个元素
        System.out.println(arr[0][0] );
        // 取出二维数组中第一个一维数组中第二个元素
        System.out.println(arr[0][1] );
        // 取出二维数组中第二个一维数组中第一个元素
        System.out.println(arr[1][0] );
        // 取出二维数组中第二个一维数组中第二个元素
        System.out.println(arr[1][1] );
        // 取出二维数组中第三个一维数组中第一个元素
        System.out.println(arr[2][0] );
        // 取出二维数组中第三个一维数组中第二个元素
        System.out.println(arr[2][1] );

        /**
         * 某学校,现有
         * java班   张三 李四
         * 前端班   王五 赵六
         * UI班    周七  茅十八
         * 使用二维数组,存储上述数据
         */
        // 3个班,每班2个人
        String[][] stuInfo = new String[3][2];
        // java班2人
        stuInfo[0][0] = "张三";
        stuInfo[0][1] = "李四";
        // 前端班2人
        stuInfo[1][0] = "王五";
        stuInfo[1][1] = "赵六";
        // UI班
        stuInfo[2][0] = "周七";
        stuInfo[2][1] = "茅十八";


        /**
         * 二维数组遍历
         */
        // 外层循环得到每一个一维数组
        for (int i = 0; i < stuInfo.length; i++) {
            // 内层循环得到一维数组的每一个元素
            for (int j = 0; j < stuInfo[i].length; j++) {
                System.out.println(stuInfo[i][j] );
            }
        }

        /**
         * 只是给二维数组赋值:
         *      二维数组名[二维数组的下标] = 一维数组;
         */
        stuInfo[0] = new String[]{"张三丰","李思思"};
        for (int i = 0; i < stuInfo.length; i++) {
            // 内层循环得到一维数组的每一个元素
            for (int j = 0; j < stuInfo[i].length; j++) {
                System.out.println(stuInfo[i][j] );
            }
        }
    }

2.3 静态赋值

/**
 * 静态创建
 *      直接给定元素,长度有系统判定
 *      数据类型[][] 数组名 = 数据类型[][]{
 *          {值1,值2,..},
 *          {值1,值2},
 *          ..
 *      };
 *  ---------
 *  一样可以简化写
 *
 */
int[][] arr2 = new int[][]{
        {1,2},
        {3,4,5},
        {6,7,8,9}
};
int[][] arr23 = {
        {1,2},
        {3,4,5},
        {6,7,8,9}
};
for (int i = 0; i < arr23.length; i++) {
    // 内层循环得到一维数组的每一个元素
    for (int j = 0; j < arr23[i].length; j++) {
        System.out.print(arr23[i][j]+" ");
    }
    System.out.println( );
}