[java] 표준 Kotlin 라이브러리에서 사용할 수있는 Java 8 Stream.collect는 무엇입니까?

추가 예제는 다음과 같이 Java 8 Stream Tutorial의 모든 샘플 을 Kotlin으로 변환 한 것입니다. 각 예제의 제목은 소스 기사에서 파생됩니다.

스트림 작동 방식

// Java:
List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1");

myList.stream()
      .filter(s -> s.startsWith("c"))
      .map(String::toUpperCase)
     .sorted()
     .forEach(System.out::println);

// C1
// C2

// Kotlin:
val list = listOf("a1", "a2", "b1", "c2", "c1")
list.filter { it.startsWith('c') }.map (String::toUpperCase).sorted()
        .forEach (::println)

다른 종류의 스트림 # 1

// Java:
Arrays.asList("a1", "a2", "a3")
    .stream()
    .findFirst()
    .ifPresent(System.out::println);    

// Kotlin:
listOf("a1", "a2", "a3").firstOrNull()?.apply(::println)

또는 ifPresent라는 문자열에 확장 함수를 만듭니다.

// Kotlin:
inline fun String?.ifPresent(thenDo: (String)->Unit) = this?.apply { thenDo(this) }

// now use the new extension function:
listOf("a1", "a2", "a3").firstOrNull().ifPresent(::println)

참조 : apply()기능

참조 : 확장 기능

참고 : ?.Safe Call 연산자 및 일반적으로 null 허용 여부 : Kotlin에서는 nullable 값을 처리하거나 참조하거나 변환하는 관용적 방법이 무엇입니까

다른 종류의 스트림 # 2

// Java:
Stream.of("a1", "a2", "a3")
    .findFirst()
    .ifPresent(System.out::println);    

// Kotlin:
sequenceOf("a1", "a2", "a3").firstOrNull()?.apply(::println)

다른 종류의 스트림 # 3

// Java:
IntStream.range(1, 4).forEach(System.out::println);

// Kotlin:  (inclusive range)
(1..3).forEach(::println)

다른 종류의 스트림 # 4

// Java:
Arrays.stream(new int[] {1, 2, 3})
    .map(n -> 2 * n + 1)
    .average()
    .ifPresent(System.out::println); // 5.0    

// Kotlin:
arrayOf(1,2,3).map { 2 * it + 1}.average().apply(::println)

다른 종류의 스트림 # 5

// Java:
Stream.of("a1", "a2", "a3")
    .map(s -> s.substring(1))
    .mapToInt(Integer::parseInt)
    .max()
    .ifPresent(System.out::println);  // 3

// Kotlin:
sequenceOf("a1", "a2", "a3")
    .map { it.substring(1) }
    .map(String::toInt)
    .max().apply(::println)

다른 종류의 스트림 # 6

// Java:
IntStream.range(1, 4)
    .mapToObj(i -> "a" + i)
    .forEach(System.out::println);

// a1
// a2
// a3    

// Kotlin:  (inclusive range)
(1..3).map { "a$it" }.forEach(::println)

다른 종류의 스트림 # 7

// Java:
Stream.of(1.0, 2.0, 3.0)
    .mapToInt(Double::intValue)
    .mapToObj(i -> "a" + i)
    .forEach(System.out::println);

// a1
// a2
// a3

// Kotlin:
sequenceOf(1.0, 2.0, 3.0).map(Double::toInt).map { "a$it" }.forEach(::println)

주문이 중요한 이유

Java 8 스트림 학습서의이 섹션은 Kotlin 및 Java에서 동일합니다.

스트림 재사용

Kotlin에서는 컬렉션 유형에 따라 두 번 이상 사용할 수 있는지 여부에 따라 다릅니다. A Sequence는 매번 새로운 반복자를 생성하며, “한 번만 사용”한다고 주장하지 않는 한, 실행될 때마다 시작으로 재설정 할 수 있습니다. 따라서 Java 8 스트림에서는 다음이 실패하지만 Kotlin에서는 작동합니다.

// Java:
Stream<String> stream =
Stream.of("d2", "a2", "b1", "b3", "c").filter(s -> s.startsWith("b"));

stream.anyMatch(s -> true);    // ok
stream.noneMatch(s -> true);   // exception

