从头学Java17-今天的Kotlin更香吗

出于各种限制，很多公司依然停留在Java8，部分小伙伴转向了Kotlin。Kotlin作为静态编译语言，提供大量语法糖，而且编译后的字节码跟Java一致。
当时，Java8于2014年发布，Kotlin于2016年，很多宣称的语法糖都是对比的Java8。不禁要问，相对今天的Java17，Kotlin优势还在吗？
现在就用最新的Kotlin1.9.0，对前三篇文章里的lambda、StreamAPI依次改造，实践出真知！

编写lambda、调用

Java

1. import Java.util.*;
2. import Java.util.function.*;
4. /**
5. *
6. * @author 烧哥burn.red
7. */
8. public class Test1 {
9.    
10.     public static void main(String[] args) {
11.         
12.         Predicate<String> predicate = s -> s.length() == 3;
13.         Consumer<String> consumer = s -> System.out.println(s);
14.         Supplier<String> supplier = () -> "Hello Duke!";
15.         Function<String, Integer> function = s -> s.length();
16.         
17.         IntSupplier intSupplier = () -> 1;
18.         IntConsumer intConsumer = s -> System.out.println(s);
19.         IntPredicate intPredicate = i -> i > 10;
20.         ToIntFunction<String> toIntFunction = s -> s.length();
21.         UnaryOperator<String> unaryOperator = s -> s.toUpperCase();
22.         
23.         BiConsumer<String, Integer> biConsumer = (s, number) -> s.indexOf(number);
24.         ObjIntConsumer<String> objIntConsumer = (s, value) -> System.out.printf("%s,%d\n", s, value);
25.         BiPredicate<String, Integer> biPredicate = (word, length) -> word.length() == length;
26.         BiFunction<String, String, Integer> biFunction = (word, sentence) -> sentence.indexOf(word);
27.         ToIntBiFunction<String, String> toIntBiFunction = (word, sentence) -> sentence.indexOf(word);
28.         
29.         String a = "aaa";
30.         
31.         if (predicate.test(a)) {
32.             consumer.accept(a);
33.             supplier.get();
34.             function.apply(a);
35.             
36.             intConsumer.accept(1);
37.             intSupplier.getAsInt();
38.             intPredicate.test(11);
39.             toIntFunction.applyAsInt(a);
40.             unaryOperator.apply(a);
41.             
42.             biConsumer.accept(a, 2);
43.             objIntConsumer.accept(null, 1);
44.             biPredicate.test(a, 3);
45.             biFunction.apply("fdsa", a);
46.             toIntBiFunction.applyAsInt("fdsa", a);
47.         }
48.         List<String> strings = new ArrayList<>(List.of("a", "bb", "ccc"));
49.         strings.forEach(consumer);
50.         strings.removeIf(predicate);//不应该在不可变集合上调用
51.         System.out.println(strings);
52.         
53.         strings = Arrays.asList("a", "bb", "ccc");
54.         strings.replaceAll(unaryOperator);
55.         System.out.println(strings);
57. //        int i = 0;
58. //        Consumer<Integer> add = s -> i++;//报错，从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量
59.     }
60. }

复制代码

Kotlin

