Java流：计算原始数组中不同值的数量

Question

为什么对int数组的去重计数会返回一个不同于对Integer数组计数的结果呢？我期望两者都应该是3。

int[] numbers1 = { 1, 2, 3 };
System.out.println("numbers1: " + Arrays.toString(numbers1));
System.out.println("distinct numbers1 count: " + Stream.of(numbers1).distinct().count());

Integer[] numbers2 = { 1, 2, 3 };
System.out.println("numbers2: " + Arrays.toString(numbers2));
System.out.println("distinct numbers2 count: " + Stream.of(numbers2).distinct().count());

结果

numbers1: [1, 2, 3]
distinct numbers1 count: 1

numbers2: [1, 2, 3]
distinct numbers2 count: 3

- Arthur Borsboom

Answer 1

在第一个例子中，Stream.of(numbers1) 的类型为 Stream<int[]>，其中只有一个值。

在第二个例子中，Stream.of(numbers2) 的类型为 Stream<Integer>，其中有三个不同的值。

您可以使用 IntStream.of(1, 2, 3) 来获取基本类型int的流。

- Erwin Bolwidt

Answer 2

原因在于第一个方法中的Stream.of会将整个数组视为一个元素，从而创建一个包含该数组元素的流。如果要处理基本类型的数组，则需要使用Arrays.stream方法。

- Andronicus

---

通常情况下，我会使用Arrays.stream来遍历现有的数组。这样，您就不必再考虑它了。Stream类中的工厂方法适用于 varargs 用例，即当您使用 Stream.of(a)、Stream.of(a, b) 或 Stream.of(a, b, c) 等时，您也不需要考虑是否存在这些调用的专门版本... - Holger

Answer 3

Streams提供两个静态的Stream<T> of()方法：

public static<T> Stream<T> of(T t) {..}

并且

public static<T> Stream<T> of(T... values) {..}

第一种方法创建一个包含单个对象的流，该对象作为参数提供，而第二种方法创建一个包含数组元素的流。
在您的情况下，int[] 参数使得调用 of(T values) 方法，而 Integer[] 参数则使得调用 of(T... values) 方法。
期望的结果是 1 ，然后是 3。

为什么编译器不将这两个调用绑定到同一个 of() 方法上？

因为当传递的参数声明类型为对象数组时，编译器会选择可用的最具体方法：of(T... values) 。但是当传递的参数声明类型为基本数据类型数组时，该方法不匹配：int 不是 Object。因此，编译器可以选择的剩余方法是 of(T t)。

简而言之：要对原始数据类型数组进行流处理，请勿使用 Stream.of()，而是使用专门设计用于此目的的特定类：IntStream.of() 或 DoubleStream.of()。

- davidxxx

---

或者也可以使用 Arrays.stream。 - Thiyagu

Answer 4

第一个 Stream.of 返回一个 Stream<int[]>，你只有1个不同的int[]，名为numbers1。第二个 Stream.of 返回一个 Stream<Integer>，你有3个不同的Integers，分别是1、2和3。你可以通过将第一个 Stream.of 替换为 Arrays.stream 来修复此问题，因为 Arrays 有一个专门的实用程序方法，它将一个 int[] 作为参数，并返回一个 IntStream。

- Avi

Answer 5

替换

Stream.of(numbers1)

使用

Arrays.stream(numbers1)

正确地将 int[] 转换为 IntStream，而不是 Stream<int[]>。

- Naman