数组

人间造梦工厂

已于 2024-06-16 14:05:14 修改

阅读量250

点赞数 1

分类专栏： Java 文章标签： Java

于 2024-06-15 11:33:15 首次发布

本文链接：https://blog.csdn.net/chengkai730/article/details/139699378

版权

Java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

概述

数组是一个引用类型，是一种容器。

数组存储多个相同数据类型的数据，允许自动类型转换。例如 int 类型的数组，可以存放 byte、short 和 int 类型的数据，double 类型的数组，可以存放 byte、short、int、long、float 和 double 类型的数据。

程序示例：

public class array1 {
    public static void main(String[] args) {
        double[] hens = {1, 2, 3};   // 定义数组
        // 数组名为 hens，数组的类型为 double[]，数组中的元素的类型为 double
        // 遍历数组
        for (int i = 0; i < hens.length; i++) {
            System.out.println(hens[i]);
        }
    }
}

获取数组元素个数：数组名.length

数组名是一个地址。

程序示例：

public static void main(String[] args) {
    double[] double1 = {1.1, 2.2, 3, 4, 5};
    System.out.println(double1);            // [D@119d7047
    float[] float1 = {1.1F, 2.2F, 3, 4, 5};
    System.out.println(float1);             // [F@776ec8df
    long[] long1 = {1, 2, 3};
    System.out.println(long1);              // [J@4eec7777
    int[] int1 = {1, 2, 3};
    System.out.println(int1);               // [I@3b07d329
    short[] short1 = {1, 2, 3};
    System.out.println(short1);             // [S@41629346
    byte[] byte1 = {1, 2, 3};
    System.out.println(byte1);              // [B@404b9385
    boolean[] boolean1 = {false, false, true, false, true};
    System.out.println(boolean1);           // [Z@6d311334
    char[] char1 = {'1', '2', '3'};
    System.out.println(char1);              // 123
    String[] String1 = {"Hello", "World"};
    System.out.println(String1);            // [Ljava.lang.String;@682a0b20
}

结果前面的字母指出了数组元素的类型。结果最前面的 [ 表示是一个数组。@ 后面的内容才是真正的地址值，是一个十六进制的值。平时习惯性地将整个结果称为地址，但实际上只有 @ 后面的才是真正的地址。@ 表示一个间隔符号，是固定格式，没有什么特殊含义。

对于字符数组：

public static void main(String[] args) {
    char[] char1 = {'1', '2', '3'};
    System.out.println(char1);              // 123
    char[] char2 = {'1', '2', '3', '9'};
    System.out.println(char2);              // 1239
    char[] char3 = {'9', '8', '7'};
    System.out.println(char3);              // 987
}

数组的静态初始化

数组的初始化：在内存中，为数组容器开辟空间，并将数据存入容器中的过程。

数组初始化有两种方式：动态初始化和静态初始化。

语法：

// 完整格式：
数据类型[] 数组名 = new 数据类型[] {元素1, 元素2, ... , 元素n};
// 或者：
数据类型 数组名[] = new 数据类型[] {元素1, 元素2, ... , 元素n};

例如：

int[] arr1 = new int[]{1, 2, 3};
double[] arr2 = new double[]{1.1, 2.2, 3.3};

// 简化格式：
数据类型[] 数组名 = {元素1, 元素2, ... , 元素n};
// 或者：
数据类型 数组名[] = {元素1, 元素2, ... , 元素n};

例如：

int[] a = {1, 2, 3};   // 等价于 int a[] = {1, 2, 3};

程序示例：

public class ArrayDemo {
    public static void main(String[] args) {
        // 需求1：定义数组存储5个学生的年龄
        int[] arr1 = new int[]{12, 14, 16, 17, 18};
        int[] arr2 = {12, 14, 16, 17, 18};
        // 需求2：定义数组存储3个学生的姓名
        String[] arr3 = new String[]{"zhangsan", "lisi", "wangwu"};
        String[] arr4 = {"zhangsan", "lisi", "wangwu"};
        // 需求3：定义数组存储4个学生的身高
        double[] arr5 = new double[]{1.9, 1.8, 1.7, 1.6};
        double[] arr6 = {1.9, 1.8, 1.7, 1.6};
    }
}

程序示例：

// 定义一个数组，存储 1，2，3，4，5
// 遍历数组得到每一个元素，求数组里面所有的数据和
public class array1 {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println(sum);    // 15
    }
}

