四.一维数组及二维数组

一、数组

1.1 概念

• 数组是引用数据类型。
• 数组：数据的组合。
• 将多个数据存储到一起，每个数据称为该容器的元素。存储元素的容器，容器里存的是元素。
• 之前学习的变量，一个变量只能存一个数据，如果我们要存储多个数据，就需要一个容器，当下我们要掌握的第一个容器，数组。

1.2 数组的概述

• 数据类型 变量名 = 值;
• 数组可以是基本数据类型，也可以是引用数据类型。

1.3 数组的定义

package com.atguigu.e_array;
/*
* 1.定义语法
*   数据类型[] 数组名;  掌握
*   数据类型 数组名[];   了解
* 注意：数组和变量一样，必须要初始化才可使用
* */
public class ArrayDefineTest1 {
    public static void main(String[] args) {
        //变量：必须要初始化才能使用
        int a;
//        System.out.println("a = " + a);

        //数组
        int[] arr;
//        System.out.println("arr = " + arr);

    }
}

1.4 数组的初始化

package com.atguigu.e_array;
/*
* 数组的初始化：
*   1.动态初始化：在定义数组的同时，指定数组的长度（空间的大小）
*       数据类型[] 数组名 = new 数据类型[长度];  常用的
*       数据类型[] 数组名;
*       数组名 = new 数据类型[长度];
*   2.静态初始化：在定义数组的同时，赋值，值的个数就决定了数组的长度
*       数据类型[] 数组名 = {值1,值2,值3}; 值的个数决定数组的长度  常用的
*       数据类型[] 数组名 = new 数据类型[]{值1,值2,值3};
*
*   注意：
*       1.直接输出数组，输出的是数组在内存的地址值。
* */
public class ArraySetValueTest2 {
    public static void main(String[] args) {

        //定义一个int类型的数组叫arr，并在内存中开辟5块连续的空间
        int[] arr = new int[5];
        double[] scores = new double[100];
        byte[] bytes;
        bytes = new byte[5];

        System.out.println("--------");
        int[] arrs = {4,3,5,2,1};
        int[] arrs2 = new int[]{5,6,7,8,9};
        System.out.println(arrs);//直接输出数组，输出的地址值
    }
}

1.5 数组的赋值与访问

package com.atguigu.e_array;
/*
* 数组的赋值：
*   1.下标/索引：下标是从0开始的。
*       数组名[下标] = 值;
*       数组名[下标] 取值
*   2.获取数组的长度
*       数组名.length; 获取数组的长度
*       数组名[数组名.length-1]:获取的是数组的最后一个元素
		数组的下标是从0开始，到数组的长度-1   [0,数组.length-1]
* */
public class ArrayUseTest3 {
    public static void main(String[] args) {
        int[] arr = new int[5];
        System.out.println("arr = " + arr);//输出的是地址值。
        //数组的赋值
        arr[0] = 100;
        arr[1] = 200;
        arr[2] = 300;
        arr[3] = 400;
        arr[4] = 500;
        System.out.println("arr = " + arr[4]);
        System.out.println(arr.length);//获取数组的长度  空间的个数
        System.out.println(arr[arr.length - 1]);//获取数组长度-1的下标元素  数组的最后一个元素
    }
}

1.6 数组的默认值

package com.atguigu.e_array;
/*
* 8个基本、1个引用
* 整数：默认值是0
* 浮点数：默认值是0.0
* char类型：'\u0000' 0 空格  直接输出char类型数组，输出的不是地址值，而是所有的元素（值）
* 布尔型：默认值是false
* 引用数据类型的默认值全是null   空
*
* 注意：如果访问的下标<0 或 >数组.length-1 则会报：
*  ArrayIndexOutOfBoundsException 数组越界（用非法索引访问数组时抛出的异常）
* */
public class ArrayDefaultValueTest4 {
    public static void main(String[] args) {
        System.out.println("整数类型的数组默认值：");
        byte[] bytes = new byte[5];
        System.out.println("bytes = " + bytes);
        System.out.println(bytes[0]);
        short[] shorts = new short[5];
        int[] arr = new int[5];
        long[] longs = new long[5];
        System.out.println(shorts[0]);
        System.out.println(arr[0]);
        System.out.println(longs[0]);

        System.out.println("浮点数类型的数组默认值：");
        float[] floats = new float[3];
        double[] doubles = new double[3];
        System.out.println(floats[0]);
        System.out.println(doubles[2]);

        System.out.println("char类型的数组默认值：");
        char[] chars= new char[3];
        System.out.println(chars[1]);
        System.out.println(chars);//直接输出char类型数组，输出的不是地址值，而是所有的元素（值）

        System.out.println("布尔类型的数组默认值：");
        boolean[] booleans = new boolean[3];
        System.out.println(booleans[0]);

        System.out.println("String类型的数组默认值：");
        String[] strs = new String[3];
        System.out.println(strs[1]);

        System.out.println(strs[4]);
    }
}

