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

出于各种限制,很多公司依然停留在Java8,部分小伙伴转向了Kotlin。Kotlin作为静态编译语言,提供大量语法糖,而且编译后的字节码跟Java一致。

当时,Java8于2014年发布,Kotlin于2016年,很多宣称的语法糖都是对比的Java8。不禁要问,相对今天的Java17,Kotlin优势还在吗?

现在就用最新的Kotlin1.9.0,对前三篇文章里的lambda、StreamAPI依次改造,实践出真知!

编写lambda、调用

Java

import Java.util.*;
import Java.util.function.*;

/**
 *
 * @author 烧哥burn.red
 */
public class Test1 {
    
    public static void main(String[] args) {
        
        Predicate<String> predicate = s -> s.length() == 3;
        Consumer<String> consumer = s -> System.out.println(s);
        Supplier<String> supplier = () -> "Hello Duke!";
        Function<String, Integer> function = s -> s.length();
        
        IntSupplier intSupplier = () -> 1;
        IntConsumer intConsumer = s -> System.out.println(s);
        IntPredicate intPredicate = i -> i > 10;
        ToIntFunction<String> toIntFunction = s -> s.length();
        UnaryOperator<String> unaryOperator = s -> s.toUpperCase();
        
        BiConsumer<String, Integer> biConsumer = (s, number) -> s.indexOf(number);
        ObjIntConsumer<String> objIntConsumer = (s, value) -> System.out.printf("%s,%d\n", s, value);
        BiPredicate<String, Integer> biPredicate = (word, length) -> word.length() == length;
        BiFunction<String, String, Integer> biFunction = (word, sentence) -> sentence.indexOf(word);
        ToIntBiFunction<String, String> toIntBiFunction = (word, sentence) -> sentence.indexOf(word);
        
        String a = "aaa";
        
        if (predicate.test(a)) {
            consumer.accept(a);
            supplier.get();
            function.apply(a);
            
            intConsumer.accept(1);
            intSupplier.getAsInt();
            intPredicate.test(11);
            toIntFunction.applyAsInt(a);
            unaryOperator.apply(a);
            
            biConsumer.accept(a, 2);
            objIntConsumer.accept(null, 1);
            biPredicate.test(a, 3);
            biFunction.apply("fdsa", a);
            toIntBiFunction.applyAsInt("fdsa", a);
        }
        List<String> strings = new ArrayList<>(List.of("a", "bb", "ccc"));
        strings.forEach(consumer);
        strings.removeIf(predicate);//不应该在不可变集合上调用
        System.out.println(strings);
        
        strings = Arrays.asList("a", "bb", "ccc");
        strings.replaceAll(unaryOperator);
        System.out.println(strings);

//        int i = 0;
//        Consumer<Integer> add = s -> i++;//报错,从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量
    }
}

Kotlin

/**
 *
 * @author 烧哥burn.red
 */

fun main() {
    val predicate = { s: String -> s.length == 3 }
    val consumer = { s: String? -> println(s) }
    val supplier = { "Hello Duke!" }
    val function = { s: String -> s.length }

    val intSupplier = { 1 }
    val intConsumer = { s: Int -> println(s) }
    val intPredicate = { i: Int -> i > 10 }
    val toIntFunction = { s: String -> s.length }
    val unaryOperator = { s: String -> s.uppercase() }

    val biConsumer = { s: String, number: Int -> s.indexOf(number.toChar()) }
    val objIntConsumer = { s: String?, value: Int -> println("$s,$value") }
    val biPredicate = { word: String, length: Int -> word.length == length }
    val biFunction = { word: String?, sentence: String -> sentence.indexOf(word!!) }
    val toIntBiFunction = { word: String?, sentence: String -> sentence.indexOf(word!!) }

    val a = "aaa"

    if (predicate(a)) {
        consumer(a)
        supplier()
        function(a)

        intConsumer(1)
        intSupplier()
        intPredicate(11)
        toIntFunction(a)
        unaryOperator(a)

        biConsumer(a, 2)
        objIntConsumer(null, 1)
        biPredicate(a, 3)
        biFunction("fdsa", a)
        toIntBiFunction("fdsa", a)
    }
    var strings = mutableListOf("a", "bb", "ccc")
    strings.forEach(consumer)
    strings.removeIf(predicate) //不应该在不可变集合上调用
    println(strings)

    strings = arrayListOf("a", "bb", "ccc")
    strings.replaceAll(unaryOperator)
    println(strings)

    var i = 0
    val add = { s: Int? -> i++ } //不报错
    add(i)
    println(i)
}

