在 Java 7 和 8 中创建与现有列表不同的列表？

如果我有：

List<Integer> listInts = { 1, 1, 3, 77, 2, 19, 77, 123, 14, 123... }

在Java中创建一个有效的方法是什么List<Integer> listDistinctInts仅包含distinct值来自listInts?

我的直接想法是创建一个Set<Integer> setInts包含来自的所有值listInts然后打电话List<Integer> listDistinctInts = new ArrayList<>(setInts);

但这似乎可能效率低下 - 使用 Java 7 是否有更好的解决方案？

我没有使用 Java 8，但我相信使用它我可以做这样的事情（？）：

List<Integer> listDistinctInts = listInts.stream().distinct().collect(Collectors.toList());

这会比上面的方法更高效和/或者在 Java 8 中是否有更有效的方法来做到这一点？

最后，（我知道提出多个问题可能会让人皱眉，但这是直接相关的）如果我只关心count中的不同元素listInts有没有更有效的方法来获取该值（在 Java 7 和 8 中） - 无需首先创建所有不同元素的列表或集合？

我对实现这一点的原生 Java 方法最感兴趣，并避免重新发明任何轮子，但如果手工代码或库提供更好的清晰度或性能，我会考虑它们。我读过这个相关问题Java - 不同的对象列表 https://stackoverflow.com/q/1019854/3651800但尚不完全清楚 Java 7 和 8 方法之间的性能差异，或者是否有更好的技术？

我现在已经从提供的优秀答案中对大多数建议选项进行了 MicroBenchmark。像大多数与性能相关的重要问题一样，哪个最好的答案是“这取决于”.

我所有的测试都是用JMHJava 微基准测试工具 http://openjdk.java.net/projects/code-tools/jmh/.

大多数测试都是使用 JDK 1.8 执行的，尽管我也使用 JDK 1.7 执行了一些测试，只是为了确保其性能不会有太大差异（几乎相同）。我测试了从迄今为止提供的答案中获取的以下技术：

1.Java 8 流- 解决方案使用stream()我曾提出使用 Java 8 的可能性：

public List<Integer> testJava8Stream(List<Integer> listInts) {
    return listInts.stream().distinct().collect(Collectors.toList());
}

pros 现代 Java 8 方法，无第三方依赖

cons 需要 Java 8

2. 添加到列表- 提出的解决方案维克多2748 https://stackoverflow.com/a/27464820/3651800当且仅当列表尚未包含该值时，才会构造并添加新列表。请注意，我还按照原始大小（最大可能）预分配目标列表，以防止任何重新分配：

public List<Integer> testAddingToList(List<Integer> listInts) {
    List<Integer> listDistinctInts = new ArrayList<>(listInts.size());
    for(Integer i : listInts)
    {
        if( !listDistinctInts.contains(i) ) { listDistinctInts.add(i); }
    }
    return listDistinctInts;
}

pros 适用于任何 Java 版本，无需创建 Set 然后复制，无需第 3 方依赖

cons 在构建列表时需要重复检查列表中的现有值

3. GS 快速收藏 （现在是 Eclipse 集合）- 提出的解决方案克雷格·莫特林 https://stackoverflow.com/a/27489572/3651800使用GS 馆藏库 https://github.com/goldmansachs/gs-collections以及他们的自定义列表类型FastList:

public List<Integer> testGsCollectionsFast(FastList listFast)
{
    return listFast.distinct();
}

pros 据报道，代码非常快速、简单且富有表现力，适用于 Java 7 和 8

cons 需要第 3 方库和FastList而不是常规的List<Integer>

4. GS系列改编- FastList 解决方案并不能完全进行同类比较，因为它需要一个FastList传递给方法而不是好的 ol'ArrayList<Integer>所以我也测试了Craig提出的适配器方法：

public List<Integer> testGsCollectionsAdapted(List<Integer> listInts)
{
    return listAdapter.adapt(listInts).distinct();
}

pros 不需要FastList，适用于 Java 7 和 8

cons 必须适应列表，因此可能性能不佳，需要第 3 方库

5.番石榴不可变集- 提出的方法路易斯·沃瑟曼 https://stackoverflow.com/a/12248480/3651800在评论中，以及卢声远盛源路 https://stackoverflow.com/a/27477005/3651800在他们的回答中使用Guava https://code.google.com/p/guava-libraries/:

public List<Integer> testGuavaImmutable(List<Integer> listInts)
{
    return ImmutableSet.copyOf(listInts).asList();
}

pros 据称速度非常快，适用于 Java 7 或 8

cons 返回一个Immutable List，无法处理输入列表中的空值，并且需要第 3 方库

7. 哈希集- 我最初的想法（也由EverV0id https://stackoverflow.com/a/27464848/3651800, ulix https://stackoverflow.com/a/27465914/3651800和无线电定义）

public List<Integer> testHashSet(List<Integer> listInts)
{
    return new ArrayList<Integer>(new HashSet<Integer>(listInts));
}

pros 适用于 Java 7 和 8，无第 3 方依赖项

cons 不保留列表的原始顺序，必须构造集合然后复制到列表。

