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

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

Basic(基本的)

每一个栗子，分割线上面是Java的写法，下面是Kotlin的写法。

print(打印)

System.out.print("Hello, World!");
System.out.println("Hello, World!");
------------------------------------
print("Hello, World!")
println("Hello, World!")

Variables(变量)

final int x;
final int y = 1;
----------------
val x: Int
val y = 1

int w;
int z = 2;
z = 3;
w = 1;
-----------
var w: Int
var z = 2
z = 3
w = 1 

Null

final String name = null;

String lastName;
lastName = null
---------------------------------------
val name: String? = null

var lastName: String?
lastName = null

var firstName: String
firstName = null // Compilation error!!

if(text != null){
  int length = text.length();
}
------------------------------------------------------------------
val length = text?.length

val length = text!!.length // NullPointerException if text == null

String

String name = "John";
String lastName = "Smith";
String text = "My name is: " + name + " " + lastName;
String otherText = "My name is: " + name.substring(2);
------------------------------------------------------
val name = "John"
val lastName = "Smith"
val text = "My name is: $name $lastName"
val otherText = "My name is: ${name.substring(2)}"

String text = "First Line\n" +
              "Second Line\n" +
              "Third Line";
-------------------------------
val text = """
        |First Line
        |Second Line
        |Third Line
""".trimMargin()

Ternary Operator(三元运算)

String text = x > 5 ? "x > 5" : "x <= 5";
-----------------------------------------
val text = if (x > 5)
              "x > 5"
            else "x <= 5"

Bits Operations(位运算)

final int andResult  = a & b;
final int orResult   = a | b;
final int xorResult  = a ^ b;
final int rightShift = a >> 2;
final int leftShift  = a << 2;
------------------------------
val andResult  = a and b
val orResult   = a or b
val xorResult  = a xor b
val rightShift = a shr 2
val leftShift  = a shl 2

Is As In

if(x instanceof Integer){ }

final String text = (String) other;

if(x >= 0 && x <= 10 ){}
-----------------------------------
if (x is Int) { }

val text = other as String

if (x in 0..10) { }

Smart Cast

if(a instanceof String){
  final String result = ((String) a).substring(1);
}
--------------------------------------------------
if (a is String) {
  val result = a.substring(1)
}

Switch / When

final int x = // value;
final String xResult;

switch (x){
  case 0:
  case 11:
    xResult = "0 or 11";
    break;
  case 1:
  case 2:
    //...
  case 10:
    xResult = "from 1 to 10";
    break;
  default:
    if(x < 12 && x > 14) {
      xResult = "not from 12 to 14";
      break;
    }
    if(isOdd(x)) {
      xResult = "is odd";
      break;
    }
    xResult = "otherwise";
}

final int y = // value;
final String yResult;

if(isNegative(y)){
  yResult = "is Negative";
} else if(isZero(y)){
  yResult = "is Zero";
}else if(isOdd(y)){
  yResult = "is Odd";
}else {
  yResult = "otherwise";
}
---------------------------------
val x = // value
val xResult = when (x) {
  0, 11 -> "0 or 11"
  in 1..10 -> "from 1 to 10"
  !in 12..14 -> "not from 12 to 14"
  else -> if (isOdd(x)) { "is odd" } else { "otherwise" }
}

val y = // value
val yResult = when {
  isNegative(y) -> "is Negative"
  isZero(y) -> "is Zero"
  isOdd(y) -> "is odd"
  else -> "otherwise"
}

For

for (int i = 1; i < 11 ; i++) { }

for (int i = 1; i < 11 ; i+=2) { }

for (String item : collection) { }

for (Map.Entry<String, String> entry: map.entrySet()) { }
---------------------------------------------------------
for (i in 1 until 11) { }

for (i in 1..10 step 2) {}

for (item in collection) {}
for ((index, item) in collection.withIndex()) {}

for ((key, value) in map) {}

Collections

final List<Integer> numbers = Arrays.asList(1, 2, 3);

final Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "One");
map.put(2, "Two");
map.put(3, "Three");