// Kotlin:  
val stream = listOf("d2", "a2", "b1", "b3", "c").asSequence().filter { it.startsWith('b' ) }

stream.forEach(::println) // b1, b2

println("Any B ${stream.any { it.startsWith('b') }}") // Any B true
println("Any C ${stream.any { it.startsWith('c') }}") // Any C false

stream.forEach(::println) // b1, b2

Java에서 동일한 동작을 얻으려면

// Java:
Supplier<Stream<String>> streamSupplier =
    () -> Stream.of("d2", "a2", "b1", "b3", "c")
          .filter(s -> s.startsWith("a"));

streamSupplier.get().anyMatch(s -> true);   // ok
streamSupplier.get().noneMatch(s -> true);  // ok

따라서 Kotlin에서 데이터 제공자는 다시 재설정하고 새 반복자를 제공 할 수 있는지 여부를 결정합니다. 그러나 의도적으로 Sequence일회성 반복을 제한 하려면 다음과 같은 constrainOnce()기능을 사용할 수 있습니다 Sequence.

val stream = listOf("d2", "a2", "b1", "b3", "c").asSequence().filter { it.startsWith('b' ) }
        .constrainOnce()

stream.forEach(::println) // b1, b2
stream.forEach(::println) // Error:java.lang.IllegalStateException: This sequence can be consumed only once. 

고급 작업

예제 # 5를 수집하십시오 (예, 이미 다른 답변에있는 것을 건너 뛰었습니다)

// Java:
String phrase = persons
        .stream()
        .filter(p -> p.age >= 18)
        .map(p -> p.name)
        .collect(Collectors.joining(" and ", "In Germany ", " are of legal age."));

    System.out.println(phrase);
    // In Germany Max and Peter and Pamela are of legal age.    

// Kotlin:
val phrase = persons.filter { it.age >= 18 }.map { it.name }
        .joinToString(" and ", "In Germany ", " are of legal age.")

println(phrase)
// In Germany Max and Peter and Pamela are of legal age.

참고로 Kotlin 에서는 다음과 같이 간단한 데이터 클래스를 만들고 테스트 데이터를 인스턴스화 할 수 있습니다 .

// Kotlin:
// data class has equals, hashcode, toString, and copy methods automagically
data class Person(val name: String, val age: Int)

val persons = listOf(Person("Tod", 5), Person("Max", 33),
                     Person("Frank", 13), Person("Peter", 80),
                     Person("Pamela", 18))

예제 # 6 수집

// Java:
Map<Integer, String> map = persons
        .stream()
        .collect(Collectors.toMap(
                p -> p.age,
                p -> p.name,
                (name1, name2) -> name1 + ";" + name2));

System.out.println(map);
// {18=Max, 23=Peter;Pamela, 12=David}    

좋아, Kotlin에 대한 더 흥미로운 사례입니다. 먼저 Map컬렉션 / 시퀀스에서 생성의 변형을 탐색하는 잘못된 답변 :

// Kotlin:
val map1 = persons.map { it.age to it.name }.toMap()
println(map1)
// output: {18=Max, 23=Pamela, 12=David} 
// Result: duplicates overridden, no exception similar to Java 8

val map2 = persons.toMap({ it.age }, { it.name })
println(map2)
// output: {18=Max, 23=Pamela, 12=David} 
// Result: same as above, more verbose, duplicates overridden

val map3 = persons.toMapBy { it.age }
println(map3)
// output: {18=Person(name=Max, age=18), 23=Person(name=Pamela, age=23), 12=Person(name=David, age=12)}
// Result: duplicates overridden again

val map4 = persons.groupBy { it.age }
println(map4)
// output: {18=[Person(name=Max, age=18)], 23=[Person(name=Peter, age=23), Person(name=Pamela, age=23)], 12=[Person(name=David, age=12)]}
// Result: closer, but now have a Map<Int, List<Person>> instead of Map<Int, String>

val map5 = persons.groupBy { it.age }.mapValues { it.value.map { it.name } }
println(map5)
// output: {18=[Max], 23=[Peter, Pamela], 12=[David]}
// Result: closer, but now have a Map<Int, List<String>> instead of Map<Int, String>

그리고 지금 정답 :

// Kotlin:
val map6 = persons.groupBy { it.age }.mapValues { it.value.joinToString(";") { it.name } }

