文章目录
第二十一章 数组
1. 数组特性
将数组和其他类型的集合区分开来的原因有三：效率，类型，保存基本数据类型的能力。在 Java 中，使用数组存储和随机访问对象引用序列是非常高效的。数组是简单的线性序列，这使得对元素的访问变得非常快。然而这种高速也是有代价的，代价就是数组对象的大小是固定的，且在该数组的生存期内不能更改。
Java 提供了 Arrays.toString() 来将数组转换为可读字符串，然后可以在控制台上显示。
2. 一等对象
数组是保存指向其他对象的引用的对象，数组可以隐式地创建，也可以显式地创建，比如使用一个 new 表达式。数组对象的一部分（事实上，你唯一可以使用的方法）就是只读的 length 成员函数，它能告诉你数组对象中可以存储多少元素。[ ] 语法是你访问数组对象的唯一方式。
对象数组存储的是对象的引用，而基元数组则直接存储基本数据类型的值。
package arrays;
import java.util.Arrays;
class BerylliumSphere {
private static long counter;
private final long id = counter++;
@Override
public String toString() {
return "Sphere " + id;
}
}
public class ArrayOptions {
static <T> void show(String info, T[] array) {
System.out.println(info + ":" + Arrays.toString(array));
}
public static void main(String[] args) {
BerylliumSphere[] a;
// 数组 a 是一个未初始化的本地变量，编译器不会允许你使用这个引用直到你正确地对其进行初始化。
// show("a",a);
BerylliumSphere[] b = new BerylliumSphere[5];
// 数组 b 被初始化，自动初始化为 null
// 数值类型初始化为 0，char 型初始化为 (char)0，
// 布尔类型初始化为 false。
show("b", b);
// 数组 c 展示了创建数组对象后给数组中各元素分配 BerylliumSphere 对象。
BerylliumSphere[] c = new BerylliumSphere[4];
for (int i = 0; i < c.length; i++) {
if (c[i] == null) {
c[i] = new BerylliumSphere();
}
}
// 数组 d 展示了创建数组对象的聚合初始化语法（隐式地使用 new 在堆中创建对象）
BerylliumSphere[] d = {
new BerylliumSphere(),
new BerylliumSphere(),
new BerylliumSphere()
};
// 动态聚合初始化
a = new BerylliumSphere[]{
new BerylliumSphere(), new BerylliumSphere(),
};
System.out.println("a.length = " + a.length);
System.out.println("b.length = " + b.length);
System.out.println("c.length = " + c.length);
System.out.println("d.length = " + d.length);
a = d;
System.out.println("a.length = " + a.length);
int[] e;
int[] f = new int[5];
System.out.println("f" + ":" + Arrays.toString(f));
int[] g = new int[4];
for (int i = 0; i < g.length; i++)
g[i] = i * i;
int[] h = {11, 47, 93};
System.out.println("f.length = " + f.length);
System.out.println("g.length = " + g.length);
System.out.println("h.length = " + h.length);
e = h;
System.out.println("h-修改前：" + Arrays.toString(h));
System.out.println("e-修改前：" + Arrays.toString(e));
h[1] = 33;
System.out.println("h-修改后：" + Arrays.toString(h));
System.out.println("e-修改后：" + Arrays.toString(e));
System.out.println("e.length = " + e.length);
e = new int[]{1, 2};
System.out.println("e.length = " + e.length);
}
}
输出：
b:[null, null, null, null, null]
a.length = 2
b.length = 5
c.length = 4
d.length = 3
a.length = 3
f:[0, 0, 0, 0, 0]
f.length = 5
g.length = 4
h.length = 3
h-修改前：[11, 47, 93]
e-修改前：[11, 47, 93]
h-修改后：[11, 33, 93]
e-修改后：[11, 33, 93]
e.length = 3
e.length = 2
3. 返回数组
而在 Java 中，你只需返回数组，你永远不用为数组担心，只要你需要它，它就可用，垃圾收集器会在你用完后把它清理干净。
4. 多维数组
要创建多维的基元数组，你要用大括号来界定数组中的向量：
package arrays;
import java.util.Arrays;
public class MultidimensionalPrimitiveArray {
public static void main(String[] args) {
int[][] a = {
// 每个嵌套的大括号都代表了数组的一个维度
{ 1, 2, 3, },
{ 4, 5, 6, },
};
System.out.println(Arrays.deepToString(a));
}
}
可以使用 new 分配数组。这是一个使用 new 表达式分配的三维数组：
package arrays;
import java.util.Arrays;
public class ThreeDWithNew {
public static void main(String[] args) {
int[][][] a = new int[2][2][4];
System.out.println(Arrays.deepToString(a));
}
}
输出：
[[[0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0]]]
5. 泛型数组
一般来说，数组和泛型并不能很好的结合。你不能实例化参数化类型的数组：
Peel<Banana>[] peels = new Peel<Banana>[10]; // Illegal
类型擦除需要删除参数类型信息，而且数组必须知道它们所保存的确切类型，以强制保证类型安全。
但是，可以参数化数组本身的类型：
package arrays;
class ClassParameter<T> {
public T[] f(T[] arg) {
return arg;
}
}
class MethodParameter {
public static <T> T[] f(T[] arg) {
return arg;
}
}
public class ParameterizedArrayType {
public static void main(String[] args) {
Integer[] ints = {1, 2, 3, 4, 5};
Double[] doubles = {1.1, 2.2, 3.3, 4.4, 5.5};
Integer[] ints2 =
new ClassParameter<Integer>().f(ints);
Double[] doubles2 =
new ClassParameter<Double>().f(doubles);
ints2 = MethodParameter.f(ints);
doubles2 = MethodParameter.f(doubles);
}
}
比起使用参数化类，使用参数化方法很方便。
6. Arrays的fill方法
Java 标准库 Arrays 类包括一个普通的 fill() 方法，该方法将单个值复制到整个数组，或者在对象数组的情况下，将相同的引用复制到整个数组：
package arrays;
import java.util.Arrays;
public class FillingArrays {
static <T> void show(String info, T[] array) {
System.out.println(info + ":" + Arrays.toString(array));
}
public static void main(String[] args) {
int size = 6;
String[] a1 = new String[size];
Arrays.fill(a1, "Hello");
show("a1", a1);
Arrays.fill(a1,1,3,"World");
show("a1", a1);
}
}
输出：
a1:[Hello, Hello, Hello, Hello, Hello, Hello]
a1:[Hello, World, World, Hello, Hello, Hello]
7. Arrays的setAll方法
它的作用是根据给定的数组索引，使用指定的lambda表达式或方法引用来设置数组的值。
package arrays;
import java.util.Arrays;
public class SimpleSetAll {
public static final int SZ = 8;
static int val = 1;
public static void main(String[] args) {
int[] ia = new int[SZ];
Arrays.setAll(ia, n -> n);
System.out.println(Arrays.toString(ia));
Arrays.setAll(ia, n -> val++);
System.out.println(Arrays.toString(ia));
}
}
输出：
[0, 1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 8]
8. 数组并行
Arrays.parallelSetAll()
效果与 SetAll() 一样，可并行
9. Arrays工具类
该类包含许多有用的 静态 程序方法：
-
asList(): 获取任何序列或数组，并将其转换为一个 列表集合 。
-
copyOf()：以新的长度创建现有数组的新副本。
-
copyOfRange()：创建现有数组的一部分的新副本。
-
equals()：比较两个数组是否相等。
-
deepEquals()：多维数组的相等性比较。
-
stream()：生成数组元素的流。
-
hashCode()：生成数组的哈希值。
-
deepHashCode(): 多维数组的哈希值。
-
sort()：排序数组
-
parallelSort()：对数组进行并行排序，以提高速度。
-
binarySearch()：在已排序的数组中查找元素。
-
parallelPrefix()：使用提供的函数并行累积(以获得速度)。基本上，就是数组的reduce()。
-
spliterator()：从数组中产生一个Spliterator;这是本书没有涉及到的流的高级部分。
-
toString()：为数组生成一个字符串表示。你在整个章节中经常看到这种用法。
-
deepToString()：为多维数组生成一个字符串。
10. 数组拷贝
与使用for循环手工执行复制相比，copyOf() 和 copyOfRange() 复制数组要快得多。这些方法被重载以处理所有类型。
工具类：
package arrays;
import java.util.Arrays;
import java.util.function.Supplier;
public interface Count {
class Integer
implements Supplier<java.lang.Integer> {
int i;
@Override
public java.lang.Integer get() {
return i++;
}
public java.lang.Integer get(int n) {
return get();
}
public java.lang.Integer[] array(int sz) {
java.lang.Integer[] result =
new java.lang.Integer[sz];
Arrays.setAll(result, n -> get());
return result;
}
}
}
测试类：
package arrays;
import java.util.Arrays;
class Sup {
// Superclass
private int id;
Sup(int n) {
id = n;
}
@Override
public String toString() {
return getClass().getSimpleName() + id;
}
}
class Sub extends Sup { // Subclass
Sub(int n) {
super(n);
}
}
public class ArrayCopying {
public static final int SZ = 10;
static <T> void show(String info, T[] array) {
System.out.println(info + ":" + Arrays.toString(array));
}
public static void main(String[] args) {
Integer[] a1 = new Integer[SZ];
Arrays.setAll(a1, new Count.Integer()::get);
show("a1", a1);
// 最基本的数组复制
Integer[] a2 = Arrays.copyOf(a1, a1.length);
// 把a1的所有元素都设为1，以证明a1的变化不会影响a2
Arrays.fill(a1,1);
show("a1", a1);
show("a2", a2);
a2 = Arrays.copyOf(a2, 8);
show("a2", a2);
// copyOfRange() 需要一个开始和结束索引
Integer[] a3 = Arrays.copyOfRange(a2, 2, 5);
show("a3", a3);
}
}
输出：
a1:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a1:[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
a2:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a2:[0, 1, 2, 3, 4, 5, 6, 7]
a3:[2, 3, 4]
11. 数组比较
数组 提供了 equals() 来比较一维数组，以及 deepEquals() 来比较多维数组。对于所有原生类型和对象，这些方法都是重载的。
数组相等的含义：数组必须有相同数量的元素，并且每个元素必须与另一个数组中的对应元素相等，对每个元素使用 equals()。
package arrays;
import java.util.Arrays;
public class ComparingArrays {
public static final int SZ = 5;
public static void main(String[] args) {
int[] a1 = new int[SZ], a2 = new int[SZ];
Arrays.setAll(a1, new Count.Integer()::get);
Arrays.setAll(a2, new Count.Integer()::get);
System.out.println("a1 == a2: " + Arrays.equals(a1, a2));
a2[3] = 11;
System.out.println("a1 == a2: " + Arrays.equals(a1, a2));
}
}
输出：
a1 == a2: true
a1 == a2: false
12. 流和数组
stream() 方法很容易从某些类型的数组中生成元素流。
package arrays;
import java.util.Arrays;
public class StreamFromArray {
public static void main(String[] args) {
String[] s = {"abc", "dcd", "erb", "kkl", "232", "dfg", "abc"};
Arrays.stream(s).skip(2)
.limit(4)
.map(n -> n + "!")
.forEach(System.out::println);
}
}
输出：
erb!
kkl!
232!
dfg!
13. 数组排序
Java有两种方式提供比较功能。第一种方法是通过实现 java.lang.Comparable 接口的原生方法。这是一个简单的接口，只含有一个方法 compareTo()。该方法接受另一个与参数类型相同的对象作为参数，如果当前对象小于参数，则产生一个负值;如果参数相等，则产生零值;如果当前对象大于参数，则产生一个正值。
package arrays;
import java.util.Arrays;
import java.util.SplittableRandom;
public class CompType implements Comparable<CompType> {
private static int count = 1;
private static SplittableRandom r = new SplittableRandom(47);
int i;
int j;
public CompType(int n1, int n2) {
i = n1;
j = n2;
}
public static CompType get() {
return new CompType(r.nextInt(100), r.nextInt(100));
}
static <T> void show(String info, T[] array) {
System.out.println(info + ":" + Arrays.toString(array));
}
@Override
public String toString() {
String result = "[i = " + i + ", j = " + j + "]";
return result;
}
public static void main(String[] args) {
CompType[] a = new CompType[6];
Arrays.setAll(a, n -> get());
show("Before sorting", a);
// 这里用的是重写的 compareTo() 进行排序
Arrays.sort(a);
show("After sorting", a);
}
@Override
public int compareTo(CompType rv) {
return i < rv.i ? -1 : (i == rv.i ? 0 : 1);
}
}
输出：
Before sorting:[[i = 35, j = 37], [i = 41, j = 20], [i = 77, j = 79], [i = 56, j = 68], [i = 48, j = 93], [i = 70, j = 7]]
After sorting:[[i = 35, j = 37], [i = 41, j = 20], [i = 48, j = 93], [i = 56, j = 68], [i = 70, j = 7], [i = 77, j = 79]]
集合类包含一个方法 reverseOrder()，它生成一个来Comparator（比较器）反转自然排序顺序。
package arrays;
import java.util.Arrays;
import java.util.Collections;
public class Reverse {
static <T> void show(String info, T[] array) {
System.out.println(info + ":" + Arrays.toString(array));
}
public static void main(String[] args) {
CompType[] a = new CompType[6];
Arrays.setAll(a, n -> CompType.get());
show("Before sorting", a);
Arrays.sort(a, Collections.reverseOrder());
show("After sorting", a);
}
}
输出：
Before sorting:[[i = 35, j = 37], [i = 41, j = 20], [i = 77, j = 79], [i = 56, j = 68], [i = 48, j = 93], [i = 70, j = 7]]
After sorting:[[i = 77, j = 79], [i = 70, j = 7], [i = 56, j = 68], [i = 48, j = 93], [i = 41, j = 20], [i = 35, j = 37]]
您还可以编写自己的比较器。这个比较CompType对象基于它们的j值而不是它们的i值:
package arrays;
import java.util.Arrays;
import java.util.Comparator;
class CompTypeComparator implements Comparator<CompType> {
@Override
public int compare(CompType o1, CompType o2) {
return (o1.j < o2.j ? -1 : (o1.j == o2.j ? 0 : 1));
}
}
public class ComparatorTest {
static <T> void show(String info, T[] array) {
System.out.println(info + ":" + Arrays.toString(array));
}
public static void main(String[] args) {
CompType[] a = new CompType[6];
Arrays.setAll(a, n -> CompType.get());
show("Before sorting", a);
Arrays.sort(a, new CompTypeComparator());
show("After sorting", a);
}
}
输出：
Before sorting:[[i = 35, j = 37], [i = 41, j = 20], [i = 77, j = 79], [i = 56, j = 68], [i = 48, j = 93], [i = 70, j = 7]]
After sorting:[[i = 70, j = 7], [i = 41, j = 20], [i = 35, j = 37], [i = 56, j = 68], [i = 77, j = 79], [i = 48, j = 93]]
—PS：推荐大佬文章：Comparator和Comparable的区别
Arrays.sort()的使用
使用内置的排序方法，您可以对实现了 Comparable 接口或具有 Comparator 的任何对象数组或任何原生数组进行排序。
并行排序
如果排序性能是一个问题，那么可以使用 Java 8 parallelSort()
parallelSort() 算法将大数组拆分成更小的数组，直到数组大小达到极限，然后使用普通的 Arrays.sort() 方法。然后合并结果。该算法需要不大于原始数组的额外工作空间。
14. binarySearch二分查找
一旦数组被排序，您就可以通过使用 Arrays.binarySearch() 来执行对特定项的快速搜索。但是，如果尝试在未排序的数组上使用 binarySearch()，结果是不可预测的。
package arrays;
import java.util.Arrays;
import java.util.Random;
public class ArraySearching {
public static void main(String[] args) {
Random random = new Random(47);
int[] a = new int[15];
for (int i = 0; i < a.length; i++) {
a[i] = random.nextInt(100);
}
Arrays.sort(a);
System.out.println("Sorted array:" + Arrays.toString(a));
while (true) {
int r = random.nextInt(100);
int location = Arrays.binarySearch(a, r);
if (location >= 0) {
System.out.println("Location of " + r + " is " + location + ", a["
+ location + "] is " + a[location]);
break;
}
}
}
}
输出：
Sorted array:[0, 7, 9, 22, 28, 29, 51, 55, 58, 61, 61, 68, 88, 89, 93]
Location of 61 is 9, a[9] is 61
15. 本章小结
Java为固定大小的低级数组提供了合理的支持。在Java的最初版本中，固定大小的低级数组是绝对必要的，这不仅是因为Java设计人员选择包含原生类型(也考虑到性能)，还因为那个版本对集合的支持非常少。因此，在早期的Java版本中，选择数组总是合理的。在Java的后续版本中，集合支持得到了显著的改进，现在集合在除性能外的所有方面都优于数组。正如本书其他部分所述，无论如何，性能问题通常不会出现在您设想的地方。
所有这些问题都表明，在使用Java的最新版本进行编程时，应该“优先选择集合而不是数组”。只有当您证明性能是一个问题(并且切换到一个数组实际上会有很大的不同)时，才应该重构到数组。
—PS：非必要不使用
（图网，侵删）
1977
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