1.7 数组的遍历

• 方式一：借助for循环，使用下标访问

• package com.atguigu.e_array;
  /*
  * 数组的遍历：
  *   指从第一个元素一直访问到最后一个元素。
  *        0      .length-1
  *   借助for循环。 i从0开始，循环条件是<数组.length
  *
  * */
  public class ArrayEachTest5 {
      public static void main(String[] args) {
          //静态初始化
          String[] girlFriends = {"迪丽热巴", "热依扎", "古力娜扎", "马尔扎哈", "哈妮克孜", "佟丽娅","萨勒芬妮"};
  
          for (int index = 0; index < girlFriends.length; index++) {
              System.out.println(girlFriends[index]);
          }
  
          System.out.println("===========");
          //对数组快捷生成遍历循环
          for (int i = 0; i < girlFriends.length; i++) {
              System.out.println(girlFriends[i]);
          }
  
      }
  }
  
  

• 方式二：增强for循环

• package com.atguigu.e_array;
  /*
  *增强for和fori的抉择：
  *   从头到尾依次遍历 增强for更好，无需关注下标，避免下标越界
  *   选择性遍历  fori更好
  *   倒序遍历，用fori更好
  * */
  public class ArrayForeachTest6 {
      public static void main(String[] args) {
          String[] strs = {"外星人","Rog","联想","华硕","苹果"};
          System.out.println("==== 增强for ====");
          //语法糖 ：程序员写着少，但是编译后，本质上还是fori
          for(String str: strs){
              System.out.println(str);
          }
  
  
          System.out.println("====== fori =====");
          for (int i = 0; i < strs.length; i++) {
              System.out.println(strs[i]);
          }
  
          System.out.println("==== 倒序遍历 ====");
          for(int i = strs.length-1; i>=0; i--){
              System.out.println(strs[i]);
          }
      }
  }
  
  

二、数组操作练习

2.1 求数组中的最大值

package com.atguigu.a_array;
/*
* 定义一个整数数组
* 遍历整个数组，获取最大值
* 没有下标的体现，增强for
* */
public class ArrayExerTest1 {
    public static void main(String[] args) {
        int[] arr = {13,14,99,77,66,43};

        //假象最大值：假象数组下标0就是最大的
        int maxNum = arr[0];

        //将每一个元素取出来，
        for (int i : arr) {
            //判断，当前取出的值
            if(maxNum < i){
                //最大值小于当前遍历的值。替换
                maxNum = i;
            }
        }

        System.out.println(maxNum);
    }
}

2.2 求数组最小值及下标

package com.atguigu.a_array;
/*
* 定义一个数组， 遍历，获取其最小值，及第一次出现的下标
* 定义一个数组
* 定义一个最小值的变量
* 定义一个记录最小元素下标的变量
* 只要有下标的体现，选择fori
* 如果求最后一个 加上=号
*
* */
public class ArrayExerTest2 {
    public static void main(String[] args) {
        //1.定义一个数组
        int[] arr = {10,30,-71,40,50,-71};

        //2.定义一个假象最小值的变量
        int minNum = arr[0];
        //3.定义一个假象最小值的下标
        int index = 0;

        //4.使用for遍历，操作下标
        for (int i = 1; i < arr.length; i++) {
            if(minNum > arr[i]){
                //替换最小值
                minNum = arr[i];
                //记录下标
                index = i;
            }
        }
        System.out.println("minNum = " + minNum+",下标为："+index);
    }
}