程序示例：

// 定义一个数组
// 存储 1，2，3，4，5，6，7，8，9，10
// 遍历数组得到每一个元素，统计数组里面一共有多少个能被 3 整除的数字

public class array1 {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] % 3 == 0)
                ++count;
        }
        System.out.println("数组中能被3整除的数字有" + count + "个。");
    }
}

执行结果：

数组中能被3整除的数字有3个。

程序示例：

// 定义一个数组，存储 1，2，3，4，5，6，7，8，9，10
// 遍历数组得到每一个元素。
// 要求：
// 1、如果是奇数，则将当前数字扩大两倍
// 2、如果是偶数，则将当前数字变成二分之一

public class array1 {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        System.out.println("原始数组为：");
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }
        // 处理数组
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] % 2 == 0)
                nums[i] /= 2;
            else nums[i] *= 2;
        }
        System.out.println("\n处理之后的数组为：");
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }
    }
}

执行结果：

原始数组为：
1        2        3        4        5        6        7        8        9        10        
处理之后的数组为：
2        1        6        2        10        3        14        4        18        5

程序示例：

// 需求：已知数组元素为 {33, 5, 22, 44, 55}
// 请找出数组中最大值并打印在控制台

public class array1 {
    public static void main(String[] args) {
        int[] nums = {33, 5, 22, 44, 55};
        int max = nums[0];
        for (int i = 0; i < nums.length; i++) {
            max = (max > nums[i] ? max : nums[i]);
        }
        System.out.println("最大值为" + max);
    }
}

执行结果：

最大值为55

程序示例：

// 冒泡排序
public class array1 {
    public static void main(String[] args) {
        int[] nums = {33, 5, 22, 44, 55};
        for (int i = 1; i <= nums.length - 1; i++) {
            for (int j = 0; j <= nums.length - 1 - i; j++) {
                if (nums[j] < nums[j + 1]) {
                    int tmp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = tmp;
                }
            }
        }
        System.out.println("从大到小进行排序：");
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }
    }
}

执行结果：

从大到小进行排序：
55        44        33        22        5

程序示例：

// 需求：生成 10 个 1~100 之间的随机数存入数组。
// 1) 求出所有数据的和
// 2) 求所有数据的平均数
// 3) 统计有多少个数据比平均值小

import java.util.Random;

public class array1 {
    public static void main(String[] args) {
        Random r = new Random();

        int[] nums = new int[10];

        // 打印数组初始值
        System.out.println("数组初始值：");
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }

        // 生成数组的值
        for (int i = 0; i < nums.length; i++) {
            nums[i] = r.nextInt(100) + 1;
        }

        // 打印数组现在的值
        System.out.println("\n数组现在的值：");
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }

        // 求数组元素之和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }

        // 求数组元素平均数
        int avg = sum / nums.length;

        // 求数组值小于平均数的个数
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] < avg)
                ++count;
        }

        System.out.println("\n数组元素之和为" + sum);
        System.out.println("数组元素平均值为" + avg);
        System.out.println("数组中元素小于平均值的个数有" + count + "个");
    }
}

执行结果：

数组初始值：
0        0        0        0        0        0        0        0        0        0        
数组现在的值：
72        6        35        98        45        85        16        100        85        47        
数组元素之和为589
数组元素平均值为58
数组中元素小于平均值的个数有5个

程序示例：

// 需求：定义一个数组，存入 1, 2, 3, 4, 5。按照要求交换索引对应的元素。
// 交换前：1, 2, 3, 4, 5
// 交换后：5, 2, 3, 4, 1

