สำหรับตัวอย่างเพิ่มเติมต่อไปนี้เป็นตัวอย่างทั้งหมดจาก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)
หรือสร้างฟังก์ชั่นส่วนขยายบน String ชื่อ 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()ฟังก์ชั่น
ดูเพิ่มเติมที่: ฟังก์ชั่นการขยาย
ดูเพิ่มเติมที่: ?.ตัวดำเนินการโทรปลอดภัยและความเป็นโมฆะทั่วไป: ใน 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 Stream นั้นเหมือนกันสำหรับ Kotlin และ Java
การใช้ซ้ำสตรีม
ใน Kotlin นั้นขึ้นอยู่กับประเภทของการสะสมว่าสามารถบริโภคได้มากกว่าหนึ่งครั้งหรือไม่ Sequenceสร้าง iterator ใหม่ทุกครั้งและถ้ามันอ้าง "การใช้เพียงครั้งเดียว" ก็สามารถตั้งค่าที่จะเริ่มต้นในแต่ละครั้งที่มีการดำเนินการใด ๆ ดังนั้นในขณะที่ข้อมูลต่อไปนี้ล้มเหลวในสตรีม 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ทำซ้ำa ถึงหนึ่งครั้งโดยเจตนาคุณสามารถใช้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ที่จะย้ายจากอินสแตนซ์ไปPersonPerson.name
รวบรวมตัวอย่าง # 7
ตกลงสามารถทำได้อย่างง่ายดายโดยไม่ต้องกำหนดเองCollectorดังนั้นให้แก้ทาง Kotlin แล้วประดิษฐ์ตัวอย่างใหม่ที่แสดงวิธีการทำกระบวนการที่คล้ายกันCollector.summarizingIntซึ่งไม่มีอยู่ใน Kotlin
// 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(" | ")
ไม่ใช่ความผิดของฉันที่พวกเขาเลือกตัวอย่างเล็กน้อย !!! ตกลงนี่เป็นsummarizingIntวิธีการใหม่สำหรับ Kotlin และตัวอย่างที่ตรงกัน:
สรุปตัวอย่าง
// 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)
แต่จะเป็นการดีกว่าถ้าสร้างฟังก์ชั่นเสริม 2 จริง ๆ แล้วจะจับคู่สไตล์ใน 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เพื่อใช้ในการสรุปนี้
collect(Collectors.toList())หรือคล้ายกันคุณอาจพบปัญหานี้: stackoverflow.com/a/35722167/3679676 (ปัญหาพร้อมวิธีแก้ไขปัญหา)