可以看出:

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

这一局,Kotlin胜出。

方法引用、链接

Java

import red.burn.bean.User;

import Java.util.*;
import Java.util.function.*;
import Java.util.logging.Logger;

/**
 * @author 烧哥burn.red
 */
public class Test2 {

    public static void main(String[] args) {
        //方法引用
        DoubleUnaryOperator sqrt = Math::sqrt;
        IntBinaryOperator max = Integer::max;//静态方法引用
        Supplier<List<String>> newListOfStrings = ArrayList::new;//构造方法引用
        Consumer<String> printer = System.out::println;//绑定到System.out
        Function<String, Integer> toLength = String::length;//非绑定,绑定到String的实例

        //Lambla的链接
        Predicate<String> isNull = Objects::isNull;
        Predicate<String> isEmpty = String::isEmpty;
        Predicate<String> isNullOrEmpty = isNull.or(isEmpty);
        Predicate<String> isNotNullNorEmpty = isNullOrEmpty.negate();
        Predicate<String> shorterThan5 = s -> s.length() < 5;
        Predicate<String> p = isNotNullNorEmpty.and(shorterThan5);

        Logger logger = Logger.getLogger("MyApplicationLogger");
        Consumer<String> log = logger::info;
        Consumer<String> printStr = System.out::println;
        Consumer<String> printAndLog = log.andThen(printStr);//
        printAndLog.accept("test");

        Function<String, Integer> function1 = String::length;
        Function<Integer, Integer> function2 = s -> ++s;
        Function<String, Integer> function = function1.andThen(function2);
        System.out.println("new=" + function.apply("abc")); //4

        Function<String, String> id = Function.identity();

        //Comparator
        Comparator<Integer> comparator = Integer::compare;
        Comparator<String> comparator1 = (s1, s2) -> Integer.compare(s1.length(), s2.length());
        Comparator<String> comparator2 = (s1, s2) -> Integer.compare(toLength.apply(s1), toLength.apply(s2));
        Comparator<String> comparator3 = Comparator.comparing(String::length);

        Comparator<User> byFirstName = Comparator.comparing(User::getFirstName);
        Comparator<User> byLastName = Comparator.comparing(User::getLastName);
        Comparator<User> byFirstNameThenLastName = byFirstName.thenComparing(byLastName)
                                                              .thenComparingInt(User::getAge);
        Comparator<User> byFirstNameThenLastName1 = Comparator.comparingInt(User::getAge)
                                                              .thenComparing(
                                                                      Comparator.nullsLast(Comparator.naturalOrder()));

        List<String> strings = Arrays.asList("one", "two", "three", "four", "five");
        strings.sort(comparator3.reversed());
        System.out.println(strings);
    }
}
import lombok.Builder;
import lombok.Data;
import org.jetbrains.annotations.NotNull;

/**
 * @author 烧哥burn.red
 */
@Data
@Builder
public class User implements Comparable<User> {

    private String name;
    private int age;
    private String firstName;
    private String lastName;

    @Override
    public int compareTo(User o) {

        return this.name.compareTo(o.name);
    }
}

Kotlin

import Java.util.logging.Logger
import Kotlin.math.sqrt
import red.burn.bean.UserKT
import Kotlin.math.max

/**
 *
 * @author 烧哥burn.red
 */