println(map6)
// output: {18=Max, 23=Peter;Pamela, 12=David}
// Result: YAY!!

일치하는 값을 조인하여 목록을 축소하고 인스턴스 jointToString에서로 이동 하는 변환기를 제공 Person해야했습니다 Person.name.

예제 # 7 수집

좋아, 이것은 사용자 정의없이 쉽게 수행 할 수 있으므로 CollectorKotlin 방식으로 해결 한 다음 Collector.summarizingIntKotlin에 기본적으로 존재하지 않는 유사한 프로세스를 수행하는 방법을 보여주는 새로운 예제를 고안해 보겠습니다 .

// Java:
Collector<Person, StringJoiner, String> personNameCollector =
Collector.of(
        () -> new StringJoiner(" | "),          // supplier
        (j, p) -> j.add(p.name.toUpperCase()),  // accumulator
        (j1, j2) -> j1.merge(j2),               // combiner
        StringJoiner::toString);                // finisher

String names = persons
        .stream()
        .collect(personNameCollector);

System.out.println(names);  // MAX | PETER | PAMELA | DAVID    

// Kotlin:
val names = persons.map { it.name.toUpperCase() }.joinToString(" | ")

그들이 사소한 예를 고른 것은 내 잘못이 아닙니다 !!! 다음은 summarizingIntKotlin 의 새로운 방법과 일치하는 샘플입니다.

SummaryInt 예제

// Java:
IntSummaryStatistics ageSummary =
    persons.stream()
           .collect(Collectors.summarizingInt(p -> p.age));

System.out.println(ageSummary);
// IntSummaryStatistics{count=4, sum=76, min=12, average=19.000000, max=23}    

// Kotlin:

// something to hold the stats...
data class SummaryStatisticsInt(var count: Int = 0,
                                var sum: Int = 0,
                                var min: Int = Int.MAX_VALUE,
                                var max: Int = Int.MIN_VALUE,
                                var avg: Double = 0.0) {
    fun accumulate(newInt: Int): SummaryStatisticsInt {
        count++
        sum += newInt
        min = min.coerceAtMost(newInt)
        max = max.coerceAtLeast(newInt)
        avg = sum.toDouble() / count
        return this
    }
}

// Now manually doing a fold, since Stream.collect is really just a fold
val stats = persons.fold(SummaryStatisticsInt()) { stats, person -> stats.accumulate(person.age) }

println(stats)
// output: SummaryStatisticsInt(count=4, sum=76, min=12, max=23, avg=19.0)

그러나 Kotlin stdlib의 스타일과 일치하도록 확장 기능을 만드는 것이 좋습니다.

// Kotlin:
inline fun Collection<Int>.summarizingInt(): SummaryStatisticsInt
        = this.fold(SummaryStatisticsInt()) { stats, num -> stats.accumulate(num) }

inline fun <T: Any> Collection<T>.summarizingInt(transform: (T)->Int): SummaryStatisticsInt =
        this.fold(SummaryStatisticsInt()) { stats, item -> stats.accumulate(transform(item)) }

이제 새로운 summarizingInt기능 을 사용하는 두 가지 방법이 있습니다 .

val stats2 = persons.map { it.age }.summarizingInt()

// or

val stats3 = persons.summarizingInt { it.age }

그리고이 모든 것들이 같은 결과를 낳습니다. 또한이 기본 확장을 작성 Sequence하여 적절한 기본 유형에 대해 작업하고 수행 할 수 있습니다.

재미 를 위해이 요약을 구현하는 데 필요한 Java JDK 코드와 Kotlin 사용자 정의 코드를 비교하십시오 .

답변

fun <T: Any> Stream<T>.toList(): List<T> = this.collect(Collectors.toList<T>())
fun <T: Any> Stream<T>.asSequence(): Sequence<T> = this.iterator().asSequence()

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

val totalByDept = employees.groupingBy { it.dept }.fold(0) { acc, e -> acc + e.salary }

public inline fun <T, K> Grouping<T, K>.sumBy(
        selector: (T) -> Int
): Map<K, Int> =
        fold(0) { acc, element -> acc + selector(element) }

val totalByDept = employees.groupingBy { it.dept }.sumBy { it.salary }