二维数组

提示

Java基础,博主看的黑马的视频。

# 1 数据交换

案例需求

已知两个整数变量a = 10，b = 20，使用程序实现这两个变量的数据交换最终输出a = 20，b = 10;

代码实现

package com.itheima.test;

public class Test1 {
 /*
     需求：已知两个整数变量a = 10，b = 20，使用程序实现这两个变量的数据交换
     最终输出a = 20，b = 10;


     思路：
        1. 定义一个三方变量temp，将a原本记录的值，交给temp记录 （a的值，不会丢了）
        2. 使用 a 变量记录 b 的值，（第一步交换完毕，b的值也丢不了了）
        3. 使用 b 变量记录 temp的值，也就是a原本的值 （交换完毕）
        4. 输出 a 和 b 变量即可
     */
    /*
        动态初始化格式：

            数据类型[][] 变量名 = new 数据类型[m][n];
            m表示这个二维数组，可以存放多少个一维数组
            n表示每一个一维数组，可以存放多少个元素
     */
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        // 将a原本记录的值，交给temp记录 （a的值，不会丢了）
        int temp = a;
        // 用 a 变量记录 b 的值，（第一步交换完毕，b的值也丢不了了）
        a = b;
        // 使用 b 变量记录 temp的值，也就是a原本的值 （交换完毕）
        b = temp;