fun main() {
    //方法引用
    val sqrt = ::sqrt
//    val max = ::max //报错,歧义
//    val newListOfStrings = ::ArrayList  //报错,歧义
//    val printer =::println //报错,歧义
    val ar = 5.run<Int, ArrayList<String>>(::ArrayList)
    "a".run(::println)
    val kt = ::UserKT //构造方法引用
    val user = kt("abc", 10)
    var (name, age) = UserKT("csc")
    val firstName = user::firstName //属性引用
    val addAge = user::addAge //函数引用
    val toLength = String::length  //非绑定,绑定到String的实例

    //Lambla的链接
    val isNull = { obj: String? -> obj == null }
    val isEmpty = { obj: String -> obj.isEmpty() }
    val isNullOrEmpty = { obj: String? -> obj == null || isEmpty(obj) }
    val isNotNullNorEmpty = { obj: String? -> !isNullOrEmpty(obj) }
    val shorterThan5 = { s: String -> s.length < 5 }
    val p = { s: String -> isNotNullNorEmpty(s).and(shorterThan5(s)) }

    val logger = Logger.getLogger("MyApplicationLogger")
    val log = { message: String? -> logger.info(message) }
    val printStr = { message: String? -> println(message) }
    val printAndLog = { message: String? ->
        log(message).also { printStr(message) }
    }
    printAndLog("test")

    val function1 = String::length
//    val function2 = {  s: Int -> ++s }//报错 Val cannot be reassigned
    val function2 = { s: Int ->
        var i = s;
        ++i;
    }
    val function = { s: String -> function1(s).let(function2) }
    println("new=" + function("abc")) //4

    val id = { s: String? -> s }

    //Comparator
    val comparator = { x: Int, y: Int -> (x).compareTo(y) }
    val comparator1 = { s1: String, s2: String -> s1.length.compareTo(s2.length) }
    val comparator2 = { s1: String, s2: String -> toLength(s1).compareTo(toLength(s2)) }
    val comparator3 = compareBy(String::length)

    val byFirstName = compareBy(UserKT::firstName)
    val byLastName = compareBy(UserKT::lastName)
    val byFirstNameThenLastName = byFirstName.then(byLastName).thenBy(UserKT::age)
    val byFirstNameThenLastName1 = compareBy(UserKT::age).then(nullsLast(naturalOrder()))

    val strings = arrayListOf("one", "two", "three", "four", "five")
    strings.sortWith(comparator3.reversed())
    println(strings)
}

/**
 *
 * @author 烧哥burn.red
 */
data class UserKT(var name: String, var age: Int = 1) : Comparable<UserKT> {

    var firstName: String? = null
    var lastName: String? = null

    override fun compareTo(other: UserKT): Int {
        return name.compareTo(other.name)
    }

    fun printUser(s: UserKT) {
        println(s)
    }

    fun addAge(i: Int, j: Int): Int {
        return i + j
    }

}

可以看出:

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

这一局,Kotlin跟Java打平。

StreamAPI

Java

import Java.util.List;
import Java.util.Map;
import Java.util.function.*;
import Java.util.stream.*;

/**
 * @author 烧哥burn.red
 */
public class Test3 {
    
