模块五 数组

最新推荐文章于 2024-06-19 22:36:17 发布
最新推荐文章于 2024-06-19 22:36:17 发布
阅读量856 收藏 21
点赞数 21
文章标签： 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45758221/article/details/136779287
版权

回顾与重点

模块四回顾

  1. Scanner：键盘录入

    a.导包：import java.util.Scanner

    b.创建对象: Scanner 变量名 = new Scanner(System.in)

    c.调用方法，实现键盘录入

    ​ 变量名.nextInt() 录入一个整数

    ​ 变量名.next() 录入字符串，遇到空格或者回车就结束录入

    ​ 变量名.nextLine() 录入字符串，遇到回车就结束录入

  2. Random：生成随机数

    a.概述：java定义好的类

    b.作用：在指定的范围内随机一个整数

    c.使用：

    ​ 导包：import java.util.Random

    ​ 创建对象：Random变量名 = new Random()

    ​ 调用方法：

    ​ 变量名.nextInt() 在int范围内随机一个整数

    ​ 变量名.nextInt(int bound) → 在0—(bound-1)之间随机

  3. switch：

    a.格式：

    switch(变量) {
  case 常量值1:
    执行语句1;
    break;
  case 常量值2:
    执行语句2;
    break;
  case 常量值3:
    执行语句2;
    break;
  ...
  default:
    执行语句n;
    break;
}

    b. 执行流程：用变量代表的值去精准匹配，匹配上哪个case就走哪个case对应的执行语句，如果都匹配不上，就走default对应的执行语句n

    c.没有break，会出现case的穿透性，一直穿透，直到遇到break或者switch代码结束为止

  4. if:

    a.格式：

    if(boolean表达式) {
  执行语句
}

    b.执行流程：先走if后面的boolean表达式，如果是true，就走if后面的执行语句，否则就不走

  5. if…else:

    a.格式：

    if(boolean表达式) {
  执行语句1
} else {
  执行语句2
}

    b.执行流程：先走if后面的boolean表达式，如果是true，就走if后面的执行语句1，否者就走else后面的执行语句2

  6. else…if:

    a.格式：

    if(boolean表达式) {
  执行语句1
} else if(boolean表达式) {
  执行语句2
} else if(boolean表达式) {
  执行语句3
}
...
else {
  执行语句n
}

    b.执行流程：从上往下挨个判断，哪个条件为true，就走哪个if对应的执行语句，以上所有的判断都不成立，就走else对应的执行语句n。

  7. for循环：

    a.格式：

    for(初始化变量;比较;步进表达式){
  循环语句
}

    b.执行流程：先初始化变量，比较，如果是true，就走循环语句，再走步进表达式；继续比较，如果还是true，继续走循环，再走步进表达式；再比较，直到比较为false，循环结束。

  8. while循环：

    a.格式：

    初始化变量;
while(比较) {
  循环语句;
  步进表达式;
}

    b.执行流程：先初始化变量，比较，如果是true，就走循环语句，再走步进表达式；继续比较，如果还是true，继续循环，再走步进表达式；再比较，直到比较为false，循环结束。

  9. do…while循环：

    a.格式：

    初始化变量;
do {
  循环语句;
  步进表达式;
} while(比较)

    b.执行流程：初始化变量；循环语句;步进表达式；比较，如果是true，继续走步进表达式，直到比较为false，循环结束。

    c.特点：至少循环一次。

  10. 循环控制语句：

    a. break：结束循环

    b. continue：结束本次循环，进入下一次循环

  11. 死循环：比较永远是true

  12. 嵌套循环：

    先走外层循环，再走内层循环，内层循环就一直循环，直到内层循环结束，外层循环进入下一次循环，直到连外层循环都结束了，整体结束。

模块五重点

  1. 数组的特点以及定义
  2. 数组的操作（存数据，取数据，遍历数据）
  3. 二维数组（定义，存，取，遍历）
  4. 知道内存中的：堆，栈

第一章 数组的概述及定义

1.1 数组的概述

  1. 问题：如果我们想存储一个数据，我们可以使用变量，但是变量一次只能存储一个数据，所以我们想能不能一次存储多个数据

  2. 数组的概述：是一个容器，数组本身属于引用数据类型

  3. 作用：一次存储多个数据

  4. 特点：

    a. 既可以存储基本类型的数据，还能存储引用类型的数据；

    b.定长（定义数组时，长度为多长，最多能存多少个数据），同时也是缺点。

