在标准Kotlin库中有哪些Java8Stream.Collect等价物？

Question

在Java8中，有stream.collect，它允许对集合进行聚合。在Kotlin中，除了可能作为stdlib中的扩展函数集合之外，这并不是以同样的方式存在的。但不清楚不同用例的等价物是什么。

例如，JavaDoc Forcollectors的顶部是为Java8编写的示例，当将它们移植到Kolin时，您不能在不同的JDK版本上使用Java8类，因此它们可能应该以不同的方式编写。

就展示Kotlin集合示例的在线资源而言，它们通常是微不足道的，并不真正与相同的用例相比较。有哪些好的例子与Java 8stream.collection文档中的例子完全匹配？这里的名单是：

null

详细信息在上面链接的JavaDoc中。

注意：这个问题是有意写的，并由作者回答（自我回答的问题），以便在so中出现对常见的Kotlin主题的惯用答案。同时也要澄清一些为阿尔法斯的Kotlin写的真正古老的答案，这些答案对于现在的Kotlin来说是不准确的。

Answer 1

Kotlin stdlib中有以下函数：平均、计数、不同、过滤、查找、分组、联接、映射、最小、最大、分区、切片、排序、求和、到/从数组、到/从列表、到/从映射、联合、共迭代、所有函数范例等等。所以您可以使用它们来创建小的1-liner，而不需要使用Java8中更复杂的语法。

我认为内置的Java8 collectors类唯一缺少的是摘要（但这个问题的另一个答案是一个简单的解决方案）。

这两种方法都缺少的一点是按计数进行批处理，它可以在另一个堆栈溢出答案中看到，并且也有一个简单的答案。另一个有趣的例子是同样来自Stack Overflow的例子：使用Kotlin将序列拆分为三个列表的惯用方法。如果您希望创建类似 stream.collection的东西以实现其他目的，请参阅Custom stream.collection in Kotlin

编辑11.08.2017:kotlin 1.2M2中增加了分块/窗口收集操作，参见https://blog.jetbrains.com/kotlin/2017/08/kotlin-1-2-m2-is-out/

在创建可能已经存在于kotlin.collections中的新函数之前，作为一个整体来研究kotlin.collections的API参考总是很好的。

以下是一些从Java8stream.collection示例到Kotlin中等效示例的转换：

将姓名累积到列表中

// Java:  
List<String> list = people.stream().map(Person::getName).collect(Collectors.toList());

// Kotlin:
val list = people.map { it.name }  // toList() not needed

将元素转换为字符串并将其串联起来，用逗号分隔

java prettyprint-override">// Java:
String joined = things.stream()
                       .map(Object::toString)
                       .collect(Collectors.joining(", "));

// Kotlin:
val joined = things.joinToString(", ")

计算员工工资总额

// Java:
int total = employees.stream()
                      .collect(Collectors.summingInt(Employee::getSalary)));

// Kotlin:
val total = employees.sumBy { it.salary }

// Java:
Map<Department, List<Employee>> byDept
     = employees.stream()
                .collect(Collectors.groupingBy(Employee::getDepartment));

// Kotlin:
val byDept = employees.groupBy { it.department }

// Java:
Map<Department, Integer> totalByDept
     = employees.stream()
                .collect(Collectors.groupingBy(Employee::getDepartment,
                     Collectors.summingInt(Employee::getSalary)));

// Kotlin:
val totalByDept = employees.groupBy { it.dept }.mapValues { it.value.sumBy { it.salary }}

// Java:
Map<Boolean, List<Student>> passingFailing =
     students.stream()
             .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));

// Kotlin:
val passingFailing = students.partition { it.grade >= PASS_THRESHOLD }

// Java:
List<String> namesOfMaleMembers = roster
    .stream()
    .filter(p -> p.getGender() == Person.Sex.MALE)
    .map(p -> p.getName())
    .collect(Collectors.toList());

// Kotlin:
val namesOfMaleMembers = roster.filter { it.gender == Person.Sex.MALE }.map { it.name }

// Java:
Map<Person.Sex, List<String>> namesByGender =
      roster.stream().collect(
        Collectors.groupingBy(
            Person::getGender,                      
            Collectors.mapping(
                Person::getName,
                Collectors.toList())));

// Kotlin:
val namesByGender = roster.groupBy { it.gender }.mapValues { it.value.map { it.name } }   

将一个列表筛选到另一个列表

// Java:
List<String> filtered = items.stream()
    .filter( item -> item.startsWith("o") )
    .collect(Collectors.toList());

// Kotlin:
val filtered = items.filter { it.startsWith('o') } 

查找列表中的最短字符串

// Java:
String shortest = items.stream()
    .min(Comparator.comparing(item -> item.length()))
    .get();

// Kotlin:
val shortest = items.minBy { it.length }

应用筛选后对列表中的项目进行计数

// Java:
long count = items.stream().filter( item -> item.startsWith("t")).count();

// Kotlin:
val count = items.filter { it.startsWith('t') }.size
// but better to not filter, but count with a predicate
val count = items.count { it.startsWith('t') }

// switch to and from lazy
val someList = items.asSequence().filter { ... }.take(10).map { ... }.toList()

// switch to lazy, but sorted() brings us out again at the end
val someList = items.asSequence().filter { ... }.take(10).map { ... }.sorted()

val someList = people.filter { it.age <= 30 }.map { it.name }

val someList: List<String> = people.filter { it.age <= 30 }.map { it.name }

由于Kotlin知道people是什么，并且people.age是int因此筛选表达式只允许与int进行比较，而people.name是string因此map步骤生成列表 （string的只读列表)。

现在，如果人可能为空，那么在列表 ？ 中：

val someList = people?.filter { it.age <= 30 }?.map { it.name }

返回需要进行空检查的列表 ？ （或对可为空的值使用其他Kotlin运算符之一，请参阅Kotlin处理可为空的值的惯用方法以及Kotlin中处理可为空或空列表的惯用方法）

• 可迭代扩展函数的API参考
• 数组扩展函数的API参考
• 列表扩展函数的API参考
• 要映射的扩展函数的API参考