Java基础(10)--数组

Java基础(10)--数组

数组概述

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

• 数组是相同类型数据的有序集合
• 其中，每一个数据称为一个数组元素，每个数组元素可以通过一个下标来访问它

数组的声明与创建

声明数组变量

首先必须声明数组变量，才能在程序中使用数组。

下面是声明数组变量的语法：

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

创建数组

Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];

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

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

// 数组变量的声明，和创建数组可以用一条语句完成
dataType[] arrayRefVar = new dataType[arraySize];

// 创建数组
dataType[] arrayRefVar = {value0, value1, ..., valuek};

Example：

package array;

public class Demo01 {
    public static void main(String[] args) {
        // 声明一个数组
        int[] nums;

        // 创建一个数组
        nums = new int[10];

        // 给数组元素赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;

        System.out.println("数组元素未赋值时，值为："+ nums[6]);  // 数组中未赋值元素，值是该数据类型默认值

        // 计算和
        int sum = 0;
        for(int i = 0; i < nums.length; i++){
            sum += nums[i];
        }
        System.out.println("和为 " + sum);
    }
}

三种初始化

• 静态初始化

  int[] = {1, 2, 3};
  Man[] = {new Man(1, 1), new Man(2, 2)};
  

• 动态初始化(包含默认初始化)

  int[] a = new int[10];
  a[0] = 1;
  a[1] = 0;
  

• 默认初始化

  /**
  数组是引用类型，它的元素相当于类的实例变量，因此数组已经分配空间，其中的每个元素也被按照实例变量的方式被隐藏初始化。
  */
  

数组边界

• 下标的合法区间:[0, array.length - 1]
• 数组也是对象。数组元素相当于对象的成员变量；
• 数组的长度是确定的，不可变的。如果越界，报错ArrayIndexOutofBounds

数组使用

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

package array;

public class Demo02 {
    public static void main(String[] args) {
        int k = 0;
        double[] myList = {1.9, 2.3, 1.2, 5.4, 3.2};
        printArray(myList);
        System.out.println();

        myList = reverseArray(myList);
        printArray(myList);
        System.out.println();

        printArray(addOne(myList));
    }
    
    // 数组作为函数的参数
    public static void printArray(double[] array){
        // 打印所有元素
        for(int i = 0; i < array.length; i++){
            System.out.print(array[i] + ", ");
        }
    }
    
    // 数组作为函数的参数及返回值
    public static double[] reverseArray(double[] array){
        double[] res = new double[array.length + 1];
        for(int i = 0, j = array.length - 1; i < array.length; i++, j--){
            res[i] = array[j];
        }
        return res;
    }

    public static double[] addOne(double[] array){
        for(double element: array){
            element += 1;
            System.out.println(element);
        }
        return array;
    }
}

多维数组

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

String str[][] = new String[3][4];

多维数组的动态初始化

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

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

example

int[][] a = new int[2][[3]];

String[][] s = new String[2][];

s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

Arrays类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

• 给数组赋值：通过 fill 方法。
• 对数组排序：通过 sort 方法,按升序。
• 比较数组：通过 equals 方法比较数组中元素值是否相等。
• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

package array;

import java.util.Arrays;

public class Demo03 {
    public static void main(String[] args) {
        String[][] s = new String[2][];

        s[0] = new String[2];
        s[1] = new String[3];
        s[0][0] = "Good";
        s[0][1] = "Luck";
        s[1][0] = "to";
        s[1][1] = "you";
        s[1][2] = "!";

        System.out.println(Arrays.toString(s));
        System.out.println(Arrays.toString(s[0]));
        System.out.println(Arrays.toString(s[1]));
    }
}

稀疏数组