1.2 数组的定义

  1. 定义：

    a. 动态初始化：定义数组的时候，我们没有给具体的数据，只指定了长度

    数据类型[] 数组名 = new 数据类型[长度]
或者
数据类型 数组名[] = new 数据类型[长度]

    各部分解释：

    等号左边的数据类型：规定了数组中只能存储什么类型的数据

    []：代表的是数组，一个 [] 代表一维数组，两个[] [] 代表二维数组

    数组名：自己取的名字，遵循小驼峰式

    new：代表的是创建数组

    等号右边的数据类型：要和等号左边的数据类型一致

    [长度]：指定数组长度，规定了数组中最多能存多少个数据

    public class Demo01Array {
    public static void main(String[] args) {
        // 动态初始化
        int [] arr1 = new int[3];

        String[] arr2 = new String[3];
    }
}

    b.静态初始化：在定义数组的时候，我们直接给了数据

    数据类型[] 数组名 = new 数据类型[]{元素1, 元素2，...} → 不推荐使用
或者
数据类型 数组名[] = new 数据类型[]{元素1, 元素2，...} → 不推荐使用

    c.简化的静态初始化：

    数据类型[] 数组名 = {元素1, 元素2，...} → 推荐使用

    public class Demo01Array {
    public static void main(String[] args) {
        // 动态初始化
        int [] arr1 = new int[3];

        String[] arr2 = new String[3];

        // 静态初始化 → 简化
        int[] arr3 = {1,2,3,4};
        String[] arr4 = {"东方不败", "林平之", "岳不群"};

        // 静态初始化 → 非简化
        int[] arr5 = new int[] {1,2,3,4};
        String[] arr6 = new String[] {"东方不败", "林平之", "岳不群"};
    }
}

  2. 动态初始化和静态初始化的区别：

    a.动态初始化：定义的时候只能指定长度，没有存具体的数据；当只知道长度，但不知道具体存啥数据的时候，可以使用动态初始化；

    b.静态初始化：定义的时候就直接知道存什么数据

第二章 数组操作

2.1 获取数组长度

  1. 格式：

    数组名.length

  2. 注意：length后面不要带小括号，因为length不是数组中的一个方法，而是数组中的一个属性

    public class Demo02Array {
    public static void main(String[] args) {
        String[] arr1 =  {"迪迦奥特曼", "猫和老鼠", "花园宝宝", "海绵宝宝", "圣斗士", "百变小樱魔术卡"};
        int length = arr1.length;
        System.out.println("length = " + length);// length = 6
    }
}

2.2 索引的介绍

  1. 概述：元素在数组中存储的位置（编号，下标）

    image-20240314014703999

  2. 特点：

    a. 索引唯一

    b. 索引都是从 0 开始的，最大索引都是数组长度 - 1.

  3. 索引的作用：

    我们将来操作元素，必须通过索引来操作（存数组、取数据、查数组等都要指定索引）。

2.3 存储元素

  1. 格式：

    数组名[索引值] = 值 → 将等号右边的数据放到数组指定的索引位置上

    public class Demo03Array {
    public static void main(String[] args) {
        // 定义一个数组
        int[] arr = new int[3];
        arr[0] = 100; //  将100存到了arr这个数组的0索引上
        arr[1] = 200; //  将200存到了arr这个数组的1索引上
        arr[2] = 300; //  将300存到了arr这个数组的2索引上
        // arr[3] = 400; //  上面的数组长度为3，最大索引为2，没有3索引，所以不能操作不存在的索引
        System.out.println("=======================");

        String[] arr2 = new String[3];
        arr2[0] = "张三";
        arr2[1] = "李四";
        arr2[2] = "王五";
        System.out.println("=======================");
    }
}

    public class Demo04Array {
    public static void main(String[] args) {
        // 定义数组，长度为3
        int[] arr = new int[3];
        // 创建 Scanner 对象
        Scanner sc = new Scanner(System.in);
        // 键盘录入，将数据存到数组中
        /*arr[0] = sc.nextInt();
        arr[1] = sc.nextInt();
        arr[2] = sc.nextInt();*/
        // 使用循环录入，数组长度是多少，我们就循环多少次
        for (int i = 0; i < arr.length; i++) {
            arr[i] = sc.nextInt();
        }
    }
}

    public class Demo05Array {
    public static void main(String[] args) {
        // 定义数组，长度为3
        int[] arr = new int[3];
        // 创建 Random 对象
        Random rd = new Random();

        // 键盘录入，将数据存到数组中
        /*arr[0] = rd.nextInt(10);
        arr[1] = rd.nextInt(10);
        arr[2] = rd.nextInt(10);*/
        // 使用循环录入，数组长度是多少，我们就循环多少次
        for (int i = 0; i < arr.length; i++) {
            arr[i] = rd.nextInt(10);
        }
    }
}

