new String 数组 java

数组概述

数组(array)是一种容器，用来存储同种数据类型的多个值，例如使用数组统计一个班级所有学生的平均分。
相对变量来存储单个数据而言，数组可以存取多个数据，不过操作的数据必须是同一个数据类型。例如数组元素的类型如果是int，那么就不能存double类型的数据，因此数组元素的类型和存储的数据类型保持一致。
数组的应用场景就是如果操作一组相同数据类型的数据就可以考虑使用数组存储。

数组的定义和初始化

数组的定义

当使用数组前必须定义，数组定义的语法格式是 数据类型[] 数组名，例如int[] array,还有一种兼容C语言风格的数组定义格式:数据类型 数组名[]，不过Java程序员通常都使用数据类型[] 数组名这种方式来定义数组。

package net.ittimeline.java.core.jdk.foundational.array;/** * 数组定义 * * @author tony [e-mail] * @version 2020/12/10 8:47 * @since JDK11 */public class ArrayDefinition {  public static void main(String[] args) {    /*         数组的定义格式: 数据类型[]  数组名    */    // 定义一个int类型的数组变量 此时数组容器还没有创建出来，数组不能使用    int[] intArray;    // 定义一个char类型的数组    char[] charArray;    // charArray没有初始化 不能使用    // System.out.println(charArray);    // 变量在定义是未初始化时不能使用，数组也一样    int number;    // System.out.println(number);  }}

不过需要注意的是数组定义后如果尚未初始化是不能使用的，因为变量尚未初始化时不能使用，此时定义的数组本质也是变量，只是其数据类型是数组而已。

数组的初始化

Java中的数组必须先初始化后才能使用，所谓的初始化就是在内存中为数组容器开辟内存空间，并将数据存入容器的过程
数组初始化的方式有动态初始化和静态初始化两种方式。
动态初始化就是初始时指定数组的长度，由系统分配数组分配初始值。
数组动态初始化的格式:数据类型[] 数组名 = new 数据类型[数组长度]; ，例如int[] 数组名=new int[5];

package net.ittimeline.java.core.jdk.foundational.array;/** * 数组的动态初始化 * * @author tony [e-mail] * @version 2020/12/10 8:53 * @since JDK11 */public class ArrayDynamicInit {  public static void main(String[] args) {    //动态初始化一个int数组，数组的长度是5    //通过new关键字创建一个int类型的数组容器，该容器可以存储5个整数，该容器被intArray数组变量所记录    int[]intArray=new int[5];    //打印数组变量时会打印数组的内存地址 内存地址由系统随机分配，每次打印的结果可能不一样    //intArray = [I@2f7a2457    //@表示分隔符    //[表示当前空间是一个数组类型    //2f7a2457 表示一个十六进制的内存地址    System.out.println("intArray = "+intArray);    //通过new关键字创建一个char类型的数组容器，该容器可以存储8个字符，该容器被charArray数组变量所记录    char[]charArray=new char[8];    //打印数组变量时会打印数组的内存地址    //charArray = [C@6108b2d7    //@表示分隔符    //[表示当前空间是一个数组类型    //6108b2d7 表示一个十六进制的内存地址    System.out.println("charArray = "+charArray);  }}

程序运行结果

当动态初始化数组后，如果打印输出数组名，会得到数组的内存地址，例如[I@2f7a2457，其中[表示当前空间是一个数组类型，@表示分隔符，2f7a2457表示十六进制的地址，该地址由系统随机分配，每次打印的地址值可能不一样。

数组元素访问

数组动态初始化后就需要对数据进行存取操作，也就是对数组元素的访问。
通过数组名就可以获取数组的内存地址,不过Java没有C语言的指针操作，因此开发人员更多关注的通过数组名[索引]的方式来访问数组的元素。
数组中的元素都是有编号的，类似于每个公司的员工都有工号一样，不过数组的编号叫做索引(index)，索引是从0开始的，而且是连续的，每次自增1,通过索引就可以访问数组容器中元素的位置。

package net.ittimeline.java.core.jdk.foundational.array;/** * 数组元素的访问 * * @author tony [e-mail] * @version 2020/12/10 9:11 * @since JDK11 */public class ArrayAssignment {  public static void main(String[] args) {    //定义int数组    int[] intArray;    //动态初始化一个int数组    //此时系统会给数组中每个元素赋初始值0    intArray=new int[5];    System.out.println("intArray数组的堆内存地址是"+intArray);    System.out.println("intArray数组动态初始化后");    // 通过数组名[索引]访问数组的元素    //访问数组中索引为0的元素的值    // intArray[0] = 0 由系统默认分配的初始值    System.out.println("intArray[0] = "+intArray[0]);    //访问数组中索引为1的元素值    System.out.println("intArray[1] = "+intArray[1]);    //访问数组中索引为2的元素值    System.out.println("intArray[2] = "+intArray[2]);    //访问数组中索引为3的元素值    System.out.println("intArray[3] = "+intArray[3]);    //访问数组中索引为4的元素值    System.out.println("intArray[4] = "+intArray[4]);    //给数组的元素赋值    intArray[0]=10;    intArray[1]=20;    intArray[2]=30;    intArray[3]=40;    intArray[4]=50;    System.out.println("intArray数组元素赋值后");    // intArray[0] = 0 由系统默认分配的初始值    System.out.println("intArray[0] = "+intArray[0]);    //访问数组中索引为1的元素值    System.out.println("intArray[1] = "+intArray[1]);    //访问数组中索引为2的元素值    System.out.println("intArray[2] = "+intArray[2]);    //访问数组中索引为3的元素值    System.out.println("intArray[3] = "+intArray[3]);    //访问数组中索引为4的元素值    System.out.println("intArray[4] = "+intArray[4]);  }}

程序运行结果

当数组动态初始化后，系统会给数组的每个元素赋相应的初始值。例如int数组默认初始值就是0，double数组默认初始值就是0.0。
不过日常业务开发中初始值没有任意意义，通常都是通过数组名[索引]的方式去修改数组元素的值。

数组静态初始化

数组静态初始化就是初始化时指定数组存储的数据，系统会根据存储的数据个数来计算数组的长度。

• 数组静态初始化的完整格式:数据类型 数组名[] =new 数据类型[]{数据1,数据2，数据3};,例如int []array =new int[]{10,20,30};
• 数组静态初始化的简化格式:数据类型 数组名[] ={数据1,数据2，数据3};,例如int []array ={10,20,30};

package net.ittimeline.java.core.jdk.foundational.array;/** * 数组静态初始化 * * @author tony [e-mail] * @version 2020/12/10 10:50 * @since JDK11 */public class ArrayStaticInit {  public static void main(String[] args) {    // 数组静态初始化的完整方式    int[] full = new int[] {10, 20, 30};    System.out.println("full[0] = " + full[0]);    System.out.println("full[1] = " + full[1]);    System.out.println("full[2] = " + full[2]);    //简化格式没有使用new关键字 ,简化了new int[]    int[] simple = {10, 20, 30};    //依然有内存地址    System.out.println("simple的内存地址是"+simple);    System.out.println("simple[0] = " + simple[0]);    System.out.println("simple[1] = " + simple[1]);    System.out.println("simple[2] = " + simple[2]);  }}

程序运行结果

数组静态初始化的简化方式只是简化了new int[]而已，虽然没有new关键字但是依然会到堆内存中开辟空间。

数组的动态初始化和静态初始化的对比

• 动态初始化是手动指定数组的长度，由系统默认指定初始化的默认值，因此动态初始化用于明确元素个数，但是不明确具体的数值，例如键盘录入的应用场景就推荐使用动态初始化
• 静态初始化是手动指定数组的元素 ，系统会根据元素的个数来计算数组的长度。怎么计算勒，就是通过数组的字节大小除以数组的每个元素大小。静态初始化用于已经明确操作的具体数据，例如使用数组存储学生成绩。

Java数组内存机制

程序运行时，需要在内存分配对应的空间，为了提高计算效率，需要对内存空间进行不同区域的划分，每一片内存区域都有特定的处理数据方式和内存管理方式。

Java的内存区域分为如下五个区域

• 栈内存:方法和局部变量所在的内存区域，例如main方法和之前在main方法定义的变量都是变量
• 堆内存:new出来的内容(也就是创建的对象)都会进入堆内存，而且系统会分配地址值
• 方法区:字节码文件(例如HelloWorld.class)j加载时进入方法区
• 本地方法栈:调用操作系统相关资源
• 寄存器:交给CPU去执行。

Java程序员更多的时关注栈内存、堆内存以及方法区。

Java数组在内存中的结构

1. ArrayAssignment.class加载到方法区中，主方法存放在ArrayAssignment.class字节码中。
2. main方法会被JVM自动调用并进入栈内存执行
3. int[] intArray; 数组变量在main方法中声明
4. intArray=new int[3]; 通过new关键字在堆内存中开辟空间，并返回地址值，因为动态初始数组的长度是3，所以会划分出连续3块空间，每块占据4个字节大小，并且每块空间的初始值都是0，将堆内存的数组的地址赋值给main方法的intArray变量，通过intArray变量就可以获取数组的堆内存地址。
5. System.out.println("intArray[0] = "+intArray[0]); 通过地址找到堆内存的空间，通过索引找到空间的位置并打印输出内容
6. intArray[0]=10;通过地址找空间，索引找位置，并将位置的内容赋值为10
7. System.out.println("intArray[0] = "+intArray[0]);通过地址找空间，索引找位置，并将更新之后的值打印输出

当程序中出现多个数组时

package net.ittimeline.java.core.jdk.foundational.array;/** * 多个数组的内存结构 * * @author tony [e-mail] * @version 2020/12/10 10:14 * @since JDK11 */public class ArrayMulti {  public static void main(String[] args) {    int[] intArray = new int[3];    intArray[0] = 10;    intArray[1] = 20;    intArray[2] = 30;    System.out.println("intArray的堆内存地址是"+intArray);    System.out.println("intArray[0] = " + intArray[0]);    System.out.println("intArray[1] = " + intArray[1]);    System.out.println("intArray[2] = " + intArray[2]);    char[] charArray = new char[3];    charArray[0] = 'a';    charArray[1] = 'b';    charArray[2] = 'c';    System.out.println("charArray的堆内存地址是"+charArray);    System.out.println("charArray[0] = " + charArray[0]);    System.out.println("charArray[1] = " + charArray[1]);    System.out.println("charArray[2] = " + charArray[2]);  }}

程序运行结果

内存结构如下

当程序中两个数组同时指向一块内存空间

package net.ittimeline.java.core.jdk.foundational.array;/** * 多个数组指向同一块内存空间 * * @author tony [e-mail] * @version 2020/12/10 10:30 * @since JDK11 */public class ArrayTheSame {  public static void main(String[] args) {      int[] sourceArray = new int[3];      sourceArray[0] = 10;      sourceArray[1] = 20;      sourceArray[2] = 30;      System.out.println("sourceArray的堆内存地址是"+sourceArray);      System.out.println("sourceArray[0] = " + sourceArray[0]);      System.out.println("sourceArray[1] = " + sourceArray[1]);      System.out.println("sourceArray[2] = " + sourceArray[2]);      //将sourceArray的地址赋值给targetArray      int[] targetArray=sourceArray;      System.out.println("targetArray的堆内存地址是"+targetArray);      System.out.println("targetArray[0] = " + targetArray[0]);      System.out.println("targetArray[1] = " + targetArray[1]);      System.out.println("targetArray[2] = " + targetArray[2]);  }}

程序运行结果

内存结构如下

数组使用常见问题

• 数组越界
  数组越界就是访问了数组中不存在的索引，造成索引越界的问题，需要注意的是数组的索引是从0开始，最大的索引是数组的长度减1

package net.ittimeline.java.core.jdk.foundational.array.exception;/** * 数组索引越界 * * @author tony [e-mail] * @version 2020/12/10 11:01 * @since JDK11 */public class ArrayIndexOutOfBounds {  public static void main(String[] args) {      int[] array={1,2,3};    System.out.println("array[3] = "+array[3]);  }}

程序运行结果

• 数组空指针异常
  数组空指针表示此时数组变量的值是null,即此时栈内存的数组变量没有指向堆内存的数组内容，这样访问数组的元素时会引发ArrayNullPointer异常

package net.ittimeline.java.core.jdk.foundational.array.exception;/** * 数组空指针 * * @author tony [e-mail] * @version 2020/12/10 11:04 * @since JDK11 */public class ArrayNullPointer {  public static void main(String[] args) {    //此时array没有指向堆内存的数组    int[] array=null;    //此时会出现空指针异常    System.out.println(array[0]);  }}

程序运行结果

在日常开发中使用数组或者ArrayList类都要避免数组越界以及ArrayNullPointer空指针异常

数组常见的操作

数组的遍历

数组的遍历相比通过数组名[下标] 一个一个访问数组的元素代码更加简洁。
数组的遍历就是通过for循环实现访问数组的元素，然后进行相应的操作，其中数组的长度可以通过数组名.length动态获取。

package net.ittimeline.java.core.jdk.foundational.array.operator;/** * 数组的遍历 * * @author tony [e-mail] * @version 2020/12/10 11:13 * @since JDK11 */public class ArrayIterator {  public static void main(String[] args) {    //      int[] intDataArray={1,2,3,4,5};    System.out.println("没有使用遍历之前获取数组的元素列表");    System.out.println("intDataArray[0] = "+intDataArray[0]);    System.out.println("intDataArray[1] = "+intDataArray[1]);    System.out.println("intDataArray[2] = "+intDataArray[2]);    System.out.println("intDataArray[3] = "+intDataArray[3]);    System.out.println("intDataArray[4] = "+intDataArray[4]);    // 使用循环获取数组的元素    System.out.println("使用循环获取数组的元素");    // intDataArray.length表示intDataArray数组的长度    System.out.println("intDataArray.length = "+intDataArray.length);    for (int i = 0; i

程序运行结果

数组获取最值

获取数组的最大值和最小值

实现思路:

1. 静态初始化化一个无序的整数数组
2. 定义两个变量，用于保存最大值和最小值，并且赋初始值为数组的第一个元素
3. 遍历数组
4. 如果数组的元素比max大，将数组的元素赋值给max
5. 如果数组的元素比min小，将数组的元素赋值给min

package net.ittimeline.java.core.jdk.foundational.array.operator;/** * 数组获取最大值最小值 * * @author tony [e-mail] * @version 2020/12/10 11:23 * @since JDK11 */public class ArrayMaxMinValue {  public static void main(String[] args) {    //静态初始化一个数组    int[] intArray={10,20,50,30,40,100,2};    System.out.println("遍历静态初始化数组intArray");    for (int i = 0; i max){        //把值赋值给max        max=intArray[i];      }      //如果数组元素比min小      if(intArray[i]

程序运行结果

数组元素求和

使用数组存储从键盘读取用户输入的5个整数，并统计数组元素的和

package net.ittimeline.java.core.jdk.foundational.array.operator;import java.util.Scanner;/** * 数组元素求和 * * @author tony [e-mail] * @version 2020/12/10 11:41 * @since JDK11 */public class ArrayElementsSum {  public static void main(String[] args) {    Scanner input = new Scanner(System.in);    int length =5;    int[] intArray=new int[length];    for (int i = 0; i

程序运行结果

这里提一下IDEA的自动导包功能设置
默认情况下IDEA是不会自动导入类所在的包的，需要进行相关设置

还有个快捷键就是输入fori可以快速生成for循环

for (int i = 0; i < ; i++) {          }

数组元素的查找

package net.ittimeline.java.core.jdk.foundational.array.operator;/** * 查找数组的元素索引 * * @author tony [e-mail] * @version 2020/12/10 11:51 * @since JDK11 */public class ArrayIndexSearch {  public static void main(String[] args) {    // 初始化一个静态数组    int[] data = {10, -20, 30, -40};    int target = -20;    // 遍历数组的元素    for (int i = 0; i < data.length; i++) {      // 拿数组的元素和目标元素进行比较      if (target == data[i]) {        System.out.printf("%d在数组的元素位置是%d",target,i);break;      }    }  }}

程序运行结果

数组案例: 假设有场比赛，六个人的分数分别是70, 80, 100, 60, 85, 98。
要求去掉一个最高分和一个最低分后计算其他四个人的平均分。

package net.ittimeline.java.core.jdk.foundational.array.operator;/** *  有六个人参加比赛，去掉一个最高分和一个最低分，求四个人的平均分 * * @author tony [e-mail] * @version 2020/12/10 12:02 * @since JDK11 */public class ArrayAvg {  public static void main(String[] args) {    // 静态初始化一个数组保存6个人的分数    int[] scores = {70, 80, 100, 60, 85, 98};    System.out.println("遍历静态初始化的成绩分数数组");    for (int i = 0; i  highest) {        highest = scores[i];      }      if (scores[i] < lowest) {        lowest = scores[i];      }    }    System.out.printf("数组的最高分是%d,最低分是%d", highest, lowest);    // 去掉最高分和最低分后计算总分    int sum = 0;    for (int i = 0; i < scores.length; i++) {      if (scores[i] != highest || scores[i] != lowest) {        sum += scores[i];      }    }    // 根据总分人数计算平均分    int avg = sum / 4;    System.out.println("数组去掉最高分和最低分后的平均分是" + avg);  }}

程序运行结果

数组元素反转

假设有个数组的元素列表值是1,2,3,4,5，要求不使用新的数组将其反转为5,4,3,2,1

实现思路

1. 获取数组的开始索引和结束索引
2. 循环开始索引的数组元素和结束索引元素，循环的条件是开始索引小于结束索引
3. 在循环内使用临时变量交换开始索引的元素和结束索引对应的元素
4. 在循环内开始索引自增，结束索引自减

package net.ittimeline.java.core.jdk.foundational.array.operator;/** * 数组元素的反转 * * @author tony [e-mail] * @version 2020/12/10 12:18 * @since JDK11 */public class ArrayInversion {  public static void main(String[] args) {    // 静态初始化一个数组    int[] intDataArray = {1, 2, 3, 4, 5};    System.out.println("数组元素反转之前");    int maxIndex = intDataArray.length - 1;    for (int i = 0; i < intDataArray.length; i++) {      System.out.print(intDataArray[i] + "");      if (i == maxIndex) {        System.out.println();      }    }    System.out.println("数组元素反转之后");    //开始索引    int startIndex = 0;    //结束索引    int endIndex = intDataArray.length-1;    while (startIndex < endIndex) {      //交换两个数组元素的位置      int temp = intDataArray[startIndex];      intDataArray[startIndex] = intDataArray[endIndex];      intDataArray[endIndex] = temp;      //改变索引      startIndex++;      endIndex--;    }    for (int i = 0; i < intDataArray.length; i++) {      System.out.print(intDataArray[i] + "");      if (i == maxIndex) {        System.out.println();      }    }  }}

程序运行结果

数组元素排序

冒泡排序(Bubble Sort)，是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序(如从大到小、首字母从Z到A)错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列)，就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

冒泡排序算法的原理如下：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

package net.ittimeline.java.core.jdk.foundational.array.operator;/** * 数组冒泡排序 * * @author tony [e-mail] * @version 2020/12/10 12:33 * @since JDK11 */public class ArrayBubbleSort {  public static void main(String[] args) {    // 静态初始化一个数组    int[] data = {1, 2, 4, 5, 7, 8, 9, 6, 3};    int maxIndex = data.length - 1;    System.out.println("【未进行排序之前】遍历静态初始化数组的元素");    for (int i = 0; i < data.length; i++) {      System.out.print(data[i] + "");      if (i == maxIndex) {        System.out.println();      }    }    //排序的次数    int count=data.length-1;    for (int i = 0; i < count; i++) {      //每次比较      for (int j = 0; j

程序运行结果

二维数组的定义和初始化

之前使用的数组都是一维数组。

二维数组的定义

二维数组也是一种容器，二维数组的元素存储的是一维数组。
二维数组的典型应用场景是假设一个高中学校，高三有四个班级，如果需要统计高三所有班级的成绩，就需要使用二维数组。

二维数组的定义语法:数据类型[][] 数组名; ，例如int [][]data;

package net.ittimeline.java.core.jdk.foundational.array;/** * 二维数组的定义 * * @author tony [e-mail] * @version 2020/12/10 13:56 * @since JDK11 */public class ArrayArrayDefinition {  public static void main(String[] args) {      //定义一个int型的二维数组   int[][] intData;   //定义一个字符型的二维数组    char[][] charData;  }}

二维数组的动态初始化和元素访问

二维数组动态初始化格式:数据类型[][] 数组名 =new 数据类型[m][n];

package net.ittimeline.java.core.jdk.foundational.array;/** * 二维数组动态初始化和赋值 * * @author tony [e-mail] * @version 2020/12/10 13:58 * @since JDK11 */public class ArrayArrayDynamicInitAssignment {  public static void main(String[] args) {    // 动态初始化二维数组    //初始化一个int二维数组，存放2个一维数组，每个一维数组有3个int元素    int[][] data = new int[2][3];    /*      [[I@2f7a2457      [[ :几个[表示几维数组，这里表示二维数组      @表示分隔符      2f7a2457 表示二维数组的十六进制地址     */    System.out.println("二维数组的内存地址是"+data);    //二维数组存储的是一维数组的内存地址    System.out.println("data[0] = "+data[0]);    System.out.println("data[1] = "+data[1]);    //访问二维数组的元素    System.out.println("动态初始化后访问二维数组");    System.out.println("data[0][0] = "+data[0][0]);    System.out.println("data[0][1] = "+data[0][1]);    System.out.println("data[1][0] = "+data[1][0]);    System.out.println("data[1][1] = "+data[1][1]);    //给二维数组的元素赋值    data[0][0]=1;    data[0][1]=1;    data[0][2]=1;    data[1][0]=2;    data[1][1]=2;    data[1][2]=2;    // 赋值之后访问二维数组    System.out.println("赋值之后访问二维数组");    System.out.println("data[0][0] = "+data[0][0]);    System.out.println("data[0][1] = "+data[0][1]);    System.out.println("data[1][0] = "+data[1][0]);    System.out.println("data[1][1] = "+data[1][1]);  }}

程序运行结果

二维数组动态初始化时可以将一个提前初始化好的一维数组赋值给二维数组的元素

package net.ittimeline.java.core.jdk.foundational.array;/** * 二维数组的赋值访问的问题 * * @author tony [e-mail] * @version 2020/12/10 14:54 * @since JDK11 */public class ArrayArrayAssignment {  public static void main(String[] args) {    //初始化三个一维数组    int[]first={11,22,33};    int[]second={44,55,66};    int[]third={77,88,99,100};    //动态初始化一个二维数组    //二维数组限制了一维数组只能存储3个元素    int[][]data=new int[3][3];    //将第一个一维数组地址赋值给二维数组的第一个元素    data[0]=first;    data[1]=second;    data[2]=third;    System.out.println("data[1][2] = "+data[1][2]);    //此时访问的是data数组第3个元素指向的一维数组的第4个元素的值 即等价于third[3]    System.out.println("data[2][3] = "+data[2][3]);    System.out.println("third[3] = "+third[3]);  }}

程序运行结果

二维数组的静态初始化和元素访问

二维数组静态初始化有两种格式
二维数组的静态初始化完整格式:数据类型[][] 数组名 =new 数据类型[][]{{元素1，元素2},{元素3，元素4},{元素5，元素6}};，例如int[][] data=new int[][]{{1,2},{3，4},{5,6};
二维数组的静态初始化简化格式:数据类型[][] 数组名 ={{元素1，元素2},{元素3，元素4},{元素5，元素6}};，例如int[][] data=={{1,2},{3，4},{5,6};

package net.ittimeline.java.core.jdk.foundational.array;/** * 二维数组静态初始化 * * @author tony [e-mail] * @version 2020/12/10 14:13 * @since JDK11 */public class ArrayArrayStaticInit {  public static void main(String[] args) {    //完整格式静态初始化二维数组    int[][] full=new int[][]{{1,2},{3,4}};    int[][] simple={{1,2},{3,4}};    System.out.println("full[1][1] = "+full[1][1]);    System.out.println("simple[1][1] = "+simple[1][1]);    //先创建一维数组    int[]data={1,2};    int[] intArray={3,4};    //将一维数组赋值给二维数组    int[][]allData={data,intArray};    System.out.println("allData[1][1] = "+allData[1][1]);  }}

程序运行结果

二维数组的常见操作

二维数组的遍历

假设三个班级有三个学生，一班的数学成绩是80,90,100 ,二班的数学成绩是85，90，88，三班的数学成绩是75，90，99，使用二维数组静态初始化，并遍历二维数组的元素，每行显示3个。

package net.ittimeline.java.core.jdk.foundational.array.operator;/** * 二维数组的遍历 * * @author tony [e-mail] * @version 2020/12/10 14:32 * @since JDK11 */public class ArrayArrayIterator {  public static void main(String[] args) {    //静态初始化三个一维数组    //使用三个一维数组存储三个班级的成绩    int[] class1=new int[]{80,90,100};    int[] class2=new int[]{85,90,88};    int[] class3=new int[]{75,90,99};    int[][]data={class1,class2,class3};    int maxLength=data[0].length-1;    for (int i = 0; i < data.length;i ++) {      for (int j = 0; j < data[i].length; j++) {        System.out.print(data[i][j]+"");        if(j==maxLength){          System.out.println();        }      }    }  }}

程序运行结果

二维数组求和

使用一维数组保存每个季度的销售金额，求全年的销售金额。

package net.ittimeline.java.core.jdk.foundational.array.operator;/** * 二维数组求和 * * @author tony [e-mail] * @version 2020/12/10 14:41 * @since JDK11 */public class ArrayArraySum {  public static void main(String[] args) {      //静态初始化每个季度的销售额      // 下划线只是为了更加方便阅读，不会影响计算结果      int[] first={100_0000,200_0000,300_0000};      int[] second={100_0000,200_0000,300_0000};      int[] third={100_0000,200_0000,300_0000};      int[] fourth={100_0000,200_0000,300_0000};      //使用二维数组存储每个季度的销售金额      int[][] fullYearSales={first,second,third,fourth};      int sum=0;    for (int i = 0; i < fullYearSales.length; i++) {      for (int j = 0; j < fullYearSales[i].length; j++) {            sum+=fullYearSales[i][j];      }    }    System.out.println("今年的销售金额是"+sum);  }}

程序运行结果