// Java 9
final List<Integer> numbers = List.of(1, 2, 3);

final Map<Integer, String> map = Map.of(1, "One",
                                        2, "Two",
                                        3, "Three");
----------------------------------------------------
val numbers = listOf(1, 2, 3)

val map = mapOf(1 to "One",
                2 to "Two",
                3 to "Three")
                

for (int number : numbers) {
  System.out.println(number);
}

for (int number : numbers) {
  if(number > 5) {
    System.out.println(number);
  }
}
-------------------------------
numbers.forEach {
    println(it)
}

numbers.filter  { it > 5 }
       .forEach { println(it) }

final Map<String, List<Integer>> groups = new HashMap<>();
for (int number : numbers) {
  if((number & 1) == 0){
    if(!groups.containsKey("even")){
      groups.put("even", new ArrayList<>());
    }

    groups.get("even").add(number);
    continue;
  }

  if(!groups.containsKey("odd")){
    groups.put("odd", new ArrayList<>());
  }

  groups.get("odd").add(number);
}

// or

Map<String, List<Integer>> groups = items.stream().collect(
  Collectors.groupingBy(item -> (item & 1) == 0 ? "even" : "odd")
);
-------------------------------------------------------------------
val groups = numbers.groupBy {
                if (it and 1 == 0) "even" else "odd"
             }

final List<Integer> evens = new ArrayList<>();
final List<Integer> odds = new ArrayList<>();
for (int number : numbers){
  if ((number & 1) == 0) {
    evens.add(number);
  }else {
    odds.add(number);
  }
}
----------------------------------------------
val (evens, odds) = numbers.partition { it and 1 == 0 }

final List<User> users = getUsers();

Collections.sort(users, new Comparator<User>(){
  public int compare(User user, User otherUser){
    return user.lastname.compareTo(otherUser.lastname);
  }
});

// or

users.sort(Comparator.comparing(user -> user.lastname));
---------------------------------------------------------
val users = getUsers()
users.sortedBy { it.lastname }

FUNCTIONS

Basic Function

public void hello() {
  System.out.print("Hello, World!");
}
------------------------------------
fun hello() {
    println("Hello, World!")
}

Arguments

public void hello(String name){
  System.out.print("Hello, " + name + "!");
}
-------------------------------------------
fun hello(name: String) {
    println("Hello, $name!")
}

Default Values

public void hello(String name) {
  if (name == null) {
    name = "World";
  }

  System.out.print("Hello, " + name + "!");
}
-------------------------------------------
fun hello(name: String = "World") {
    println("Hello, $name!")
}

Return

public boolean hasItems() {
  return true;
}
---------------------------
fun hasItems() : Boolean {
    return true
}

Single-Expression

public double cube(double x) {
  return x * x * x;
}
------------------------------
fun cube(x: Double) : Double = x * x * x

Vararg(可变参数)

public int sum(int... numbers) { }
----------------------------------
fun sum(vararg x: Int) { }

Main

public class MyClass {
    public static void main(String[] args){

    }
}
-------------------------------------------
fun main(args: Array<String>) {

}

Named Arguments

public static void main(String[]args){
  openFile("file.txt", true);
}

public static File openFile(String filename, boolean readOnly) { }
------------------------------------------------------------------
fun main(args: Array<String>) {
  openFile("file.txt", readOnly = true)
}

fun openFile(filename: String, readOnly: Boolean) : File { }

Optional Arguments

public static void main(String[]args){
  createFile("file.txt");

  createFile("file.txt", true);

  createFile("file.txt", true, false);

  createExecutableFile("file.txt");
}

public static File createFile(String filename) { }

public static File createFile(String filename, boolean appendDate) { }

public static File createFile(String filename, boolean appendDate,
                              boolean executable) { }

public static File createExecutableFile(String filename) { }
-----------------------------------------------------------------------
fun main(args: Array<String>) {
  createFile("file.txt")

  createFile("file.txt", true)
  createFile("file.txt", appendDate = true)

  createFile("file.txt", true, false)
  createFile("file.txt", appendDate = true, executable = true)

  createFile("file.txt", executable = true)
}