1. /**
2. *
3. * @author 烧哥burn.red
4. */
6. fun main() {
7.     val predicate = { s: String -> s.length == 3 }
8.     val consumer = { s: String? -> println(s) }
9.     val supplier = { "Hello Duke!" }
10.     val function = { s: String -> s.length }
12.     val intSupplier = { 1 }
13.     val intConsumer = { s: Int -> println(s) }
14.     val intPredicate = { i: Int -> i > 10 }
15.     val toIntFunction = { s: String -> s.length }
16.     val unaryOperator = { s: String -> s.uppercase() }
18.     val biConsumer = { s: String, number: Int -> s.indexOf(number.toChar()) }
19.     val objIntConsumer = { s: String?, value: Int -> println("$s,$value") }
20.     val biPredicate = { word: String, length: Int -> word.length == length }
21.     val biFunction = { word: String?, sentence: String -> sentence.indexOf(word!!) }
22.     val toIntBiFunction = { word: String?, sentence: String -> sentence.indexOf(word!!) }
24.     val a = "aaa"
26.     if (predicate(a)) {
27.         consumer(a)
28.         supplier()
29.         function(a)
31.         intConsumer(1)
32.         intSupplier()
33.         intPredicate(11)
34.         toIntFunction(a)
35.         unaryOperator(a)
37.         biConsumer(a, 2)
38.         objIntConsumer(null, 1)
39.         biPredicate(a, 3)
40.         biFunction("fdsa", a)
41.         toIntBiFunction("fdsa", a)
42.     }
43.     var strings = mutableListOf("a", "bb", "ccc")
44.     strings.forEach(consumer)
45.     strings.removeIf(predicate) //不应该在不可变集合上调用
46.     println(strings)
48.     strings = arrayListOf("a", "bb", "ccc")
49.     strings.replaceAll(unaryOperator)
50.     println(strings)
52.     var i = 0
53.     val add = { s: Int? -> i++ } //不报错
54.     add(i)
55.     println(i)
56. }

复制代码

可以看出：

• Kotlin的lambda，没有那四种划分，调用时类似函数，(参数..)，非常简洁
  
• Kotlin的lambda，可以改变外层变量的值
  
• Kotlin没有自己的removeIf，replaceAll，但可以直接调用Java的
  
• Java为原始类型准备了特别版，Kotlin默认都是原始类型
  
• Kotlin变量默认都是非null
  

这一局，Kotlin胜出。
方法引用、链接

Java

1. import red.burn.bean.User;
3. import Java.util.*;
4. import Java.util.function.*;
5. import Java.util.logging.Logger;
7. /**
8. * @author 烧哥burn.red
9. */
10. public class Test2 {
12.     public static void main(String[] args) {
13.         //方法引用
14.         DoubleUnaryOperator sqrt = Math::sqrt;
15.         IntBinaryOperator max = Integer::max;//静态方法引用
16.         Supplier<List<String>> newListOfStrings = ArrayList::new;//构造方法引用
17.         Consumer<String> printer = System.out::println;//绑定到System.out
18.         Function<String, Integer> toLength = String::length;//非绑定，绑定到String的实例
20.         //Lambla的链接
21.         Predicate<String> isNull = Objects::isNull;
22.         Predicate<String> isEmpty = String::isEmpty;
23.         Predicate<String> isNullOrEmpty = isNull.or(isEmpty);
24.         Predicate<String> isNotNullNorEmpty = isNullOrEmpty.negate();
25.         Predicate<String> shorterThan5 = s -> s.length() < 5;
26.         Predicate<String> p = isNotNullNorEmpty.and(shorterThan5);
28.         Logger logger = Logger.getLogger("MyApplicationLogger");
29.         Consumer<String> log = logger::info;
30.         Consumer<String> printStr = System.out::println;
31.         Consumer<String> printAndLog = log.andThen(printStr);//
32.         printAndLog.accept("test");
34.         Function<String, Integer> function1 = String::length;
35.         Function<Integer, Integer> function2 = s -> ++s;
36.         Function<String, Integer> function = function1.andThen(function2);
37.         System.out.println("new=" + function.apply("abc")); //4
39.         Function<String, String> id = Function.identity();
41.         //Comparator
42.         Comparator<Integer> comparator = Integer::compare;
43.         Comparator<String> comparator1 = (s1, s2) -> Integer.compare(s1.length(), s2.length());
44.         Comparator<String> comparator2 = (s1, s2) -> Integer.compare(toLength.apply(s1), toLength.apply(s2));
45.         Comparator<String> comparator3 = Comparator.comparing(String::length);
47.         Comparator<User> byFirstName = Comparator.comparing(User::getFirstName);
48.         Comparator<User> byLastName = Comparator.comparing(User::getLastName);
49.         Comparator<User> byFirstNameThenLastName = byFirstName.thenComparing(byLastName)
50.                                                               .thenComparingInt(User::getAge);
51.         Comparator<User> byFirstNameThenLastName1 = Comparator.comparingInt(User::getAge)
52.                                                               .thenComparing(
53.                                                                       Comparator.nullsLast(Comparator.naturalOrder()));
55.         List<String> strings = Arrays.asList("one", "two", "three", "four", "five");
56.         strings.sort(comparator3.reversed());
57.         System.out.println(strings);
58.     }
59. }

