Java数组

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。

 

Java 数组特点

特点:

     1.数组是引用数据类型

     2.数组的长度是固定的,也就是说可以存储固定个数的数据

     3.数组中的元素的类型必须一致,也就是说数组中存储的多个数据的数据类型一致

 

声明数组变量

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayName;   // 首选的方法
 
或
 
dataType arrayName[];  // 效果相同，但不是首选方法（方便从c过渡的）

实例

下面是这两种语法的代码示例：

double[] myList;         // 首选的方法
 
或
 
double myList[];         //  效果相同，但不是首选方法

 

创建数组

Java语言使用new操作符来创建数组，语法如下：（需先声明数组再才可创建数组）

arrayName = new dataType[arraySize];

上面的语法语句做了两件事：

  • 一、使用 dataType[arraySize] 创建了一个数组。
  • 二、把新创建的数组的引用赋值给变量 arrayName。

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] arrayName = new dataType[arraySize];

另外，你还可以使用如下的方式创建数组:

dataType[] arrayName = {value0, value1, ..., valuek};

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayName.length - 1。

通常通过循环遍历来输出数组，直接输出打印数组的结果是对应的内存地址。

实例：

public class MusicDay{
    public static void main(String[] args) {
        int size = 3;   // 声明数组的长度
        double numbers[] = new double[size];    // 声明数组并创建数组

        // 通过索引来更新数组里的值
        numbers[0] = 10;
        numbers[1] = 20.7;
        numbers[2] = 30.8;

        // double numbers[] = {10, 20, 30};     第二种创建数组的方式

        // 直接输出该数组会输出对应的内存地址
        System.out.println(numbers);
        System.out.println("=================");
        
        // 通过索引遍历可输出数组中的值
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("该数组第" + i + "个值为" + numbers[i]);
        }
    }
}

输出结果为：

[D@75b84c92
=================
该数组第0个值为10.0
该数组第1个值为20.7
该数组第2个值为30.8

 

 

处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 For-Each 循环。

示例

该实例完整地展示了如何创建、初始化和操纵数组：

public class MusicDay {
    public static void main(String[] args) {
        double[] numbers = {10.7, 20.3, 52.1, 30.7};  // 声明并创建数组

        // 打印数组所有元素
        System.out.print("该数组的所有元素为：");
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + "  ");
        }
        System.out.println();

        // 计算数组所有元素的累计和
        double sum = 0;
        for (int i = 0; i < numbers.length; i++) {
            sum += numbers[i];
        }
        System.out.println("该数组所有元素和为：" + sum);

        // 查找数组中的最大元素
        double max = 0;
        for (int i = 0; i < numbers.length; i++) {
            if (max < numbers[i]){
                    max = numbers[i];
            }
        }
        System.out.println("该数组的最大值为：" + max);
    }
}

输出结果为：

该数组的所有元素为：10.7  20.3  52.1  30.7  
该数组所有元素和为：113.8
该组数组的最大值为：52.1

 

for-each 循环

JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。

语法格式如下：

for(type elementName: arrayName)
{
    System.out.println(elementName);
}

实例：

public class MusicDay {
    public static void main(String[] args) {
        double[] numbers = {10.3, 20.7, 52.1};  // 声明并创建数组

        // 使用加强循环for-each遍历数组并输出每一个值
        for (double a : numbers) {
            System.out.println(a);
        }
    }
}

输出结果：

10.3
20.7
52.1

 

数组作为函数的参数

数组可以作为参数传递给方法。

例如，下面的例子就是一个打印 int 数组中元素的方法:

public class Demo2 {
    public static void main(String[] args) {
        int[] a = {10, 20, 30};  // 声明并创建数组

        printArray(a);  // 调用方法 (将数组作为参数)
    }
    
    // 定义方法 printArray 作用是遍历打印数组所有值
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i] + "  ");
        }
    }
}

输出结果为：

10  
20  
30

 

数组作为函数的返回值

实例：(以下实例定义了反转数组的方法，并将数组作为 return 返回值)

public class MusicDay {
    public static void main(String[] args) {
        int[] a = {10, 20, 30}; // 声明并创建数组

        int[] b = reverse(a);   // 调用下方定义的reverse方法并接收返回值赋值给b

        for (int i = 0; i < b.length; i++) {    // 循环遍历输出返回的新数组b
            System.out.println(b[i]);
        }
    }

    // 定义方法reverse作用是反转数组的元素
    public static int[] reverse(int[] array){
        int[] array_2 = new int[array.length];　// 声明并创建新数组作为反转后的数组
        for (int i = 0, j = array.length - 1; i < array.length; i++, j--){
            array_2[j] = array[i];
        }
        return array_2;    // 将数组作为 return 返回值
        }
    }

输出结果为：

30
20
10

 

 

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：

// 二维数组 (最外围有3个元素，这3个元素又都是拥有4个元素的数组)
String str[][] = new String[3][4];

 

多维数组的动态初始化（以二维数组为例）

1. 直接为每一维分配空间，格式如下：

type[][] typeName = new type[typeLength1][typeLength2];

type 可以为基本数据类型和复合数据类型，arraylength1 和 arraylength2 必须为正整数，arraylength1 为行数，arraylength2 为列数。

例如：

int a[][] = new int[2][3];   // 2行3列的二位数组

声明并创建数组后，通过索引可更新数组的元素：

　　　　// 更新第一个数组中的数组元素(行)
        a[0][0] = 1;
        a[0][1] = 2;
        a[0][2] = 3;

        // 更新第二个数组中的数组元素(列)
        a[1][0] = 4;
        a[1][1] = 5;
        a[1][2] = 6;

也可使用另外一种方法声明创建多维数组：

// 可以简单理解有几对{}就为多少维数组 (以下为二维数组)
int[][] arrays = {{1, 2, 3}, {4, 5, 6}};

 

多维数组的索引（以二维数组为例）

对二维数组中的每个元素，引用方式为 arrayName[index1][index2]，例如：

num[1][0];   // 访问二维数组num中第1个数组中的第0个元素

实例：

public class MusicDay {
    public static void main(String[] args) {

        // 声明并创建二位数组(2行3列)
        int[][] arrays = new int[2][3];

        // 更新第一个数组中的数组元素(行)
        arrays[0][0] = 1;
        arrays[0][1] = 2;
        arrays[0][2] = 3;

        // 更新第二个数组中的数组元素(列)
        arrays[1][0] = 4;
        arrays[1][1] = 5;
        arrays[1][2] = 6;

    /*
        第二种声明并创建二位数组的方法
        int[][] arrays = {{1, 2, 3}, {4, 5, 6}};
    */

        printArrays(arrays);    // 调用输出二维数组所有元素的方法
    }

    // 定义 printArrays 方法作用为通过索引遍历二维数组并输出所有元素
        public static void printArrays(int[][] arrays){
            for (int i = 0; i < arrays.length; i++) {
                for (int i1 = 0; i1 < arrays[i].length; i1++) {
                    System.out.println(arrays[i][i1]);
                }
            }
        }

}

 

 

参考链接https://www.runoob.com/java/java-array.html

posted @ 2021-02-17 17:02  MieDidXiang  阅读(46)  评论(0)    收藏  举报