public class array1 {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        System.out.println("交换之前的数组：");
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }
        // 交换
        // int i = 0, j = nums.length - 1;
        // while (i <= j) {
        //     int tmp = nums[i];
        //     nums[i] = nums[j];
        //     nums[j] = tmp;
        //     ++i;
        //     --j;
        // }
        for (int i = 0, j = nums.length - 1; i <= j; ++i, --j) {
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }

        System.out.println("\n交换之后的数组：");
        for (int k = 0; k < nums.length; k++) {
            System.out.print(nums[k] + "\t");
        }
    }
}

执行结果：

交换之前的数组：
1        2        3        4        5        
交换之后的数组：
5        4        3        2        1

程序示例：

// 需求：定义一个数组，存入 1~9。要求随机打乱数组中所有数据的顺序。

import java.util.Random;

public class array1 {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9};

        System.out.println("初始状态的数组：");
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }

        Random r = new Random();
        // 每一次遍历到当前数组元素时，只和后面的随机一个元素进行交换
        for (int i = 0; i < nums.length - 1; i++) {
            int randomIndex = r.nextInt(nums.length - 1 - i - 1 + 1) + i + 1;
            int tmp = nums[i];
            nums[i] = nums[randomIndex];
            nums[randomIndex] = tmp;
        }

        System.out.println("\n方法一打乱之后的数组：");
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }

        // 每一次遍历到当前数组元素时，和一个随机元素进行交换
        for (int i = 0; i < nums.length - 1; i++) {
            int randomIndex = r.nextInt(nums.length);
            int tmp = nums[i];
            nums[i] = nums[randomIndex];
            nums[randomIndex] = tmp;
        }

        System.out.println("\n方法二打乱之后的数组：");
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }
    }
}

执行结果：

初始状态的数组：
1        2        3        4        5        6        7        8        9        
方法一打乱之后的数组：
9        8        6        2        4        5        1        7        3        
方法二打乱之后的数组：
3        1        9        8        7        4        5        6        2

数组动态或者静态初始化时，允许自动类型转换，能进行自动类型转换的类型可以被赋值给数组元素，不能进行自动类型转换的类型不能赋值给数组元素，否则报错：不兼容的类型。

程序示例：

public class array1 {
    public static void main(String[] args) {
        double[] nums = {1.1, 2.2, 3, 4, 5};    // 此处的静态初始化，利用了自动类型转换
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + "\t");
        }
    }
}

执行结果：

1.1        2.2        3.0        4.0        5.0

IDEA 提供了一个快速生成数组遍历的方式：数组名.fori

[图片]

数组中的数据类型，可以是基本类型或者引用类型。

数组下标越界会报错。编译时不检查是否越界，运行时才报错。

程序示例：

public class array1 {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        System.out.println(nums[3]);  // ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
    }
}

数组的动态初始化 1

动态初始化：初始化时只指定数组的长度，由虚拟机为数组分配初始值。

动态初始化的数组的定义：

数据类型 数组名[] = new 数据类型[数组长度];
// 或者：
数据类型[] 数组名 = new 数据类型[数组长度];  // 两者等价，但是推荐使用这一种

不同数据类型的数组，默认的初始值不同。

int 类型默认初始值为 0
short 类型默认初始值为 0
byte 类型默认初始值为 0
long 类型默认初始值为 0
float 类型默认初始值为 0.0
double 类型默认初始值为 0.0
char 类型默认初始值为 \u0000 (零字符)，打印出来就是一个空格。
boolean 类型默认初始值为 false
引用数据类型默认初始值为 NULL

程序示例：

public class array1 {
    public static void main(String[] args) {
        double[] hens = new double[3]; // 定义数组
        int[] kens = new int[4];
        double sumHens = 0;
        int sunKens = 0;
        // 遍历数组
        for (int i = 0; i < hens.length; i++) {
            System.out.print(hens[i] + "\t");
            sumHens += hens[i];
        }
        System.out.println("");
        for (int i = 0; i < kens.length; i++) {
            System.out.print(kens[i] + "\t");
            sunKens += kens[i];
        }
        System.out.println();
        System.out.println(sumHens);
        System.out.println(sunKens);
    }
}

结果：

0.0        0.0        0.0        
0        0        0        0        
0.0
0

程序示例：