复制代码

1. import lombok.Builder;
2. import lombok.Data;
3. import org.jetbrains.annotations.NotNull;
5. /**
6. * @author 烧哥burn.red
7. */
8. @Data
9. @Builder
10. public class User implements Comparable<User> {
12.     private String name;
13.     private int age;
14.     private String firstName;
15.     private String lastName;
17.     @Override
18.     public int compareTo(User o) {
20.         return this.name.compareTo(o.name);
21.     }
22. }

复制代码

Kotlin

1. import Java.util.logging.Logger
2. import Kotlin.math.sqrt
3. import red.burn.bean.UserKT
4. import Kotlin.math.max
6. /**
7. *
8. * @author 烧哥burn.red
9. */
10. fun main() {
11.     //方法引用
12.     val sqrt = ::sqrt
13. //    val max = ::max //报错，歧义
14. //    val newListOfStrings = ::ArrayList  //报错，歧义
15. //    val printer =::println //报错，歧义
16.     val ar = 5.run<Int, ArrayList<String>>(::ArrayList)
17.     "a".run(::println)
18.     val kt = ::UserKT //构造方法引用
19.     val user = kt("abc", 10)
20.     var (name, age) = UserKT("csc")
21.     val firstName = user::firstName //属性引用
22.     val addAge = user::addAge //函数引用
23.     val toLength = String::length  //非绑定，绑定到String的实例
25.     //Lambla的链接
26.     val isNull = { obj: String? -> obj == null }
27.     val isEmpty = { obj: String -> obj.isEmpty() }
28.     val isNullOrEmpty = { obj: String? -> obj == null || isEmpty(obj) }
29.     val isNotNullNorEmpty = { obj: String? -> !isNullOrEmpty(obj) }
30.     val shorterThan5 = { s: String -> s.length < 5 }
31.     val p = { s: String -> isNotNullNorEmpty(s).and(shorterThan5(s)) }
33.     val logger = Logger.getLogger("MyApplicationLogger")
34.     val log = { message: String? -> logger.info(message) }
35.     val printStr = { message: String? -> println(message) }
36.     val printAndLog = { message: String? ->
37.         log(message).also { printStr(message) }
38.     }
39.     printAndLog("test")
41.     val function1 = String::length
42. //    val function2 = {  s: Int -> ++s }//报错 Val cannot be reassigned
43.     val function2 = { s: Int ->
44.         var i = s;
45.         ++i;
46.     }
47.     val function = { s: String -> function1(s).let(function2) }
48.     println("new=" + function("abc")) //4
50.     val id = { s: String? -> s }
52.     //Comparator
53.     val comparator = { x: Int, y: Int -> (x).compareTo(y) }
54.     val comparator1 = { s1: String, s2: String -> s1.length.compareTo(s2.length) }
55.     val comparator2 = { s1: String, s2: String -> toLength(s1).compareTo(toLength(s2)) }
56.     val comparator3 = compareBy(String::length)
58.     val byFirstName = compareBy(UserKT::firstName)
59.     val byLastName = compareBy(UserKT::lastName)
60.     val byFirstNameThenLastName = byFirstName.then(byLastName).thenBy(UserKT::age)
61.     val byFirstNameThenLastName1 = compareBy(UserKT::age).then(nullsLast(naturalOrder()))
63.     val strings = arrayListOf("one", "two", "three", "four", "five")
64.     strings.sortWith(comparator3.reversed())
65.     println(strings)
66. }