        // 输出 a 和 b 变量即可
        System.out.println("a=" + a);
        System.out.println("b=" + b);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# 1.1 数组反转

案例需求 :

已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换，

交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素

实现步骤 :

定义两个变量, start和end来表示开始和结束的指针.
确定交换条件, start < end 允许交换
循环中编写交换逻辑代码
每一次交换完成, 改变两个指针所指向的索引 start++, end--
循环结束后, 遍历数组并打印, 查看反转后的数组

代码实现 :

package com.itheima.test;

public class Test2 {
 /*
     需求：已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换，
       交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素。

     步骤:
              1. 定义两个变量, start和end来表示开始和结束的指针.
              2. 确定交换条件, start < end 允许交换
              3. 循环中编写交换逻辑代码
              4. 每一次交换完成, 改变两个指针所指向的索引 start++, end--
              5. 循环结束后, 遍历数组并打印, 查看反转后的数组
     */
    public static void main(String[] args) {
        int[] arr = {19, 28, 37, 46, 50};
        //  1. 定义两个变量, start和end来表示开始和结束的指针.
        int start = 0;
        int end = arr.length -1;
        //  2. 确定交换条件, start < end 允许交换
        // 4. 每一次交换完成, 改变两个指针所指向的索引 start++, end--
        // for(int start = 0, end = arr.length -1; start < end; start++, end--)
        for( ; start < end; start++, end--){
            // 3. 循环中编写交换逻辑代码
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# 1.2 二维数组概述

概述 : 二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器

# 1.3 二维数组动态初始化

动态初始化格式：数据类型[][] 变量名 = new 数据类型[m][n]; m表示这个二维数组，可以存放多少个一维数组 n表示每一个一维数组，可以存放多少个元素

package com.itheima.demo;

public class Demo1Array {
 /*
     动态初始化格式：

         数据类型[][] 变量名 = new 数据类型[m][n];
         m表示这个二维数组，可以存放多少个一维数组
         n表示每一个一维数组，可以存放多少个元素
  */
 public static void main(String[] args) {
     // 数据类型[][] 变量名 = new 数据类型[m][n];
     int[][] arr = new int[3][3];
     /*
         [[I@10f87f48

         @ : 分隔符
         10f87f48 : 十六进制内存地址
         I : 数组中存储的数据类型
         [[ : 几个中括号就代表的是几维数组
      */
     System.out.println(arr);

     /*
         二维数组存储一维数组的时候, 存储的是一维数组的内存地址
      */
     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[1][1]);
     System.out.println(arr[2][2]);

     // 向二维数组中存储元素
     arr[0][0] = 11;
     arr[0][1] = 22;
     arr[0][2] = 33;

     arr[1][0] = 11;
     arr[1][1] = 22;
     arr[1][2] = 33;

     arr[2][0] = 11;
     arr[2][1] = 22;
     arr[2][2] = 33;

     // 从二维数组中取出元素并打印
     System.out.println(arr[0][0]);
     System.out.println(arr[0][1]);
     System.out.println(arr[0][2]);
     System.out.println(arr[1][0]);
     System.out.println(arr[1][1]);
     System.out.println(arr[1][2]);
     System.out.println(arr[2][0]);
     System.out.println(arr[2][1]);
     System.out.println(arr[2][2]);
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

# 1.4 二维数组访问元素的细节问题

问题 : 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?

答 : 可以的

代码实现

package com.itheima.demo;

public class Demo2Array {
 /*
     问题: 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?
     答 : 可以的
  */
 public static void main(String[] args) {
     int[] arr1 = {11,22,33};
     int[] arr2 = {44,55,66};
     int[] arr3 = {77,88,99,100};

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

     arr[2][3] = 100;

     arr[0] = arr1;
     arr[1] = arr2;
     arr[2] = arr3;

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 1.5 二维数组静态初始化

完整格式 : 数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...}

简化格式 : 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};

**代码实现 : **

package com.itheima.demo;

public class Demo3Array {
 /*
     完整格式：数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...} ...};

     简化格式: 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};
  */
 public static void main(String[] args) {
     int[] arr1 = {11,22,33};
     int[] arr2 = {44,55,66};

     int[][] arr = {{11,22,33}, {44,55,66}};
     System.out.println(arr[0][2]);

     int[][] array = {arr1,arr2};
     System.out.println(array[0][2]);
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 1.6 二维数组遍历

需求 :

已知一个二维数组

arr = {{11, 22, 33}, {33, 44, 55}};

遍历该数组，取出所有元素并打印

步骤 :

遍历二维数组，取出里面每一个一维数组
在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素

代码实现 :

package com.itheima.test;

public class Test1 {
 /*
     需求:

         已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};
         遍历该数组，取出所有元素并打印

     步骤:
            1. 遍历二维数组，取出里面每一个一维数组
            2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素
     */
    public static void main(String[] args) {
        int[][] arr = {{11, 22, 33}, {33, 44, 55}};

        // 1. 遍历二维数组，取出里面每一个一维数组
        for (int i = 0; i < arr.length; i++) {
            //System.out.println(arr[i]);
            // 2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素
            //int[] temp = arr[i];
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 1.7 二维数组求和

需求 :

某公司季度和月份统计的数据如下：单位(万元)

第一季度：22,66,44

第二季度：77,33,88

第三季度：25,45,65

第四季度：11,66,99

步骤 :

定义求和变量，准备记录最终累加结果
使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
遍历二维数组，获取所有元素，累加求和
输出最终结果

代码实现 :

package com.itheima.test;

public class Test2 {
 /*
     需求:
         某公司季度和月份统计的数据如下：单位(万元)
         第一季度：22,66,44
         第二季度：77,33,88
         第三季度：25,45,65
         第四季度：11,66,99

     步骤:
            1. 定义求和变量，准备记录最终累加结果
            2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
            3. 遍历二维数组，获取所有元素，累加求和
            4. 输出最终结果
     */
    public static void main(String[] args) {
        // 1. 定义求和变量，准备记录最终累加结果
        int sum = 0;
        // 2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
        int[][] arr = { {22,66,44} , {77,33,88} , {25,45,65} , {11,66,99}};
        // 3. 遍历二维数组，获取所有元素，累加求和
        for (int i = 0; i < arr.length; i++) {
            for(int j = 0; j < arr[i].length; j++){
                sum += arr[i][j];
            }
        }
        // 4. 输出最终结果
        System.out.println(sum);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#Java基础 #Java基础语法

上次更新: 2022/05/12 14:57:53

← 进制面向对象基础→