public class array1 {
    public static void main(String[] args) {
        byte[] bytes = new byte[10];
        short[] shorts = new short[10];
        int[] ints = new int[10];
        long[] longs = new long[10];
        char[] chars = new char[10];
        boolean[] booleans = new boolean[10];
        float[] floats = new float[10];
        double[] doubles = new double[10];
        String[] Strings = new String[10];

        System.out.println(bytes[0]);           // 0
        System.out.println(shorts[0]);          // 0
        System.out.println(ints[0]);            // 0
        System.out.println(longs[0]);           // 0
        System.out.println(chars[0]);
        System.out.println(booleans[0]);        // false
        System.out.println(floats[0]);          // 0.0
        System.out.println(doubles[0]);         // 0.0
        System.out.println(Strings[0]);         // null
    }
}

执行结果：

0
0
0
0
 
false
0.0
0.0
null

程序示例：

// 空字符 \u0000 打印出来就是一个空格
public class array1 {
    public static void main(String[] args) {
        System.out.println("Hello\u0000World!");    // Hello World!
    }
}

数组的动态初始化 2

先声明数组，语法：

数据类型 数组名[];
// 或者：
数据类型[] 数组名;

再创建数组，语法：

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

例如：

int[] a;           // 或者 int a[];   此时还没有在内存中为 a 分配空间，a 是 NULL
a = new int[10];   // 此时在内存中为 a 分配了空间，只有分配了存储空间，才能存放数据，否则报错，显示空指针异常

其实就是把方式 1 分两步写了。

错误代码：

// 在未分配空间的情况下，访问数组的长度：
public class array1 {
    public static void main(String[] args) {
        double[] a;
        System.out.println(a.length);  // 可能尚未初始化变量 a
    }
}

数组赋值

数组赋值是引用传递，传递的是地址。

程序示例：

public class ArrayAssign {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3};
        int[] arr2 = arr1;
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + " ");
        }
        System.out.println("");
        arr2[1] = 100;
        for (int i = 0; i < arr1.length; i++) {  // 修改 arr2 会影响 arr1
            System.out.print(arr1[i] + " ");
        }
    }
}

执行结果：

1 2 3 
1 100 3

程序示例：

public class test {
    public static void main(String[] args) {
        // 给定一个初始数组
        int[] arr1 = {1, 2, 3};
        // 遍历打印初始数组
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + " ");
        }
        // 调用方法修改数组
        change(arr1);
        // 遍历打印修改后的数组
        System.out.println();
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + " ");
        }
    }

    // 修改数组的方法
    public static void change(int[] arr) {
        arr[0] = 100;
    }
}

执行结果：

1 2 3 
100 2 3

JVM 内存

在这里插入图片描述

在 JDK 7 之前，JVM 将方法区和堆放在一起，在真实的物理内存中，也是一块连续的空间。但是这种设计方式不太好。从 JDK 8 开始，取消方法区，新增元空间。把原来方法区的多种功能进行拆分，有的功能放到了堆中，有的功能放到了元空间中。

寄存器：给 CPU 使用，和我们开发无关。

本地方法栈：JVM 在使用操作系统功能的时候使用，和我们开发无关。

栈：方法运行时使用的内存，比如 main 方法运行时会先进栈。基本数据类型都放在栈中。

堆：存储对象或者数组，只要是 new 出来的东西，比如数组，都存储在堆内存。new 出来的东西会在堆内存中开辟空间并产生地址，表示在堆内存中的位置。

方法区：存储可以运行的 class 文件。当一个类要运行时，要把这个类的字节码文件，即 class 文件加载到方法区中临时存储。

[图片]

数组的静态初始化可以有简化的书写方式，这种书写方式是没有 new 关键字的，但是还是认为是有 new 关键字的，只是省略没写，所以还是 new 出来的东西。

[图片]

int[] arr1 中的 int[] 表示 arr1 可以存放 int 型数组的地址。

当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果了。

拷贝数组

要求：将数组 arr1 拷贝到数组 arr2。进行值传递，而不是引用传递，即拷贝之后的数组的改变，不影响原数组，两个数组的内存空间是独立的。

思路：