复制代码

1. /**
2. *
3. * @author 烧哥burn.red
4. */
5. data class UserKT(var name: String, var age: Int = 1) : Comparable<UserKT> {
7.     var firstName: String? = null
8.     var lastName: String? = null
10.     override fun compareTo(other: UserKT): Int {
11.         return name.compareTo(other.name)
12.     }
14.     fun printUser(s: UserKT) {
15.         println(s)
16.     }
18.     fun addAge(i: Int, j: Int): Int {
19.         return i + j
20.     }
22. }

复制代码

可以看出：

• Kotlin的lambda，可以有类引用、函数引用、属性引用、构造引用，其中函数引用不能有歧义
  
• Kotlin的lambda，因为没有四种划分，缺乏Java里丰富的链接方式，不过可以自己实现
  
• Kotlin的lambda，无法修改自己的参数，只能读取
  
• Kotlin可读性比较强，Java容易看的分神
  

这一局，Kotlin跟Java打平。
StreamAPI

Java

1. import Java.util.List;
2. import Java.util.Map;
3. import Java.util.function.*;
4. import Java.util.stream.*;
6. /**
7. * @author 烧哥burn.red
8. */
9. public class Test3 {
10.    
11.     public static void main(String[] args) {
12.         
13.         //flatmap
14.         Function<String, Stream<Integer>> flatParser = s -> {
15.             try {
16.                 return Stream.of(Integer.parseInt(s));
17.             } catch (NumberFormatException e) {
18.             }
19.             return Stream.empty();
20.         };
21.         
22.         List<String> strings = List.of("1", " ", "2", "3 ", "", "3");
23.         List<Integer> ints = strings.stream().flatMap(flatParser).toList();
24.         System.out.println("ints = " + ints);
25.         
26.         //mapMulti
27.         ints = strings.stream().<Integer>mapMulti((string, consumer) -> {
28.             try {
29.                 consumer.accept(Integer.parseInt(string));
30.             } catch (NumberFormatException ignored) {
31.             }
32.         }).toList();
33.         System.out.println("ints = " + ints);
34.         
35.         List<Integer> ints2 = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
36.         List<Integer> result = ints2.stream().skip(2).limit(5).toList();
37.         System.out.println("result = " + result);
38.         
39.         List<Integer> list0 = List.of(1, 2, 3);
40.         List<Integer> list1 = List.of(4, 5, 6);
41.         List<Integer> list2 = List.of(7, 8, 9);
42. // 1st pattern: concat
43.         List<Integer> concat = Stream.concat(list0.stream(), list1.stream()).toList();
44. // 2nd pattern: flatMap
45.         List<Integer> flatMap = Stream.of(list0.stream(), list1.stream(), list2.stream())//类似city的外层组成的流
46.                                       .flatMap(Function.identity()).toList();
47.         System.out.println("concat  = " + concat);
48.         System.out.println("flatMap = " + flatMap);
49.         
50.         //reduce
51.         Stream<String> strings1 = Stream.of("one", "two", "three", "four");
52.         BinaryOperator<Integer> combiner = Integer::sum;
53.         Function<String, Integer> mapper = String::length;
54.         BiFunction<Integer, String, Integer> accumulator = (partialReduction, element) -> partialReduction + mapper.apply(element);
55.         int result1 = strings1.reduce(0, accumulator, combiner);
56.         System.out.println("sum = " + result1);
57.         
58.         //groupby map
59.         List<String> strings2 = List.of("two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve");
60.         Map<Integer, Long> histogram = strings2.stream().collect(Collectors.groupingBy(String::length, Collectors.counting()));
61.         histogram.forEach((k, v) -> System.out.println(k + " :: " + v));
62.         
63.         Map<Long, List<Integer>> map = histogram.entrySet()
64.                                                 .stream()
65.                                                 .collect(Collectors.groupingBy(Map.Entry::getValue,
66.                                                                                Collectors.mapping(Map.Entry::getKey, Collectors.toList())));
67.         Map.Entry<Long, List<Integer>> result2 = map.entrySet().stream().max(Map.Entry.comparingByKey())//再求max
68.                                                     .orElseThrow();
69.         System.out.println("result = " + result2);
70.     }
71. }