2.4 获取元素

  1. 格式：

    数组名[索引值]

  2. 细节说明：

    a. 直接输出数组名，会输出数组在内存中的地址值；

    b. 地址值：数组在内存中的一个身份证号，唯一标识，我们可以通过这个唯一标识到内存中找到这个数组，从而操作这个数组中的数据；

    c. 如果数组中没有存数据，那么直接获取也能获取出来一些数据（元素的默认值）；

    ​ 整数：0

    ​ 小数：0.0

    ​ 字符：‘\u0000’ → 对应的int值是0

    ​ 布尔：false

    ​ 引用：null

    public class Demo06Array {
    public static void main(String[] args) {
        // 定义数组，长度为3
        int[] arr = new int[3];
        System.out.println(arr);  // [I@4eec7777
        System.out.println(arr[0]); // 0
        System.out.println(arr[1]); // 0
        System.out.println(arr[2]); // 0
    }
}

    image-20240314022013318

2.5 遍历元素

1.遍历：将元素从数组中一个一个的获取出来。

public class Demo07Array {
    public static void main(String[] args) {
        // 定义数组，长度为3
        int[] arr = new int[3];
        System.out.println(arr); // 地址值
        System.out.println(arr[0]); // 默认值0
        System.out.println(arr[1]); // 默认值0
        System.out.println(arr[2]); // 默认值0

        // 存数据
        arr[0] = 100;
        arr[1] = 200;
        arr[2] = 300;

        System.out.println(arr[0]); // 100
        System.out.println(arr[1]); // 200
        System.out.println(arr[2]); // 300

        System.out.println("=====================");
        String[] arr1 = new String[3];
        System.out.println(arr1); // 地址值
        System.out.println(arr1[0]); // 默认值 null
        System.out.println(arr1[1]); // 默认值 null
        System.out.println(arr1[2]); // 默认值 null

        // 存数据
        arr1[0] = "张无忌";
        arr1[1] = "张三丰";
        arr1[2] = "张翠山";

        System.out.println(arr1[0]); // 默认值 null
        System.out.println(arr1[1]); // 默认值 null
        System.out.println(arr1[2]); // 默认值 null

        System.out.println("==========遍历数组arr===========");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        System.out.println("==========遍历数组arr1===========");
        /*
        快捷键：数组名.fori
        */
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
    }
}

快捷键：数组名.fori

第三章 操作数组时两个常见的问题

3.1 数组索引越界异常——ArrayIndexOutOfBoundsException

  1. 原因：操作的索引超出了数组索引范围了

    public class Demo08Array {
    public static void main(String[] args) {
        int[] arr = new int[3];
        arr[0] = 100;
        arr[1] = 200;
        arr[1] = 300;
        // arr[3] = 400; // 索引3超出了arr的索引范围
        // arr[-1] = 400; // 索引-1超出了arr的索引范围

        for (int i = 0; i <= arr.length; i++) {
            System.out.println(arr[i]); // 当i等于3时，索引3超出了arr的索引范围
        }
    }
}

    image-20240314112719648

3.2 空指针异常——NullPinterException

  1. 原因：当一个对象为 null时，在调用此对象的其他

    public class Demo09Array {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr.length);

        arr = null;
        System.out.println(arr.length); // NullPointerException
    }
}

    image-20240314113143642

    image-20240314113434159

    以上两个问题，我们只需要知道原因

第四章 数组练习

4.1 需求：求出数组中的元素最大值

步骤：

a. 定义一个max，接收两个元素比较之后的较大值

b. 遍历数组，将每一个元素获取出来进行比较

c. 判断，如果max小于遍历出来的元素，证明遍历出来的元素大，就将大的重新赋值给max

d. 直接输出max

image-20240314114626916