2.3 求数组中最大值及下标、最小值及下标、求和、平均值

package com.atguigu.a_array;

/*
 * 定义一个数组
 * 求数组中最大值、最大值的下标、最小值、最小值的下标、数组的总和、数组的平均值
 * */
public class ArrayExerTest3 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50, 9};

        //定义变量 最大值 最大值下标 最小值 最小值下标
        int maxNum = arr[0], maxIndex = 0, minNum = arr[0], minIndex = 0, sum = 0;

        for (int i = 0; i < arr.length; i++) {
            //当前最大值 小于 当前遍历的数组元素
            if (maxNum < arr[i]) {
                maxNum = arr[i];
                maxIndex = i;
            }
            //当前最小值 大于 当前遍历的数组元素
            if (minNum > arr[i]) {
                minNum = arr[i];
                minIndex = i;
            }
            //无论是最大还是最小，都不能影响累加求和
            sum+=arr[i];
        }
        System.out.println("最大值："+maxNum+",其下标为："+maxIndex);
        System.out.println("最小值："+minNum+",其下标为："+minIndex);
        System.out.println("总和为："+sum);
        System.out.println("平均值为："+ (double)sum / arr.length );
    }
}

2.4 综合练习

package com.atguigu.a_array;

import java.util.Scanner;

/*
* 从控制台输入学生的人数。
* 创建学生的成绩数组，数组的长度为学生的人数
* 统计学生的总分数，计算平均分。
* 从控制台输入多个学生的成绩。
* */
public class ArrayExerTest4 {
    public static void main(String[] args) {
        //1.创建控制台输入对象
        Scanner input = new Scanner(System.in);
        System.out.println("请输入学生的人数：");
        int num = input.nextInt();

        //2定义学生的成绩数组。 数组的长度为学生的人数
        double[] scores = new double[num];
        //累加求和的变量
        double sum = 0.0;

        //3.fori循环，循环输入学生的成绩，存储到数组里。
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请输入第"+(i + 1)+"名学生的成绩：");
            double score = input.nextDouble();
            //判断成绩是否合理
            if(score<0){
                System.out.println("输出的成绩有误，必须是大于0的成绩");
                //为了下一次的循环，还是本次循环的i的值
                i--;
                continue;//跳出本次不合理的循环，进入下一次重新输入
            }
            scores[i] = score;
            //将数组中的元素取出来累加求和
            sum +=scores[i];
        }

        //4.输出数组的平均分
        System.out.println("平均分为："+sum / scores.length);
    }
}

2.5 综合练习优化迭代部分

package com.atguigu.a_array;

import java.util.Arrays;
import java.util.Scanner;

public class ArrayExerTest5 {
    public static void main(String[] args) {
            //1.创建控制台输入对象
            Scanner input = new Scanner(System.in);
            System.out.println("请输入学生的人数：");
            int num = input.nextInt();
            //2定义学生的成绩数组。 数组的长度为学生的人数
            double[] scores = new double[num];
            //累加求和的变量
            double sum = 0.0;

            //3.fori循环，循环输入学生的成绩，存储到数组里。
            for (int i = 0; i < scores.length; ) {
                System.out.println("请输入第"+(i + 1)+"名学生的成绩：");
                double score = input.nextDouble();
                //判断成绩是否合理
                if(score<0){
                    System.out.println("输出的成绩有误，必须是大于0的成绩");
                    continue;//跳出本次不合理的循环，进入下一次重新输入
                }
                scores[i] = score;
                //将数组中的元素取出来累加求和
                sum +=scores[i];
                i++;//其实还是迭代部分，只不过控制了一下正确执行完毕，才进行i++迭代操作
            }

            //4.输出数组的平均分
            System.out.println("平均分为："+sum / scores.length);
    }
}

三、JVM内存划分

• JVM内存，其实运行时数据区