复制代码

Kotlin

1. /**
2. * @author 烧哥burn.red
3. */
4. fun main() {
5.    
6.     //flatmap
7.     val flatParser = label@{ s: String ->
8.         try {
9.             return@label listOf(s.toInt())
10.         } catch (_: NumberFormatException) {
11.         }
12.         emptyList<Int>()
13.     }
15.     val strings = listOf("1", " ", "2", "3 ", "", "3")
16.     var ints = strings.flatMap(flatParser)
17.     println("ints = $ints")
19.     //mapMulti
20.     /*ints = strings.mapMulti { string: String, consumer: Consumer<Int?> ->
21.             try {
22.                 consumer.accept(string.toInt())
23.             } catch (ignored: NumberFormatException) {
24.             }
25.         }
26.     println("ints = $ints")*/
28.     val ints2 = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
29.     val result = ints2.drop(2).take(5)
30.     println("result = $result")
32.     val list0 = listOf(1, 2, 3)
33.     val list1 = listOf(4, 5, 6)
34.     val list2 = listOf(7, 8, 9)
35. // 1st pattern: concat
36.     val concat = list0 + list1
37. // 2nd pattern: flatMap
38.     val flatMap = listOf(list0, list1, list2).flatten()
39.     println("concat  = $concat")
40.     println("flatMap = $flatMap")
42.     //reduce
43.     val strings1 = listOf("one", "two", "three", "four")
44.     val mapper = String::length
45.     val accumulator = { partialReduction: Int, element: String -> partialReduction + mapper(element) }
46.     val result1 = strings1.fold(0, accumulator)
47.     println("sum = $result1")
49.      //groupby map
50.     val strings2 = listOf("two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve")
51.     val histogram: Map<Int, Int> = strings2.groupingBy { it.length }.eachCount()
52.     histogram.forEach({ k, v -> println("$k :: $v") })
54.     val map = histogram.map { it }.groupBy({ it.value }, { it.key }).maxBy { it.key }
55.     println(map)
57. }

复制代码

可以看出：

• Kotlin的lambda，不支持multiMap，但可以自己实现
  
• Kotlin有运算符重载，可以对集合进行+-
  
• flatten简化了flatmap,fold简化了reduce,eachCount简化了分组计数
  
• 集合直接就是流，集合上的groupby等直接调用，不需要collect（）
  
• 函数很多有混淆，像groupBy、groupingBy，maxBy、maxOf
  
• 不过中间可能有null，还需要人工判断，不如Java，Optional总不会报错
  
• groupBy({ it.value }, { it.key }).maxBy { it.key }这个能亮瞎
  

总体来说，代码量减少非常多，这局Kotlin胜出。
综合

Java