fun createFile(filename: String, appendDate: Boolean = false,
               executable: Boolean = false): File { }

Generic Methods

public void init() {
  List<String> moduleInferred = createList("net");
}

public <T> List<T> createList(T item) { }
--------------------------------------------------
fun init() {
  val module = createList<String>("net")
  val moduleInferred = createList("net")
}

fun <T> createList(item: T): List<T> { }

Data Classes - Destructuring

public static void main(String[]args) {
    Book book = createBook();

    System.out.println(book);
    System.out.println("Title: " + book.title);
}

public static Book createBook(){
    return new Book("title_01", "author_01");
}

public class Book {
    final private String title;
    final private String author;

    public Book(String title, String author) {
        this.title = title;
        this.author = author;
    }

    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    @Override
    public String toString() {
        return "Title: " + title + " Author: " + author;
    }
}
--------------------------------------------------------
fun main(args: Array<String>) {
    val book = createBook();
    // or
    val (title, author) = createBook()

    println(book)
    println("Title: $title")
}

fun createBook() : Book{
    return Book("title_01", "author_01")
}

data class Book(val title: String, val author: String)

CLASSES

Constructor Call

final File file = new File("file.txt");
---------------------------------------
val file = File("file.txt")

Class

public final class User {
}
-------------------------
class User

Open Class

public class User {
}
-------------------
open class User

Final Attributes

final class User {
     private final String name;

     public User(String name) {
         this.name = name;
     }

     public String getName() {
         return name;
     }
 }
 ------------------------------
 class User(val name: String)

Primary Constructor

final class User {
     private String name;

     public User(String name) {
         this.name = name;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }
 }
 --------------------------------------
 class User(var name: String)

Optional Arguments in Constructors

final class User {
     private String name;
     private String lastName;

     public User(String name) {
         this(name, "");
     }

     public User(String name, String lastName) {
         this.name = name;
         this.lastName = lastName;
     }

     // And Getters & Setters
 }
 ------------------------------------------------
 class User(var name: String, var lastName: String = "")

Properties

public class Document {
    private String id = "00x";

     public String getId() {
         return id;
     }

     public void setId(String id) {
         if(id != null && !id.isEmpty()) {
             this.id = id;
         }
     }
 }
 -------------------------------------------
 class Document{
    var id : String = "00x"
        set(value) {
            if(value.isNotEmpty())  field = value
        }
}

Abstract Class

public abstract class Document{
   public abstract int calculateSize();
}

public class Photo extends Document{
    @Override
    public int calculateSize() {

    }
}
--------------------------------------
abstract class Document {
    abstract fun calculateSize(): Int
}

class Photo : Document() {
    override fun calculateSize(): Int {

    }
}

Singleton

public class Document {
   private static final Document INSTANCE = new Document();

   public static Document getInstance(){
       return INSTANCE;
   }

 }
 -----------------------------------------------------------
 object Document {

}

Extensions

public class ByteArrayUtils {
      public static String toHexString(byte[] data) {

      }
  }

  final byte[] dummyData = new byte[10];
  final String hexValue = ByteArrayUtils.toHexString(dummyData);
  --------------------------------------------------------------
  fun ByteArray.toHex() : String {

}

val dummyData = byteArrayOf()
val hexValue = dummyData.toHex()

Inner Class

public class Documment {

    class InnerClass {

    }

}
-------------------------
class Document {
    inner class InnerClass
}

Nested Class(内部类)

public class Documment {

    public static class InnerClass {

    }

}
--------------------------------------
class Document {

    class InnerClass

}

Interface

public interface Printable {
    void print();
}

public class Document implements Printable {
    @Override
    public void print() {

    }
}
---------------------------------------------
interface Printable{
    fun print()
}

class Document : Printable{
    override fun print() {

    }
}

讲真，一顿复制粘贴操作下来，发现Kolin的写法真的简单很多。