public class Demo01GetMax {
    public static void main(String[] args) {
        /*
        需求：求出数组中的元素最大值
        步骤：
        a. 定义一个max，接收两个元素比较之后的较大值
        b. 遍历数组，将每一个元素获取出来进行比较
        c. 判断，如果max小于遍历出来的元素，证明遍历出来的元素大，就将大的重新赋值给max
        d. 直接输出max
        */
        int[] arr = {4, 1, 2, 6, 5};
        
        int max = arr[0];

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

4.2 随机产生10个[0-100]之间整数，统计既是3又是5，但不是7的倍数的个数

步骤：

a. 创建Random对象，用于生成随机数

b.定义一个数组，长度为10

c.定义一个变量 count，用于统计符合条件的数据个数

d.遍历数组，判断元素是否符合指定条件，如果符合，count++

e.输出count

public class Demo02Count {
    public static void main(String[] args) {
        /*
        随机产生10个[0-100]之间整数，统计既是3又是5，但不是7的倍数的个数
        步骤：
        a. 创建Random对象，用于生成随机数
        b.定义一个数组，长度为10
        c.定义一个变量 count，用于统计符合条件的数据个数
        d.遍历数组，判断元素是否符合指定条件，如果符合，count++
        e.输出count
         */
        // 1.创建Random对象，用于生成随机数
        Random rd = new Random();
        // 2.定义一个数组，长度为10
        int[] arr = new int[10];
        // 3.定义一个变量 count，用于统计符合条件的数据个数
        int count = 0;
        // 遍历数组，给数组赋值随机数
        for (int i = 0; i < arr.length; i++) {
            arr[i] = rd.nextInt(101);
        }
        // 4.遍历数组，判断元素是否符合指定条件，如果符合，count++
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%3==0 && arr[i]%5==0 && arr[i]%7 != 0) {
                count++;
            }
        }
        // 5.输出count
        System.out.println("count = " + count);
    }
}

4.3 定义一个数组 int[] arr = {1,2,3,4}，遍历数组，输出元素按照[1,2,3,4]

public class Demo03Print {
    public static void main(String[] args) {
        /*
        定义一个数组 int[] arr = {1,2,3,4}，遍历数组，输出元素按照[1,2,3,4]
         */
        int[] arr = {1, 2, 3 ,4};
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length -1) {
                System.out.print(arr[i]+"]");
            } else {
                System.out.print(arr[i]+",");
            }
        }
    }
}

4.4 需求：随机50个1-100之间的整数，统计偶数个数

步骤：

a. 创建Random对象，用于生成随机数

b. 定义长度为 50的数组

c. 随机50个存储到数组中

d. 定义变量 count，用于统计

e. 遍历数组，判断，如果是偶数，count++

f. 输出count

public class Demo04Count {
    public static void main(String[] args) {
        /*
        需求：随机50个1-100之间的整数，统计偶数个数
        步骤：
        a. 创建Random对象，用于生成随机数
        b. 定义长度为 50的数组
        c. 随机50个存储到数组中
        d. 定义变量 count，用于统计
        e. 遍历数组，判断，如果是偶数，count++
        f. 输出count
         */
        // 1. 创建Random对象，用于生成随机数
        Random rd = new Random();
        // 2. 定义长度为 50的数组
        int[] arr = new int[50];
        // 3.随机50个存储到数组中
        for (int i = 0; i < arr.length; i++) {
            arr[i] = rd.nextInt(99) + 1;
        }
        // 4.定义变量 count，用于统计
        int count = 0;
        // 5. 遍历数组，判断，如果是偶数，count++
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%2==0) {
                count++;
            }
        }
        // 6. 输出count
        System.out.println("count = " + count);
    }
}

4.5 键盘录入一个整数，找出整数在数组中存储的索引位置

步骤：

a. 创建Scanner对象

b. 定义数组，随便存几个数据

c. 遍历数组，在遍历的过程中，判断是否和录入的数相等，如果相等，输出索引

public class Demo05Search {
    public static void main(String[] args) {
        /*
        键盘录入一个整数，找出整数在数组中存储的索引位置
        步骤：
        a. 创建Scanner对象
        b. 定义数组，随便存几个数据
        c. 遍历数组，在遍历的过程中，判断是否和录入的数相等，如果相等，输出索引
         */
        // 1. 创建Scanner对象
        Scanner sc = new Scanner(System.in);
        // 2. 定义数组，随便存几个数据
        int[] arr = {5,6,8,2,9};
        System.out.println("请输入搜索的数");
        int data = sc.nextInt();
        // 3.遍历数组，在遍历的过程中，判断是否和录入的数相等，如果相等，输出索引
        for (int i = 0; i < arr.length; i++) {
            if (data == arr[i]) {
                System.out.println("i = " + i);
            }
        }
    }
}

问题升级：如果查不到，输出-1，代表没有查到