1. import red.burn.bean.*;
3. import Java.util.*;
4. import Java.util.function.BiFunction;
5. import Java.util.function.Function;
6. import Java.util.stream.*;
8. /**
9. *
10. * @author 烧哥burn.red
11. */
12. public class Test4 {
13.    
14.     public static void main(String[] args) {
15.         
16.         Author au1 = new Author("Au1");
17.         Author au2 = new Author("Au2");
18.         Author au3 = new Author("Au3");
19.         Author au4 = new Author("Au4");
20.         Author au5 = new Author("Au5");
21.         Article a1 = new Article("a1", 1991, List.of(au1));
22.         Article a2 = new Article("a2", 1992, List.of(au1, au2));
23.         Article a3 = new Article("a3", 1993, List.of(au1, au3, au4));
24.         Article a4 = new Article("a4", 1992, List.of(au1, au2, au3, au4));
25.         List<Article> articles = List.of(a1, a2, a3, a4);
26.         
27.         BiFunction<Article, Author, Stream<PairOfAuthors>> buildPairOfAuthors =
28.                 (article, firstAuthor) -> article.authors().stream().flatMap(
29.                         secondAuthor -> PairOfAuthors.of(firstAuthor, secondAuthor).stream());//Optional的Stream
30.         
31.         Function<Article, Stream<PairOfAuthors>> toPairOfAuthors =
32.                 article -> article.authors().stream().flatMap(firstAuthor -> buildPairOfAuthors.apply(article, firstAuthor));
33.         Collector<PairOfAuthors, ?, Map<PairOfAuthors, Long>> collector1 =
34.                 Collectors.groupingBy(Function.identity(), Collectors.counting());
36. //        System.out.println("numberOfAuthorsTogether=" + numberOfAuthorsTogether);
37.         Function<Map<PairOfAuthors, Long>, Map.Entry<PairOfAuthors, Long>> finisher1 =
38.                 map1 -> map1.entrySet().stream().max(Map.Entry.comparingByValue()).orElseThrow();
39.         
40.         Map.Entry<PairOfAuthors, Long> result11 =
41.                 articles.stream().flatMap(toPairOfAuthors).collect(Collectors.collectingAndThen(collector1, finisher1));
42.         
43.         Map.Entry<PairOfAuthors, Long> result12 =
44.                 articles.stream().collect(Collectors.flatMapping(toPairOfAuthors, Collectors.collectingAndThen(collector1, finisher1)));
45.         
46.         //找出每年发表文章最多的两位联合作者
47.         Collector<Article, ?, Optional<Map.Entry<PairOfAuthors, Long>>> flatMapping = Collectors.flatMapping(toPairOfAuthors,
48.                                                                                                              Collectors.collectingAndThen(
49.                                                                                                                      collector1,
50.                                                                                                                      map2 -> map2.entrySet()
51.                                                                                                                                  .stream()
52.                                                                                                                                  .max(Map.Entry.comparingByValue())));
53.         Map<Integer, Optional<Map.Entry<PairOfAuthors, Long>>> result13 =
54.                 articles.stream().collect(Collectors.groupingBy(Article::inceptionYear, flatMapping));
55.         Map<Integer, Map.Entry<PairOfAuthors, Long>> result14 = result13.entrySet()
56.                                                                         .stream()
57.                                                                         .flatMap(entry -> entry.getValue()
58.                                                                                                .map(value -> Map.entry(entry.getKey(),
59.                                                                                                                        value))
60.                                                                                                .stream())
61.                                                                         .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
62.         
63.         System.out.println(result11);
64.         System.out.println(result12);
65.         System.out.println(result13);
66.         System.out.println(result14);
67.     }
68. }

复制代码

1. public record Article(String title, int inceptionYear, List<Author> authors) {
3. }
4. public record Author(String name) implements Comparable<Author> {
5.    
6.     public int compareTo(Author other) {
7.         
8.         return this.name.compareTo(other.name);
9.     }
10. }
12. public record PairOfAuthors(Author first, Author second) {
13.    
14.     public static Optional<PairOfAuthors> of(Author first, Author second) {
15.         
16.         if (first.compareTo(second) > 0) {
17.             return Optional.of(new PairOfAuthors(first, second));
18.         } else {
19.             return Optional.empty();
20.         }
21.     }
22. }

复制代码

Kotlin
[code][/code]可以看出：

• 这个例子主要体现Optional跟StreamAPI的结合，Kotlin里没有Optional，所以很难写出。
  

这局Java胜。
最终

Kotlin以2:1微弱优势胜出。
Java用他的严谨，证明能实现从简单到复杂的各种场景。
Kotlin用它的简洁，通常情况下能减少工作量。
Kotlin还提供了委托、扩展、运算符重载、作用域函数、协程等等。
子曾经曰过”越简洁，越有坑“。想完全用Kotlin取代Java，还有一段路，目前二者可以互操作，建议同时使用。
复杂场景下，用什么语言并不是决定性的，解决方案才是。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！