    public static void main(String[] args) {
        
        //flatmap
        Function<String, Stream<Integer>> flatParser = s -> {
            try {
                return Stream.of(Integer.parseInt(s));
            } catch (NumberFormatException e) {
            }
            return Stream.empty();
        };
        
        List<String> strings = List.of("1", " ", "2", "3 ", "", "3");
        List<Integer> ints = strings.stream().flatMap(flatParser).toList();
        System.out.println("ints = " + ints);
        
        //mapMulti
        ints = strings.stream().<Integer>mapMulti((string, consumer) -> {
            try {
                consumer.accept(Integer.parseInt(string));
            } catch (NumberFormatException ignored) {
            }
        }).toList();
        System.out.println("ints = " + ints);
        
        List<Integer> ints2 = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
        List<Integer> result = ints2.stream().skip(2).limit(5).toList();
        System.out.println("result = " + result);
        
        List<Integer> list0 = List.of(1, 2, 3);
        List<Integer> list1 = List.of(4, 5, 6);
        List<Integer> list2 = List.of(7, 8, 9);
// 1st pattern: concat
        List<Integer> concat = Stream.concat(list0.stream(), list1.stream()).toList();
// 2nd pattern: flatMap
        List<Integer> flatMap = Stream.of(list0.stream(), list1.stream(), list2.stream())//类似city的外层组成的流
                                      .flatMap(Function.identity()).toList();
        System.out.println("concat  = " + concat);
        System.out.println("flatMap = " + flatMap);
        
        //reduce
        Stream<String> strings1 = Stream.of("one", "two", "three", "four");
        BinaryOperator<Integer> combiner = Integer::sum;
        Function<String, Integer> mapper = String::length;
        BiFunction<Integer, String, Integer> accumulator = (partialReduction, element) -> partialReduction + mapper.apply(element);
        int result1 = strings1.reduce(0, accumulator, combiner);
        System.out.println("sum = " + result1);
        
        //groupby map
        List<String> strings2 = List.of("two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve");
        Map<Integer, Long> histogram = strings2.stream().collect(Collectors.groupingBy(String::length, Collectors.counting()));
        histogram.forEach((k, v) -> System.out.println(k + " :: " + v));
        
        Map<Long, List<Integer>> map = histogram.entrySet()
                                                .stream()
                                                .collect(Collectors.groupingBy(Map.Entry::getValue,
                                                                               Collectors.mapping(Map.Entry::getKey, Collectors.toList())));
        Map.Entry<Long, List<Integer>> result2 = map.entrySet().stream().max(Map.Entry.comparingByKey())//再求max
                                                    .orElseThrow();
        System.out.println("result = " + result2);
    }
}

Kotlin

/**
 * @author 烧哥burn.red
 */
fun main() {
    
    //flatmap
    val flatParser = label@{ s: String ->
        try {
            return@label listOf(s.toInt())
        } catch (_: NumberFormatException) {
        }
        emptyList<Int>()
    }

    val strings = listOf("1", " ", "2", "3 ", "", "3")
    var ints = strings.flatMap(flatParser)
    println("ints = $ints")

    //mapMulti
    /*ints = strings.mapMulti { string: String, consumer: Consumer<Int?> ->
            try {
                consumer.accept(string.toInt())
            } catch (ignored: NumberFormatException) {
            }
        }
    println("ints = $ints")*/

    val ints2 = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
    val result = ints2.drop(2).take(5)
    println("result = $result")

    val list0 = listOf(1, 2, 3)
    val list1 = listOf(4, 5, 6)
    val list2 = listOf(7, 8, 9)
// 1st pattern: concat
    val concat = list0 + list1
// 2nd pattern: flatMap
    val flatMap = listOf(list0, list1, list2).flatten()
    println("concat  = $concat")
    println("flatMap = $flatMap")

    //reduce
    val strings1 = listOf("one", "two", "three", "four")
    val mapper = String::length
    val accumulator = { partialReduction: Int, element: String -> partialReduction + mapper(element) }
    val result1 = strings1.fold(0, accumulator)
    println("sum = $result1")

     //groupby map
    val strings2 = listOf("two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve")
    val histogram: Map<Int, Int> = strings2.groupingBy { it.length }.eachCount()
    histogram.forEach({ k, v -> println("$k :: $v") })

    val map = histogram.map { it }.groupBy({ it.value }, { it.key }).maxBy { it.key }
    println(map)

}

可以看出:

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

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

综合

Java

import red.burn.bean.*;

import Java.util.*;
import Java.util.function.BiFunction;
import Java.util.function.Function;
import Java.util.stream.*;

/**
 *
 * @author 烧哥burn.red
 */
public class Test4 {
    