public class Demo05Search {
    public static void main(String[] args) {
        /*
        键盘录入一个整数，找出整数在数组中存储的索引位置
        步骤：
        a. 创建Scanner对象
        b. 定义数组，随便存几个数据
        c. 遍历数组，在遍历的过程中，判断是否和录入的数相等，如果相等，输出索引
         */
        // 1. 创建Scanner对象
        Scanner sc = new Scanner(System.in);
        // 2. 定义数组，随便存几个数据
        int[] arr = {5,6,8,2,9};
        System.out.println("请输入搜索的数");
        int data = sc.nextInt();
        // 定义一个变量，此变量用来表示是否有要查找的数据
        int flag = 0;
        // 3.遍历数组，在遍历的过程中，判断是否和录入的数相等，如果相等，输出索引
        for (int i = 0; i < arr.length; i++) {
            if (data == arr[i]) {
                System.out.println("i = " + i);
                flag++;
            }
        }
        /*
        4.判断flag是否还是0，如果遍历完，比较完之后，出了for循环，flag还是0，
          证明在遍历的过程中，没有走过if
         */
        if (flag == 0) {
            System.out.println(-1);
        }
    }
}

4.6 数组复制

image-20240314133302128

public class Demo06Copy {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4};
        int[] arr2 = new int[4];
        /*
        两个数组等长，遍历时可以共用 i
         */
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }

        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }
}

  1. 如果 arr[索引值] 在等号右边，证明是获取值；如果在等号左边，证明时存值

    arr[0] = 100;

  2. arr1[i] = arr2[i] → 先看等号右边的，相当于将 arr2 数组的 i 索引上的数据，保存到 arr1 数组的 i 索引上

    arr1[0] = arr2[0] → 先看等号右边的，相当于将arr2数组的 0 索引上的元素获取出来，保存到 arr1 数组的 0 索引上

4.7 数组扩容

需求：定义一个数组：int[] arr1 = {1,2,3,4,5}，将数组由原来的长度扩容到10.

image-20240314182628835

public class Demo07Array {
    public static void main(String[] args) {
        /*
            需求：定义一个数组：int[] arr1 = {1,2,3,4,5}，将数组由原来的长度扩容到10.
         */
        int[] oldArr = {1,2,3,4, 5};
        // 创建新数组
        int[] newArr = new int[10];
        // 将老数组中的元素复制到新数组中
        for (int i = 0; i < oldArr.length; i++) {
            newArr[i] = oldArr[i];
        }
        // 将新数组的地址值给老数组
        oldArr = newArr;

        for (int i = 0; i < oldArr.length; i++) {
            System.out.println(oldArr[i]);
        }
    }
}

image-20240315135655146

4.8 数组合并

数组合并：int[] arr1 = {1,2,3}, int[] arr2 = {4,5,6}

image-20240315140858183

public class Demo08Array {
    public static void main(String[] args) {
        /*
            数组合并：int[] arr1 = {1,2,3}, int[] arr2 = {4,5,6}
         */
        int[] arr1 = {1,2,3};
        int[] arr2 = {4,5,6};
        // 创建新数组
        int[] newArr = new int[arr1.length + arr2.length];
        // 先将 arr1 的元素放到newArr中
        for (int i = 0; i < arr1.length; i++) {
            newArr[i] = arr1[i];
        }
        /*
            由于已经保存了 arr1 的三个元素，所以我们保存arr2时，就不能从newArr的索引0开始，
            不然从arr1中保存的元素会被arr2的元素覆盖
            arr2的元素需要从newArr的索引3开始保存
         */
        // 先获取 arr1的长度为3
        int len = arr1.length; // 3
        for (int i = 0; i < arr2.length; i++) {
            /*
             i = 0时，newArr[3+0] = arr2[0]
             i = 1时，newArr[3+1] = arr2[1]
             i = 2时，newArr[3+2] = arr2[2]
             */
            newArr[len+i] = arr2[i];
        }

        for (int i = 0; i < newArr.length; i++) {
            System.out.println(newArr[i]);
        }
    }
}

image-20240315141004326

第五章 数组内存图

5.1 内存划分

内存： 可以理解为“内存条”，所有的软件，程序运行起来都会进入到内存中， 占用内存 ，在java的世界中，将 内存划分为5块