• 空间划分：

  • 方法区（元空间）：存储的类的信息 包名、类名。。。 静态信息 常量信息
  • 虚拟机栈（栈空间）：方法运行时产生的局部变量信息。每当有一个方法执行时，在栈中为方法开辟一块空间，栈帧。
  • 堆：对象、数组
  • 程序计数器（寄存器）：存储下一步要执行代码的指令、地址。用于存储当前代码执行时，保存的是分支、流程跳转的下一步的指令。
  • 本地方法栈：Java不是万能的。 有些功能是靠C/C++来实现的 其他语言在执行代码时，所占的空间在这里。

四、数组常见算法

4.1 数组的反转

package com.atguigu.c_operator;

import java.util.Arrays;
/*
* Arrays.toString(数组名); 可以快速展示数组中的元素，以String的格式
* 1.首尾互换
*   找到中间下标。 互换的中间下标的左右两侧
*   左侧下标从0开始，右侧下标是从数组的长度-1 - 左侧的下标值
* 2.定义左侧的下标值  右侧的下标值
*         l :0        r:数组的长度-1
*          l++         r--
* */
public class ArrayReverseTest1 {
    public static void main(String[] args) {
        int[] arr = {10,20,30,40,50,60,70};
        //70 60 50 40 30 20 10
        //1.如果想快速看数组中的元素   从头到尾
        System.out.println("反转前 = " + Arrays.toString(arr));

        for(int i = 0;i< arr.length / 2;i++){
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 -i] = temp;
        }

        System.out.println("反转后 = "+Arrays.toString(arr));
    }
}
class ArrayReverseTest2{
    public static void main(String[] args) {
        int[] arr = {10,20,30,40,50,60,70};
        //70 60 50 40 30 20 10
        //1.如果想快速看数组中的元素   从头到尾
        System.out.println("反转前 = " + Arrays.toString(arr));

        for(int l = 0,r = arr.length-1;l < r;l++,r--){
            int temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
        }

        System.out.println("反转后 = "+Arrays.toString(arr));
    }
}

4.2 数组的扩容与缩容

package com.atguigu.c_operator;

import java.util.Arrays;

/*
* 数组的长度问题：
*  数组在定义后，无论是静态、动态初始化，长度一旦固定，则不可更改。
*
* 数组的扩容：原数组，空间不足，扩容一个新的数组，存储数据
*   1.创建一个新数组
*   2.将旧数组中的元素原位复制到新数组中
*   3.将新数组地址赋值给旧的数组
*
* 数组的缩容：
*   已经存储元素的数组，最后一个下标之前的元素被删除。那么后续的元素要往前移动
* */
public class ArrayCapacityTest2 {
    public static void main(String[] args) {
        //           0 1 2 3 4
        int[] arr = {4,3,5,2,1};

        //1.创建新数组
        int[] newArr = new int[arr.length << 1];//arr.length * 2

        //2.将旧数组的值复制到新数组中
        for (int i = 0; i < arr.length; i++) {
            newArr[i] = arr[i];//复制的是值
        }

        //3.将新数组的地址赋值给旧数组
        arr = newArr;

        arr[5] = 100;
        //4.展示
        System.out.println(Arrays.toString(arr));

    }
}
class ArrayCapacityTest3{
    public static void main(String[] args) {
        //todo 删除指定下标的元素
        //           0 1 2 3 4
        int[] arr = {4,3,5,2,1};
        //删除下标2的元素，赋值为0
        //要将删除元素下标后的元素往前移动
        arr[2] = 0;//删除下标2的元素
        //循环起始从被删除元素的下标开始
        for(int i = 2;i<arr.length - 1;i++){
            arr[i] = arr[i+1];
        }
        //将最后一位元素赋值为0.可以存储其他新的值
        arr[arr.length-1] = 0;

        System.out.println("缩容后= "+Arrays.toString(arr));
    }
}

4.3 顺序查找

package com.atguigu.c_operator;

import java.util.Scanner;

/*
* 定义一个数组  int[] arr = {4,3,5,2,1};
* 请输入一个数：
*           5
*   有5这个元素，下标是2   第一次出现的下标
*
* 请输入一个输：
*       100
*       未查到元素100
*
* */
public class ArrayFindTest3 {
    public static void main(String[] args) {
        int[] arr = {4,3,5,2,1};

        Scanner input = new Scanner(System.in);
        System.out.println("请输入要查找的数字：");
        int num = input.nextInt();

        //todo 假设查找的元素所在的下标
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if(num == arr[i]){
                index = i;//将找到的元素所在的下标记录下来
                break;
            }
        }
        //对下标变量做判断
        if(index == -1){
            System.out.println("未找到元素"+num);
        }else{
            System.out.println("有"+num+"这个元素,下标为："+index);
        }

    }
}