新建一个数组 arr2，长度等于 arr1。
利用 for 循环遍历 arr1 的所有元素，将其复制到 arr2 中。

程序示例：

public class ArrayCopy {
    public static void main(String[] args) {
        int[] arr1 = { 1, 2, 3 }; // 定义数组arr1
        int[] arr2 = new int[arr1.length]; // 定义新数组arr2
        // 遍历数组arr1,将每一个元素值复制给arr2的对应位置
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        // 输出arr1
        System.out.print("arr1:");
        for (int i = 0; i < arr1.length; i++)
            System.out.print(arr1[i] + " ");
        System.out.println("");
        // 输出arr2
        System.out.print("arr2:");
        for (int i = 0; i < arr1.length; i++)
            System.out.print(arr2[i] + " ");
        System.out.println("");
        // 修改arr2的某一个元素
        arr2[1] = 999;
        // 输出arr1
        System.out.print("arr1:");
        for (int i = 0; i < arr1.length; i++)
            System.out.print(arr1[i] + " ");
        System.out.println("");
        // 输出修改后的arr2
        System.out.print("arr2:");
        for (int i = 0; i < arr1.length; i++)
            System.out.print(arr2[i] + " ");
        System.out.println("");
    }
}

结果：

arr1:1 2 3 
arr2:1 2 3
arr1:1 2 3
arr2:1 999 3

二维数组

初始化的两种方法：静态初始化和动态初始化。

静态初始化

public static void main(String[] args) {
    int[][] arr1 = new int[][]{{11, 22, 33, 44}, {33, 44, 55, 66}};
    System.out.println(arr1.length);        // 2
    int[][] arr2 = new int[][]{{11, 22, 33}, {44, 55, 66}, {44, 55, 66}, {44, 55, 66}};
    System.out.println(arr2.length);        // 4，说明对于二维数组而言，arr.length表示一维数组的个数
}

public static void main(String[] args) {
    int arr3[][] = {                        // 建议将多个一维数组分行书写，每行一个一维数组
            {11, 22, 33},
            {44, 55, 66},
            {44, 55, 66},
            {44, 55, 66},
            {11, 22, 33}
    };
    System.out.println(arr3.length);        // 5
    System.out.println(arr3[0]);            // [I@119d7047
    System.out.println(arr3[1]);            // [I@776ec8df
    System.out.println(arr3[2]);            // [I@4eec7777
}

public static void main(String[] args) {
    int[][] arr4 = {{1, 2, 3}, {}, {4, 5}}; // 简化写法,且子数组元素个数不同
    System.out.println(arr4.length);        // 3
    System.out.println(arr4[0].length);     // 3
    System.out.println(arr4[1].length);     // 0
    System.out.println(arr4[2].length);     // 2
    // for (int i = 0; i < arr4[0].length; i++) {
    //     for (int j = 0; j < arr4[1].length; j++) {
    //         System.out.println(arr4[i][j]); // Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 2 out of bounds for length 2
    //     }
    // }
    // 正确的打印二维数组的方法：
    for (int i = 0; i < arr4.length; i++) {
        for (int j = 0; j < arr4[i].length; j++) {
            System.out.print(arr4[i][j] + "  ");
        }
        System.out.println();
    }
    System.out.println(arr4[0][2]);         // 3
}

执行结果：

动态初始化

格式：

数据类型[][] 数组名 = new 数据类型[m][n];
// m 表示这个二维数组可以存放多少个一维数组.
// n 表示每一个一维数组可以存放多少个元素.

范例：

int[][] arr = new int[2][3];    // 该数组可以放 2 个一维数组, 每一个一维数组可以放 3 个 int 类型的元素.

程序示例：

public static void main(String[] args) {
    int[][] arr1 = new int[2][3];
    arr1[1][2] = 10;
    for (int i = 0; i < arr1.length; i++) {
        for (int j = 0; j < arr1[i].length; j++) {
            System.out.print(arr1[i][j] + "  ");
        }
        System.out.println();
    }
}

执行结果：

0  0  0  
0  0  10

没有初始化的地方是默认初始化，因此用这一种动态初始化方式定义的数组，一定是四四方方的，不会像静态初始化那样有空缺的角。