    public static void main(String[] args) {
        
        Author au1 = new Author("Au1");
        Author au2 = new Author("Au2");
        Author au3 = new Author("Au3");
        Author au4 = new Author("Au4");
        Author au5 = new Author("Au5");
        Article a1 = new Article("a1", 1991, List.of(au1));
        Article a2 = new Article("a2", 1992, List.of(au1, au2));
        Article a3 = new Article("a3", 1993, List.of(au1, au3, au4));
        Article a4 = new Article("a4", 1992, List.of(au1, au2, au3, au4));
        List<Article> articles = List.of(a1, a2, a3, a4);
        
        BiFunction<Article, Author, Stream<PairOfAuthors>> buildPairOfAuthors =
                (article, firstAuthor) -> article.authors().stream().flatMap(
                        secondAuthor -> PairOfAuthors.of(firstAuthor, secondAuthor).stream());//Optional的Stream
        
        Function<Article, Stream<PairOfAuthors>> toPairOfAuthors =
                article -> article.authors().stream().flatMap(firstAuthor -> buildPairOfAuthors.apply(article, firstAuthor));
        Collector<PairOfAuthors, ?, Map<PairOfAuthors, Long>> collector1 =
                Collectors.groupingBy(Function.identity(), Collectors.counting());

//        System.out.println("numberOfAuthorsTogether=" + numberOfAuthorsTogether);
        Function<Map<PairOfAuthors, Long>, Map.Entry<PairOfAuthors, Long>> finisher1 =
                map1 -> map1.entrySet().stream().max(Map.Entry.comparingByValue()).orElseThrow();
        
        Map.Entry<PairOfAuthors, Long> result11 =
                articles.stream().flatMap(toPairOfAuthors).collect(Collectors.collectingAndThen(collector1, finisher1));
        
        Map.Entry<PairOfAuthors, Long> result12 =
                articles.stream().collect(Collectors.flatMapping(toPairOfAuthors, Collectors.collectingAndThen(collector1, finisher1)));
        
        //找出每年发表文章最多的两位联合作者
        Collector<Article, ?, Optional<Map.Entry<PairOfAuthors, Long>>> flatMapping = Collectors.flatMapping(toPairOfAuthors,
                                                                                                             Collectors.collectingAndThen(
                                                                                                                     collector1,
                                                                                                                     map2 -> map2.entrySet()
                                                                                                                                 .stream()
                                                                                                                                 .max(Map.Entry.comparingByValue())));
        Map<Integer, Optional<Map.Entry<PairOfAuthors, Long>>> result13 =
                articles.stream().collect(Collectors.groupingBy(Article::inceptionYear, flatMapping));
        Map<Integer, Map.Entry<PairOfAuthors, Long>> result14 = result13.entrySet()
                                                                        .stream()
                                                                        .flatMap(entry -> entry.getValue()
                                                                                               .map(value -> Map.entry(entry.getKey(),
                                                                                                                       value))
                                                                                               .stream())
                                                                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
        
        System.out.println(result11);
        System.out.println(result12);
        System.out.println(result13);
        System.out.println(result14);
    }
}
public record Article(String title, int inceptionYear, List<Author> authors) {

}
public record Author(String name) implements Comparable<Author> {
    
    public int compareTo(Author other) {
        
        return this.name.compareTo(other.name);
    }
}

public record PairOfAuthors(Author first, Author second) {
    
    public static Optional<PairOfAuthors> of(Author first, Author second) {
        
        if (first.compareTo(second) > 0) {
            return Optional.of(new PairOfAuthors(first, second));
        } else {
            return Optional.empty();
        }
    }
}

Kotlin


可以看出:

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

这局Java胜。

最终

Kotlin以2:1微弱优势胜出。

Java用他的严谨,证明能实现从简单到复杂的各种场景。

Kotlin用它的简洁,通常情况下能减少工作量。

Kotlin还提供了委托、扩展、运算符重载、作用域函数、协程等等。

子曾经曰过”越简洁,越有坑“。想完全用Kotlin取代Java,还有一段路,目前二者可以互操作,建议同时使用。

复杂场景下,用什么语言并不是决定性的,解决方案才是。

热门相关:总裁别再玩了   富贵不能吟   万古至尊   金粉   戏精老公今天作死没