4.4 数组的排序

package com.atguigu.d_sort;

import java.lang.reflect.Array;
import java.util.Arrays;

/*
* 冒泡排序：相邻的两个元素比较大小，交换位置
* 0 - 1 -2
* 1、从下标0开始， 只要前一个元素 > 后一个元素，就交换位置
* 2、每次排序，都是将本次比较最大的放到最后面
* 3、一个有n个元素的数组，比较的轮数是 n -1轮
* 4、比较的次数会随着轮数的增长而减少
* */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {4,3,5,2,1};
        //外层循环控制的是轮数
        for(int i = 0;i<arr.length - 1;i++){
            //内层循环控制的是次数 次数随着轮数的增长递减
            for(int j = 0;j<arr.length - 1 - i;j++){
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        System.out.println(Arrays.toString(arr));
    }
}
/*
//第一轮  比的是最大的
        for(int i = 0;i<arr.length - 1;i++){
            if(arr[i] > arr[i + 1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }

        //第二轮 比的是第二大的

* for(int i = 0;i<arr.length - 1 - 1;i++){
            if(arr[i] > arr[i + 1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }

        //第三轮 比的是第三大的
        for(int i = 0;i<arr.length - 1 - 1 - 1;i++){
            if(arr[i] > arr[i + 1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }

        //第四轮
        for(int i = 0;i<arr.length - 1 - 1 - 1 - 1;i++){
            if(arr[i] > arr[i + 1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
*
*
*
*
* */

五、二维数组

5.1 概述

• 一维数组存储的是元素。
• 二维数组存储的是一维数组。 将数组作为值存储给另一个数组。

5.2 定义

package com.atguigu.a_two;
/*
* 定义方式：
* 数据类型[][] 数组名;  常用
* 数据类型[] 数组名[]; 不推荐
* 数据类型 数组名[][]; 不推荐
* */
public class TwoArrayTest1 {
    public static void main(String[] args) {

        String name = "猴精";

        String[] arr = {"蜘蛛精","白骨精","黑熊精","耗子精",name};

        String[] arr2 = {"孙悟空","猪八戒","唐僧","猫精"};

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

        //定义二维数组
        String[][] arr3 = {arr,arr2};
        System.out.println("arr3 = " + arr3);

    }
}

5.3 初始化

• 静态初始化：

  • package com.atguigu.a_two;
    
    /*
     * 静态初始化：编译时就确定了数组长度、元素
     *  数据类型[][] 数组名 = {{值1,值2,值3},{值n},{}}; 声明和赋值必须在一行
     *   数据类型[][] 数组名 = new 数组类型[][]{{},{},{}};声明和赋值可以换行
     * 动态初始化：
     * */
    public class TwoArrayInitTest2 {
        public static void main(String[] args) {
            int[] nums = {4, 3, 5, 2, 1};
            //               0           1         2
            int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8}};
    
            //二维数组名.length，获取的是二维数组的长度
            System.out.println("arr.length = " + arr.length);
    
            //数组名[0];  二维数组当中的第一个一维数组的空间
            System.out.println("arr[0] = " + arr[0]);//[I@6d03e736
    
            //数组名[0][1];  二维数组中第一个一维数组中的第二个元素
            System.out.println("arr[0][1] = " + arr[0][1]);
    
            String[][] strArr;
            strArr = new String[][]{{"安琪拉","米莱迪","王昭君"},{"夏侯惇","吕布"},{"鲁班"}};
    
            System.out.println("strArr.length = " + strArr.length);
            System.out.println("strArr[1].length = " + strArr[1].length);
            System.out.println("strArr[2][0] = " + strArr[2][0]);
            
        }
    }
    
    