二维数组的内存图

public static void main(String[] args) {
    int[][] arr = new int[2][3];
}

arr 是变量名。

int[][] 是类型，表示 arr 可以记录 int 类型的二维数组的地址值。

[图片]

需要手动创建一维数组。

[图片]

程序示例：

public class test {
    public static void main(String[] args) {
        // 动态定义一个二维数组
        int[][] arr = new int[2][3];

        // 打印数组的初始值
        print(arr);

        System.out.println("-------------");

        // 定义两个一维数组，长度和二维数组中的一维数组长度刚好相等
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {4, 5, 6};

        // 将两个一维数组关联到二维数组中
        arr[0] = arr1;
        arr[1] = arr2;

        // 打印修改后的二维数组
        print(arr);

        System.out.println("-------------");

        // 定义两个一维数组，长度分别比二维数组中的一维数组长度短和长
        int[] arr3 = {1, 2};
        int[] arr4 = {3, 4, 5, 6};

        // 将两个一维数组关联到二维数组中
        arr[0] = arr3;
        arr[1] = arr4;

        // 打印修改后的二维数组
        print(arr);
    }

    // 打印二维数组
    private static void print(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

执行结果：

0 0 0 
0 0 0 
-------------
1 2 3 
4 5 6 
-------------
1 2 
3 4 5 6

二维数组的练习题：

// 某商城每个季度的营业额如下：单位(万元)
//         第一季度：22,66,44
//         第二季度：77,33,88
//         第三季度：25,45,65
//         第四季度：11,66,99
//         要求计算出每个季度的总营业额和全年的总营业额

public class TwoDi {
    public static void main(String[] args) {
        int[][] arr = new int[][]{
                {22, 66, 44},
                {77, 33, 88},
                {25, 45, 65},
                {11, 66, 99}
        };
        int sum = 0;
        int[] quarters = new int[4];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                quarters[i] += arr[i][j];
                sum += arr[i][j];
            }
        }
        System.out.println("各个季度的营业额：");
        for (int i = 0; i < quarters.length; i++) {
            System.out.print(quarters[i] + "  ");
        }
        System.out.println();
        System.out.println("全年的营业额：");
        System.out.println(sum);
    }
}

执行结果：

各个季度的营业额：
132  198  135  176  
全年的营业额：
641

另一种写法：

// 某商城每个季度的营业额如下：单位(万元)
//         第一季度：22,66,44
//         第二季度：77,33,88
//         第三季度：25,45,65
//         第四季度：11,66,99
//         要求计算出每个季度的总营业额和全年的总营业额

public class TwoDi {
    public static void main(String[] args) {
        int[][] arr = new int[][]{
                {22, 66, 44},
                {77, 33, 88},
                {25, 45, 65},
                {11, 66, 99}
        };

        System.out.println("各个季度的营业额：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println("第 " + (i + 1) + " 季度：" + getSumArr(arr[i]));
        }
        System.out.println("全年的营业额：" + getSumArrArr(arr));

    }

    public static int getSumArr(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

    public static int getSumArrArr(int[][] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];
            }
        }
        return sum;
    }
}

执行结果：

各个季度的营业额：
第 1 季度：132
第 2 季度：198
第 3 季度：135
第 4 季度：176
全年的营业额：641

优化之后：

// 某商城每个季度的营业额如下：单位(万元)
//         第一季度：22,66,44
//         第二季度：77,33,88
//         第三季度：25,45,65
//         第四季度：11,66,99
//         要求计算出每个季度的总营业额和全年的总营业额

public class TwoDi {
    public static void main(String[] args) {
        int[][] arr = new int[][]{
                {22, 66, 44},
                {77, 33, 88},
                {25, 45, 65},
                {11, 66, 99}
        };
        int yearSum = 0;
        System.out.println("各个季度的营业额：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println("第 " + (i + 1) + " 季度：" + getSumArr(arr[i]));
            yearSum = yearSum + getSumArr(arr[i]);
        }
        System.out.println("全年的营业额：" + yearSum);
    }

    public static int getSumArr(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
}