6.LinkedHashSet- 自从HashSet解决方案没有保留原始列表中整数的顺序我还测试了一个使用 LinkedHashSet 来保留顺序的版本：

public List<Integer> testLinkedHashSet(List<Integer> listInts)
{
    return new ArrayList<Integer>(new LinkedHashSet<Integer>(listInts));
}

pros 保留原始顺序，适用于 Java 7 和 8，无第 3 方依赖项

cons 不太可能像平常一样快HashSet方法

Results

这是我对各种不同尺寸的结果listInts（结果从最慢到最快排序）：

1. 与 ArrayList 不同，取 0-50,000 之间的 100,000 个随机整数（即大列表，一些重复）

Benchmark                Mode       Samples     Mean   Mean error    Units

AddingToList            thrpt        10        0.505        0.012    ops/s
Java8Stream             thrpt        10      234.932       31.959    ops/s
LinkedHashSet           thrpt        10      262.185       16.679    ops/s
HashSet                 thrpt        10      264.295       24.154    ops/s
GsCollectionsAdapted    thrpt        10      357.998       18.468    ops/s
GsCollectionsFast       thrpt        10      363.443       40.089    ops/s
GuavaImmutable          thrpt        10      469.423       26.056    ops/s

2. 取不同于 ArrayList 的 1000 个 0-50 之间的随机整数（即中等列表，许多重复项）

Benchmark                Mode       Samples     Mean   Mean error    Units

AddingToList            thrpt        10    32794.698     1154.113    ops/s
HashSet                 thrpt        10    61622.073     2752.557    ops/s
LinkedHashSet           thrpt        10    67155.865     1690.119    ops/s
Java8Stream             thrpt        10    87440.902    13517.925    ops/s
GsCollectionsFast       thrpt        10   103490.738    35302.201    ops/s
GsCollectionsAdapted    thrpt        10   143135.973     4733.601    ops/s
GuavaImmutable          thrpt        10   186301.330    13421.850    ops/s

3. 取不同于 ArrayList 的 100 个 0-100 之间的随机整数（即小列表，一些重复）

Benchmark                Mode       Samples     Mean   Mean error    Units

AddingToList            thrpt        10   278435.085    14229.285    ops/s
Java8Stream             thrpt        10   397664.052    24282.858    ops/s
LinkedHashSet           thrpt        10   462701.618    20098.435    ops/s
GsCollectionsAdapted    thrpt        10   477097.125    15212.580    ops/s
GsCollectionsFast       thrpt        10   511248.923    48155.211    ops/s
HashSet                 thrpt        10   512003.713    25886.696    ops/s
GuavaImmutable          thrpt        10  1082006.560    18716.012    ops/s

4. 取不同于 ArrayList 的 10 个 0-50 之间的随机整数（即小列表，很少重复）

Benchmark                Mode       Samples     Mean   Mean error    Units

Java8Stream             thrpt        10  2739774.758   306124.297    ops/s
LinkedHashSet           thrpt        10  3607479.332   150331.918    ops/s
HashSet                 thrpt        10  4238393.657   185624.358    ops/s
GsCollectionsAdapted    thrpt        10  5919254.755   495444.800    ops/s
GsCollectionsFast       thrpt        10  7916079.963  1708778.450    ops/s
AddingToList            thrpt        10  7931479.667   966331.036    ops/s
GuavaImmutable          thrpt        10  9021621.880   845936.861    ops/s

结论

• 如果您只从列表中取出一次不同的项目，并且列表不是很长any这些方法应该足够了。

• 最有效的通用方法来自第三方库：GS Collections 和 Guava 表现出色。

• 在选择性能最佳的方法时，您可能需要考虑列表的大小以及可能的重复项数量。

• 仅当值尚未存在时才添加到新列表的幼稚方法对于小型列表非常有效，但是一旦输入列表中包含多个值，它就会执行所尝试的方法中最差的方法。

• 番石榴ImmutableSet.copyOf(listInts).asList()方法在大多数情况下效果最快。但请注意限制：返回的列表是Immutable并且输入列表不能包含空值。

• The HashSet方法执行最好的非第 3 方方法，通常比 Java 8 流更好，但会重新排序整数（这可能是也可能不是问题，具体取决于您的用例）。

• The LinkedHashSet方法保持顺序，但不出所料通常比 HashSet 方法更糟糕。

• 这俩HashSet and LinkedHashSet当使用具有复杂 HashCode 计算的数据类型列表时，方法的性能会更差，因此，如果您尝试选择不同的数据类型，请自行进行分析Foos 来自 aList<Foo>.

• 如果你已经有GS系列 https://github.com/goldmansachs/gs-collections作为依赖项，它的性能非常好，并且比 ImmutableList 更灵活Guava https://code.google.com/p/guava-libraries/方法。如果您没有将其作为依赖项，并且选择不同项目的性能对于应用程序的性能至关重要，则值得考虑添加它。

• 令人失望的是，Java 8 流的性能似乎相当差。可能有更好的编码方式distinct()调用方式比我使用的方式更好，所以当然欢迎评论或其他答案。

注意。我不是微基准测试专家，因此如果有人发现我的结果或方法存在缺陷，请通知我，我将尽力纠正答案。