分为哪五块：

  1. 栈（重点）（Stack）：主要运行方法，方法的运行都会进栈内存运行，运行完毕之后；需要“弹栈”，为了腾空间，释放内存。

  2. 堆（重点）（Heap）：保存的是对象，数组，每new一次，都会在堆内存中开辟空间，并为这个空间分配一个地址值

    堆内存中的数据都是有默认值的

    整数： 0

    小数： 0.0

    字符： ‘\u0000’

    布尔： false

    引用： null

  3. 方法区（重点）（Method Area）：代码的“预备区”，记录了类的信息以及方法的信息；方法区中主要保存 class 文件以及其中的细腻；代码运行之前，需要先进内存（方法区）

  4. 本地方法栈（了解）（Native Method Stack）：专门运行 native方法（本地方法）；本地方法可以理解为堆对java功能的扩充，有很多功能，java语言实现不了，所以就需要依靠本地方法完成（C语言编写）

  5. 寄存器（了解）（PC register） → 和 CPU 有关

image-20240315143204938

5.2 一个数组的内存图

public class Demo01Array {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr); // 地址值
        System.out.println(arr[1]); // 0
        arr[1] = 100;
        System.out.println(arr[1]); // 100
    }
}

image-20240315161235299

5.3 两个数组的内存图

我们创建了两个数组，在堆内存中开辟了两个不同的空间，此时修改一个空间中的数据，不会影响到另一个空间的数据

public class Demo01Array {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr); // 地址值
        System.out.println(arr[1]); // 0
        arr[1] = 100;

        int[] arr2 = new int[3];
        System.out.println(arr2); // 地址值
        System.out.println(arr2[1]); // 0
        arr2[1] = 200;

        System.out.println(arr[1]); // 100
        System.out.println(arr2[1]); // 200
    }
}

image-20240315163341434

5.4 两个数组指向一片内存空间

arr2 不是new出来的，是arr1直接赋值给的，arr1在内存中保存的是地址值，给了arr2，那么arr2的地址值和arr1一样，所以此时arr1和arr2指向了堆内存中的同一片空间（同一个地址值，代表的是同一个数组），此时改变一个数组中的元素会影响到另外一个数组。

image-20240315173037032

第六章 二维数组

6.1 二维数组的定义格式

  1. 概述：数组中套了多个数组，

  2. 定义格式：

    a.动态初始化

    数据类型[][] 数组名 = new 数据类型[m][n]
数据类型 数组名[][] = new 数组类型[m][n]
数据类型[] 数组名[] = new 数组类型[m][n]

    m:代表的是二维数组的长度

    n：代表的是二维数组中每一个一维数组的长度

    数据类型[][] 数组名 = new 数据类型[m][]

    没有n表示二维数组中的一维数组没有被创建

    image-20240315180318452

    b. 静态初始化

    数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2,...}, {元素1,元素2,...},...}
数据类型 数组名[][] = new 数组类型[][]{{元素1,元素2,...}, {元素1,元素2,...},...}
数据类型[] 数组名[] = new 数组类型[][]{{元素1,元素2,...}, {元素1,元素2,...},...}

    c. 简化静态初始化

    数据类型[][] 数组名 = {{元素1,元素2,...}, {元素1,元素2,...},...}
数据类型 数组名[][] = {{元素1,元素2,...}, {元素1,元素2,...},...}
数据类型[] 数组名[] = {{元素1,元素2,...}, {元素1,元素2,...},...}

    public class Demo01Array {
    public static void main(String[] args) {
        /* 
            int[][] arr1 = new int[m][n];
            m:代表的是二维数组的长度
            n：代表的是二维数组中每一个一维数组的长度,没有n表示二维数组中的一维数组没有被创建
         */
        int[][] arr1 = new int[2][2];
        int[][] arr2 = new int[2][];

        System.out.println("====================");
        String[][] arr3 = {{"孙悟空", "唐僧"}, {"刘备", "关羽", "张飞"}, {"宋江"},{"林黛玉", "贾宝玉"}};

    }
}

6.2 获取二维数组长度

  1. 格式

    数组名.length

    image-20240315182152859

  2. 获取每一个一维数组长度，需要先遍历二维数组，将每一个一维数组遍历出来

    public class Demo02Array {
    public static void main(String[] args) {
        String[][] arr1 = {{"孙悟空", "唐僧"}, {"刘备", "关羽", "张飞"}, {"宋江"},{"林黛玉", "贾宝玉"}};
        System.out.println("二维数组长度"+arr1.length);
        // 获取每一个一维数组长度
        for (int i = 0; i < arr1.length; i++) {
            /*
                arr[i] → 代表的是每一个一维数组
             */
            System.out.println("第"+i+"一维数组长度"+arr1[i].length);
        }
    }
}

    image-20240315182805294

