数组类型

62次阅读

共计 2796 个字符，预计需要花费 7 分钟才能阅读完成。

如果我们有一组类型相同的变量，例如，5 位同学的成绩，可以这么写：

public class Main {public static void main(String[] args) {// 5 位同学的成绩:
        int n1 = 68;
        int n2 = 79;
        int n3 = 91;
        int n4 = 85;
        int n5 = 62;
    }
}

但其实没有必要定义 5 个 int 变量。可以使用数组来表示“一组”int类型。代码如下：

// 数组
public class Main {public static void main(String[] args) {// 5 位同学的成绩:
        int[] ns = new int[5];
        ns[0] = 68;
        ns[1] = 79;
        ns[2] = 91;
        ns[3] = 85;
        ns[4] = 62;
    }
}

定义一个数组类型的变量，使用数组类型“类型 []”，例如，int[]。和单个基本类型变量不同，数组变量初始化必须使用new int[5] 表示创建一个可容纳 5 个 int 元素的数组。

Java 的数组有几个特点：

数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false；
数组一旦创建后，大小就不可改变。

要访问数组中的某一个元素，需要使用索引。数组索引从 0 开始，例如，5 个元素的数组，索引范围是0~4。

可以修改数组中的某一个元素，使用赋值语句，例如，ns[1] = 79;。

可以用 数组变量.length获取数组大小：

// 数组
public class Main {public static void main(String[] args) {// 5 位同学的成绩:
        int[] ns = new int[5];
        System.out.println(ns.length); // 5
    }
}

数组是引用类型，在使用索引访问数组元素时，如果索引超出范围，运行时将报错：

// 数组
public class Main {public static void main(String[] args) {// 5 位同学的成绩:
        int[] ns = new int[5];
        int n = 5;
        System.out.println(ns[n]); // 索引 n 不能超出范围
    }
}

也可以在定义数组时直接指定初始化的元素，这样就不必写出数组大小，而是由编译器自动推算数组大小。例如：

// 数组
public class Main {public static void main(String[] args) {// 5 位同学的成绩:
        int[] ns = new int[] { 68, 79, 91, 85, 62 };
        System.out.println(ns.length); // 编译器自动推算数组大小为 5 
    }
}

还可以进一步简写为：

int[] ns = { 68, 79, 91, 85, 62 };

注意数组是引用类型，并且数组大小不可变。我们观察下面的代码：

// 数组
public class Main {public static void main(String[] args) {// 5 位同学的成绩:
        int[] ns;
        ns = new int[] { 68, 79, 91, 85, 62 };
        System.out.println(ns.length); // 5
        ns = new int[] { 1, 2, 3 };
        System.out.println(ns.length); // 3
    }
}

数组大小变了吗？看上去好像是变了，但其实根本没变。

对于数组 ns 来说，执行 ns = new int[] { 68, 79, 91, 85, 62}; 时，它指向一个 5 个元素的数组：

     ns
      │
      ▼
┌───┬───┬───┬───┬───┬───┬───┐
│   │68 │79 │91 │85 │62 │   │
└───┴───┴───┴───┴───┴───┴───┘

执行 ns = new int[] { 1, 2, 3}; 时，它指向一个新的 3 个元素的数组：

     ns ──────────────────────┐
                              │
                              ▼
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│   │68 │79 │91 │85 │62 │   │ 1 │ 2 │ 3 │   │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘

但是，原有的 5 个元素的数组并没有改变，只是无法通过变量 ns 引用到它们而已。

如果数组元素不是基本类型，而是一个引用类型，那么，修改数组元素会有哪些不同？

字符串是引用类型，因此我们先定义一个字符串数组：

String[] names = {"ABC", "XYZ", "zoo"
};

对于 String[] 类型的数组变量names，它实际上包含 3 个元素，但每个元素都指向某个字符串对象：

          ┌─────────────────────────┐
    names │   ┌─────────────────────┼───────────┐
      │   │   │                     │           │
      ▼   │   │                     ▼           ▼
┌───┬───┬─┴─┬─┴─┬───┬───────┬───┬───────┬───┬───────┬───┐
│   │░░░│░░░│░░░│   │ "ABC" │   │ "XYZ" │   │ "zoo" │   │
└───┴─┬─┴───┴───┴───┴───────┴───┴───────┴───┴───────┴───┘
      │                 ▲
      └─────────────────┘

对 names[1] 进行赋值，例如names[1] = "cat";，效果如下：

          ┌─────────────────────────────────────────────────┐
    names │   ┌─────────────────────────────────┐           │
      │   │   │                                 │           │
      ▼   │   │                                 ▼           ▼
┌───┬───┬─┴─┬─┴─┬───┬───────┬───┬───────┬───┬───────┬───┬───────┬───┐
│   │░░░│░░░│░░░│   │ "ABC" │   │ "XYZ" │   │ "zoo" │   │ "cat" │   │
└───┴─┬─┴───┴───┴───┴───────┴───┴───────┴───┴───────┴───┴───────┴───┘
      │                 ▲
      └─────────────────┘

这里注意到原来 names[1] 指向的字符串 "XYZ" 并没有改变，仅仅是将 names[1] 的引用从指向 "XYZ" 改成了指向 "cat"，其结果是字符串"XYZ" 再也无法通过 names[1] 访问到了。

对“指向”有了更深入的理解后，试解释如下代码：

// 数组
public class Main {public static void main(String[] args) {String[] names = {"ABC", "XYZ", "zoo"};
        String s = names[1];
        names[1] = "cat";
        System.out.println(s); // s 是 "XYZ" 还是 "cat"?
    }
}