Java 转 Kotlin 自查表，轻松跨语言开发！

**Java 转 Kotlin 自查表** 

和 Flutter 一样，Kotlin 现在也很火，很多人愿意去学习尝试写 Kotlin。有时知道 Java 语言该如何写，就是不知道 Kotlin 语言该如何下手。以此文记录一些 Java 转换为 Kotlin 的使用方法。

本文参考 From Java to Kotlin，特此整理，用于自查。

每一行代码都是一种方法，从上到下，难度和深入程度递增，适合所有程度的开发者。

1. **变量声明** 

   * Java：
     ```java
     int a = 1;
     ```
   * Kotlin：
     ```kotlin
     val a: Int = 1
     ```

2. **类型推断** 

   * Java：
     ```java
     int a = 1;
     ```
   * Kotlin：
     ```kotlin
     val a = 1
     ```

3. **常量声明** 

   * Java：
     ```java
     final int a = 1;
     ```
   * Kotlin：
     ```kotlin
     val a = 1
     ```

4. **方法声明** 

   * Java：
     ```java
     public static void main(String[] args) {
       System.out.println("Hello, World!");
     }
     ```
   * Kotlin：
     ```kotlin
     fun main(args: Array<String>) {
       println("Hello, World!")
     }
     ```

5. **方法参数** 

   * Java：
     ```java
     public static void printHello(String name) {
       System.out.println("Hello, " + name + "!");
     }
     ```
   * Kotlin：
     ```kotlin
     fun printHello(name: String) {
       println("Hello, $name!")
     }
     ```

6. **方法返回值** 

   * Java：
     ```java
     public static int sum(int a, int b) {
       return a + b;
     }
     ```
   * Kotlin：
     ```kotlin
     fun sum(a: Int, b: Int): Int {
       return a + b
     }
     ```

7. **条件语句** 

   * Java：
     ```java
     if (a > 0) {
       System.out.println("a is positive");
     } else {
       System.out.println("a is negative");
     }
     ```
   * Kotlin：
     ```kotlin
     if (a > 0) println("a is positive") else println("a is negative")
     ```

8. **循环语句** 

   * Java：
     ```java
     for (int i = 0; i < 10; i++) {
       System.out.println(i);
     }
     ```
   * Kotlin：
     ```kotlin
     for (i in 0 until 10) {
       println(i)
     }
     ```

9. **数组声明** 

   * Java：
     ```java
     int[] a = new int[10];
     ```
   * Kotlin：
     ```kotlin
     val a = IntArray(10)
     ```

10. **数组元素访问** 

    * Java：
      ```java
      int a = arr[0];
      ```
    * Kotlin：
      ```kotlin
      val a = arr[0]
      ```

11. **列表声明** 

    * Java：
      ```java
      List<Integer> list = new ArrayList<>();
      ```
    * Kotlin：
      ```kotlin
      val list = mutableListOf<Int>()
      ```

12. **列表元素访问** 

    * Java：
      ```java
      int a = list.get(0);
      ```
    * Kotlin：
      ```kotlin
      val a = list[0]
      ```

13. **映射声明** 

    * Java：
      ```java
      Map<String, Integer> map = new HashMap<>();
      ```
    * Kotlin：
      ```kotlin
      val map = mutableMapOf<String, Int>()
      ```

14. **映射元素访问** 

    * Java：
      ```java
      int a = map.get("key");
      ```
    * Kotlin：
      ```kotlin
      val a = map["key"]
      ```

15. **函数声明** 

    * Java：
      ```java
      public static int sum(int a, int b) {
        return a + b;
      }
      ```
    * Kotlin：
      ```kotlin
      fun sum(a: Int, b: Int) = a + b
      ```

16. **Lambda 表达式** 

    * Java：
      ```java
      List<Integer> list = new ArrayList<>();
      list.forEach((Integer i) -> System.out.println(i));
      ```
    * Kotlin：
      ```kotlin
      val list = mutableListOf<Int>()
      list.forEach { println(it) }
      ```

17. **协程声明** 

    * Java：
      ```java
      new Thread(() -> {
        // Do something
      }).start();
      ```
    * Kotlin：
      ```kotlin
      launch {
        // Do something
      }
      ```

18. **并发编程** 

    * Java：
      ```java
      ExecutorService executorService = Executors.newFixedThreadPool(10);
      executorService.submit(() -> {
        // Do something
      });
      ```
    * Kotlin：
      ```kotlin
      val executorService = Executors.newFixedThreadPool(10)
      executorService.submit {
        // Do something
      }
      ```

19. **流式编程** 

    * Java：
      ```java
      List<Integer> list = new ArrayList<>();
      list.stream().filter(i -> i > 0).map(i -> i * 2).forEach(System.out::println);
      ```
    * Kotlin：
      ```kotlin
      val list = mutableListOf<Int>()
      list.filter { it > 0 }.map { it * 2 }.forEach { println(it) }
      ```

20. **面向对象编程** 

    * Java：
      ```java
      public class MyClass {
        private int a;

        public MyClass(int a) {
          this.a = a;
        }

        public int getA() {
          return a;
        }

        public void setA(int a) {
          this.a = a;
        }
      }
      ```
    * Kotlin：
      ```kotlin
      class MyClass(private var a: Int) {
        fun getA() = a
        fun setA(a: Int) {
          this.a = a
        }
      }
      ```

希望这份 Java 转 Kotlin 自查表对您有所帮助。如果您有任何问题，请随时留言。