• 动态初始化

  • package com.atguigu.a_two;
    /*
    *
    * 动态初始化：编译时就指定了数组的长度、默认值
    *   数据类型[][] 数组名 = new 数据类型[数值1][数值2];
    *       数值1 是二维数组的行。 代表一维数组的数量
    *       数值2 是一维数组的列  代表一维数组的元素个数
    *   数据类型[][] 数组名 = new 数据类型[数值1][];
    * */
    public class TwoArrayInitTest3 {
        public static void main(String[] args) {
    //        int[] arr = new int[3];
            //todo 数据类型[][] 数组名 = new 数据类型[数值1][数值2];
            //第一个[]代表的是行  第二个[]代表的是列
            int[][] arr = new int[3][5];
            System.out.println("arr。 = " + arr.length);
            System.out.println("arr[0].length = " + arr[0].length);
            System.out.println("arr[0].length = " + arr[1].length);
            System.out.println("arr[0].length = " + arr[2].length);
    
            //todo 数据类型[][] 数组名 = new 数据类型[数值1][];
            //只动态分配了行。 列可以换行后单独指定
            int[][] arr2 = new int[3][];
            arr2[0] = new int[16];//为二维中的每个下标单独分配一维的长度
            arr2[1] = new int[3];
            //静态初始化赋值，必须用下述语法，不能换行。
            arr2[2] = new int[]{6,6,6,6,6};
    
    
        }
    }
    
    

5.4 二维数组的遍历

• fori遍历

  • /*
     * fori遍历
     * 增强for遍历
     *       for(数组的类型 数组名:数组名){
     *       }
     * */
    public class TwoArrayForTest4 {
        public static void main(String[] args) {
            //                          0                       1                   2
            String[][] names = {{"安琪拉", "米莱迪", "王昭君"}, {"吕布", "程咬金"}, {"赵云", "刘备", "李白", "韩信"}};
            //外层循环控制的是二维数组的行
            for (int i = 0; i < names.length; i++) {
                //内层循环控制的是一维数组的列
                for (int j = 0; j < names[i].length; j++) {
                    //i是二维的下标  j是一维的下标
                    System.out.print(names[i][j] + "\t");
                }
                System.out.println();
            }
            /*//todo 遍历二维数组中的第一个一维数组
            for(int i =0;i<names[0].length;i++){
                System.out.print(names[0][i]+"\t");
            }
            System.out.println();
    
            //todo 遍历二维数组中的第二个一维数组
            for(int i =0;i<names[1].length;i++){
                System.out.print(names[1][i]+"\t");
            }
            System.out.println();
            //todo 遍历二维数组中的第三个一维数组
            for(int i =0;i<names[2].length;i++){
                System.out.print(names[2][i]+"\t");
            }
            System.out.println();*/
        }
    }
    

• 增强for遍历

  • class TwoArrayForPlusTest5 {
        public static void main(String[] args) {
            //                          0                       1                   2
            String[][] names = {{"安琪拉", "米莱迪", "王昭君"}, {"吕布", "程咬金"}, {"赵云", "刘备", "李白", "韩信"}};
            //外层增强for每次遍历拿到的是一个一个的一维数组
            for (String[] name : names) {
                //内层增强for每次遍历拿到的是一个一个的元素
                for (String n : name) {
                    System.out.print(n+"\t");
                }
                System.out.println();
            }
        }
    }
    

5.5 二维数组的小练习

• 求二维数组中最大值和最小值

  • package com.atguigu.a_two;
    /*
    * 定义一个整数二维数组，将整个二维数组中最大值和最小值取出来
    * */
    public class TwoArrayExerTest6 {
        public static void main(String[] args) {
            int[][] arrs = {{10,57,18},{33,12,99},{-9,82,-736,115}};
            //1.先定义假想最大值
            int maxNum = arrs[0][0];
            int minNum = arrs[0][0];
            //遍历的是二维数组   拿到的是一维
            for (int[] arr : arrs) {
                //遍历的是一维数组  拿到是元素  值
                for (int i : arr) {
                    if(maxNum < i){
                        maxNum = i;
                    }
    
                    if(minNum > i){
                        minNum = i;
                    }
                }
            }
    
            System.out.println(maxNum);
            System.out.println(minNum);
    
        }
    }
    