6.3 获取二维数组中的元素

  1. 格式

    数组名[i][j]

    i：代表的是一维数组在二维数组中的索引位置

    j：代表的是元素在一维数组中的索引位置

    public class Demo03Array {
    public static void main(String[] args) {
        String[][] arr1 = {{"孙悟空", "唐僧"}, {"刘备", "关羽", "张飞"}, {"宋江"},{"林黛玉", "贾宝玉"}};
        System.out.println(arr1[0][0]);
        System.out.println(arr1[2][0]);
        System.out.println(arr1[3][1]);
    }
}

    image-20240315184900560

6.4 二维数组中存储元素

  1. 格式

    数组名[i][j] = 值

    i：代表的是一维数组在二维数组中的索引位置

    j：代表的是元素在一维数组中的索引位置

    public class Demo04Array {
    public static void main(String[] args) {
        String[][] arr = new String[2][2];
        arr[0][0] = "张飞";
        arr[0][1] = "李逵";
        arr[1][0] = "刘备";
        arr[1][1] = "宋江";

        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
    }
}

6.5 二维数组的遍历

先遍历二维数组，将每一个一维数组遍历出来，在遍历每一个一维数组，将元素获取出来。

public class Demo05Array {
    public static void main(String[] args) {
        String[][] arr = new String[2][2];
        arr[0][0] = "张飞";
        arr[0][1] = "李逵";
        arr[1][0] = "刘备";
        arr[1][1] = "宋江";
        // 遍历二维数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i].length);
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }
}

6.6 二维数组内存图

public class Demo06Array {
    public static void main(String[] args) {
        int[][] arr1 = new int[3][];
        arr1[1] = new int[] {1, 2, 3};
        arr1[2] = new int[3];
        arr1[2][1] = 100;
    }
}

image-20240315194108325

总结

img