• 杨辉三角（了解）

  • package com.atguigu.a_two;
    /*
    *  了解：
    * 杨辉三角：练习二维数组的动态初始化  因为是个不规则数组。  每行的列数是不一样的
    *        练习 每行的每列的值  由上一行的列计算而来。  嵌套循环  外层和内层的关系
    * */
    public class YhTest8 {
        public static void main(String[] args) {
            //1.需要创建一个二维数组
            int[][] yh = new int[10][];
    
            //2.动态的分配一维数组的列数
            for (int h = 0; h < yh.length; h++) {
                //列数随着行数的增长而增长
                yh[h] = new int[h + 1];
    
                //每行的第一列都是1
                yh[h][0] = 1;
                //每行的最后一列都是1
                yh[h][h] = 1;
            }
    
            //从第三行的第二列开始，每一列的值 = 上一列的同下标 + 前一个下标的值
            //外层循环控制的是行数， 从第三行开始计算
            for (int h = 2; h < yh.length; h++) {
                //内存循环控制的是列数。 从第二列开始。 到最后一列-1的下标
                for (int l = 1; l < yh[h].length - 1; l++) {
                    //当前行的第二列 = 上一行的同列  + 上一行的前一列
                    yh[h][l] = yh[h - 1][l] + yh[h - 1][l - 1];
                }
            }
    
    
            //最终步骤：打印显示
            for (int i = 0; i < yh.length; i++) {
                for (int j = 0; j < yh[i].length; j++) {
                    System.out.print(yh[i][j] + "\t");
                }
                System.out.println();
            }
        }
    }
    
    

5.6 二维数组的内存图和案例

package com.atguigu.a_two;

public class TwoArrayMemoryTest7 {
    public static void main(String[] args) {
        //在栈中开辟一个空间叫arr。
        //在堆中开辟一个空间存储的是数组元素.
        //将堆中数组的地址，赋值给栈中的arr
        int[] arr = {4,3,5,2,1};

        int[][] arr2 = new int[3][];
        arr2[0] = new int[3];
        System.out.println("arr2[0][0] = " + arr2[0][0]);
        System.out.println("arr2[1] = " + arr2[1]);//二维数组中的一维数组没分配空间时，是null


        arr2[1] = new int[2];

        arr2[2] = arr;

    }
}

package com.atguigu.a_two;

public class TwoArrayMemoryTest7 {
    public static void main(String[] args) {
        //在栈中开辟一个空间叫arr。
        //在堆中开辟一个空间存储的是数组元素.
        //将堆中数组的地址，赋值给栈中的arr
        int[] arr = {4,3,5,2,1};

        int[][] arr2 = new int[3][];
        arr2[0] = new int[3];
        System.out.println("arr2[0][0] = " + arr2[0][0]);
        System.out.println("arr2[1] = " + arr2[1]);//二维数组中的一维数组没分配空间时，是null


        arr2[1] = new int[2];

        arr2[2] = arr;

    }
}

package com.atguigu.a_two;

public class TwoArrayMemoryTest7 {
    public static void main(String[] args) {
        //在栈中开辟一个空间叫arr。
        //在堆中开辟一个空间存储的是数组元素.
        //将堆中数组的地址，赋值给栈中的arr
        int[] arr = {4,3,5,2,1};

        int[][] arr2 = new int[3][];
        arr2[0] = new int[3];
        System.out.println("arr2[0][0] = " + arr2[0][0]);
        System.out.println("arr2[1] = " + arr2[1]);//二维数组中的一维数组没分配空间时，是null


        arr2[1] = new int[2];

        arr2[2] = arr;

    }
}

package com.atguigu.a_two;

public class TwoArrayMemoryTest7 {
    public static void main(String[] args) {
        //在栈中开辟一个空间叫arr。
        //在堆中开辟一个空间存储的是数组元素.
        //将堆中数组的地址，赋值给栈中的arr
        int[] arr = {4,3,5,2,1};

        int[][] arr2 = new int[3][];
        arr2[0] = new int[3];
        System.out.println("arr2[0][0] = " + arr2[0][0]);
        System.out.println("arr2[1] = " + arr2[1]);//二维数组中的一维数组没分配空间时，是null


        arr2[1] = new int[2];

        arr2[2] = arr;

    }
}