枫林残忆168
关注
  • 21
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
使用Numpy模块创建数组对象
也许会有_hui的博客
06-13 1563
目录 一、Numpy模块的简介 二、使用Numpy模块创建数组对象 1.array （1）创建一维数组 （2）创建二维数组 2.arange 3.linspace 创建一个均匀数组 4.logspace 创建等比数列 5.zeros 创建全为0的多维数组 6.ones 创建全为1的多维数组 7.eye 创建单位矩阵E 8.diag 创建指定元素组成的对角数组 ...
python的ctypes模块详解数组_python ctypes结构数组
weixin_39872044的博客
02-21 1508
代码中的STRUCT_ARRAY应该是指向指针数组的指针，而不是指向数组中某个元素的指针，因为您将STRUCT_2指针附加到数组中。在c语言中，STRUCT_数组可以定义为*STRUCT_2[长度]，也就是STRUCT_2指针的数组import ctypesfrom random import randintclass STRUCT_2(ctypes.Structure):#_pack_=2_fi...
verilog的模块端口支持数组
xiao_yao_ke的博客
09-25 6592
// pack 2D-array to 1D-array `define PACK_ARRAY(PK_WIDTH,PK_LEN,PK_SRC,PK_DEST) \                 generate \                 genvar pk_idx; \                 for (pk_idx=0; pk_idx&lt;(PK_LEN); pk_idx=...
【入门】Python之numpy模块的数组运算
weixin_43780617的博客
06-08 556
Python中numpy模块的ndarray对象的常用基本函数操作，早学早享受，晚学享受煎熬和不用功读书的懊悔
python模块：array数组模块
热门推荐
皮皮blog
03-17 1万+
http://blog.csdn.net/pipisorry/article/details/62889137数组模块array简介在Python中，列表是一个动态的指针数组，而array模块所提供的array对象则是保存相同类型的数值的动态数组。list的内存分析参考[python数据类型的内存分析 ]。数组并不是Python中内置的标配数据结构，不
易语言数组操作模块
08-16
易语言数组操作模块源码 系统结构:数组_翻转成员,数组_取成员索引,数组_是否有重复项,数组_取重复项成员名,数组_替换成员,数组_文本排序,字符串比较大小,数组_置合并数组, ======程序
易语言数组比较模块
08-16
易语言数组比较模块源码 系统结构:比较数组不同_整数,比较数组不同_文本,比较数组不同_逻辑,比较数组不同_字节,比较数组不同_字节集,比较数组不同_子程序指针,比较数组不同_日期时
Python使用numpy模块创建数组操作示例
09-20
本篇文章将深入探讨如何使用numpy模块创建数组，包括`array`、`zeros`、`zeros_like`、`ones`、`ones_like`、`empty`、`empty_like`以及`arange`和`eye`等函数。 1. **创建数组**： - `np.array()` 是numpy中创建...
易语言数组排序模块
08-17
易语言数组排序模块源码 系统结构:冒泡,选择_asm,交换_asm,选择_,交换,冒泡_E自带例子_改良后,插入,快速排序,快速排序_asm,asm快速排序,快速排序2,快速排序2_asm,asm快速排序2, ======程序集
Web模块挑战数组
02-19
数组 目标 使用数组来存储和访问数据 使用数组属性和数组方法 介绍 全球冰淇淋店连锁店Baskin Robins于1945年首次开业，提供31种口味的冰淇淋。 在全球范围内，它们已发展到近6,000个专营权，现在因一次提供正好31种...
新需求：实现一个自动运维部署工具
云端源想的博客
06-13 674
如何构建一个高效、可靠的自动运维部署工具，以下是具体的需求情况，希望有朋友可以指点一下，有报酬的哦！
Java 树形结构数据如何高效返回给前端进行展示？
最新发布
qq_31674229的博客
06-19 173
Java 树形结构数据如何高效返回给前端进行展示
认识QML
燃犀的博客
06-18 205
Qt Quick是Qt5界面开发技术的统称，是以下几种技术的集合QML-界面标记语言JavaScript-动态脚本语言Qt C+±跨平台c++封装库QML是与HTML类似的一种标记语言。在QtQuick中将由标签组成的元素封装在大括号中 Item{}。这样的设计重新定义了界面的创建方式，对于开发者而言更加简单易读。可以使用JavaScript开发界面功能，也可以使用本地Qt C++函数接口扩展界面功能。简单来说，声明式的UI被称作前端，本地C++部分称作后端，将复杂的。
LuckySheet后端传被依赖数据和公式前端进行测算示例
jiyukun1的博客
06-13 322
通过LuckySheet的回调函数workbookCreateAfter，WookBook创建之后将值重新刷新覆盖，json中包含的格子的全部数据，需要将只将公式set回去即可，后端将数据和公式返给前端，前端进行计算，消耗的是本地浏览器的资源，LuckySheet官方文档并没有相关文档来说明前端和后端重新计算的案例。但是如果公式特别大，导致前端计算和渲染特别慢，慢的原因是luckysheet.setCellValue太重了，有很多操作，数据量少可以使用。
Go版RuoYi
K.
06-12 1360
后端用Go写的RuoYi权限管理系统 (功能正在持续实现)后端Gitee地址。
el-upload上传文件类型大小限制+手动上传+通过后端给的接口带参数_el-upload 文件类型
2401_85124682的博客
06-12 336
上传配置。
澳洲前端与后端开发的区别：深入解析两者之间的异同
huyngd89_666的博客
06-13 620
前端开发主要负责实现用户界面和用户交互，包括网页的布局、样式、动画、表单、图像等。此外，随着技术的不断进步和市场的变化，前端和后端开发者都需要不断学习新知识和技能，以适应行业的发展。综上所述，澳洲的前端开发和后端开发在职责、技术要求、开发环境、视角、目标以及职业发展和市场需求等方面都存在着显著的差异。同时，无论选择哪个方向，都需要保持学习的热情和持续的努力，以适应不断变化的IT行业。而后端开发者则从业务角度出发，关注数据处理和安全性，致力于提供可靠的业务逻辑和高效的数据处理，以增强系统稳定性和安全性。
vue聊天发送Emoji表情
qq_45963071的博客
06-13 764
在用web端写聊天发送表情的功能中，使用web端系统自带的unicode表情会出现app跟web表情不统一问题且还不好看，在这里我想到了一个非常好的思路，可以解决这个问题！
jeecg-boot修改后端项目名称为自定义
疏笃
06-12 282
找到dependencyManagement标签。4、修改父pom中版本号对应的项目名称。然后修改 每一个项目的名称。
点击QT模块就串口发送数组
05-22
要实现点击QT模块后串口发送数组，你需要先创建一个串口对象并打开串口。然后，在QT模块中添加一个按钮控件，当按钮被点击时，触发发送数组的函数。下面是一个简单的示例代码，可以参考一下： ```c++ #include #...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

枫林残忆168

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值