Kotlin與java對比

時間 2019-11-07

標籤 kotlin java 對比欄目 Java 简体版

原文原文鏈接

Kotlin與java對比

最近由於工做關係，須要迭代維護公司現有kotlin客服聊天的項目。以前一直使用java，對於kotlin仍是比較陌生的。
使用kotlin一段時間後，感觸仍是有點。kotlin比java真是太簡潔了，一段代碼，剛開始可能按java語法習慣編寫，而後根據ide的提示，一步一步優化，縮減代碼量，最後發現，代碼量的差距很大。最後剩下的代碼可能就只剩下了業務邏輯了。
kotlin結合mvvm架構，項目很是簡潔。
kotlin是基於jvm編程語言，同java同樣能夠編譯成class字節碼文件。同java之間能夠相互調用。java

基礎語法

1.定義函數

java：編程

public String retrunStr(String str){
        return str;
}
複製代碼

kotlin：bash

fun returnStr(str: String): String {
        return str
}
複製代碼

2.定義變量

java：閉包

public String str1;
public static final String str2 = "HelloWorld";
複製代碼

kotlin：架構

var str1: String? = null
val str2 = "HelloWorld"
複製代碼

3. 空置判斷：? 和 !!

java：app

?
public String retrunStr2(String str) {
        if (str != null) {
            return str1;
        } else {
            return "";
        }
}

!!
public void toLowerStr(String str) {
        try {
            str.toLowerCase();
        } catch (NullPointerException e) {
            e.printStackTrace();
        }
}
複製代碼

kotlin：jvm

?
fun retrunStr2(str: String?): String {
        return str ?: ""
}

!!
fun toLowerStr(str: String) {
        str!!.toLowerCase()
}
複製代碼

4.for循環

java：mvvm

public void test() {
        List<String> arr = Arrays.asList("java", "kotlin");
        for (int i = 0; i < arr.size(); i++) {
            System.out.println(i);
        }

        for (int i = 0; i < arr.size(); i++) {
            System.out.println(arr.get(i));
        }

        for (Iterator it = arr.iterator(); it.hasNext(); ) {
            System.out.println(it);
        }
}
複製代碼

kotlin：編程語言

fun test() {
        val arr = Arrays.asList("java", "kotlin")
        for (i in arr.indices) {
            println(i)
        }

        for (i in arr.indices) {
            println(arr[i])
        }

        val it = arr.iterator()
        while (it.hasNext()) {
            println(it)
        }

        for(item in arr){
            println(item)
        }
}
複製代碼

5.when 表達式

java：ide

public void test1() {
        int item = 3;
        switch (item) {
            case 1:
                System.out.println(1);
                break;
            case 2:
                System.out.println(2);
                break;
            case 3:
                System.out.println(3);
                break;
            default:
                System.out.println(0);
        }
}
複製代碼

kotlin：

fun test1() {
        val item = 3
        when (item) {
            1 -> println(1)
            2 -> println(2)
            3 -> println(3)
            else -> println(0)
        }
}
複製代碼

標準函數

1.let

let 擴展函數是一個做用域函數，當你須要去定義一個變量在一個特定的做用域範圍內，可使用let函數。

object.let{
   it.todo()//在函數體內使用it替代object對象去訪問其公有的屬性和方法
}
複製代碼

java示例:
------------
	public static final void main(@NotNull String[] args) {
        Intrinsics.checkParameterIsNotNull(args, "args");
        String var2 = "testLet";
        System.out.println(var2.length());//輸出 7
        int result = 1000;
        System.out.println(result); //輸出 1000
    }

kotlin示例:
------------
	fun main(args: Array<String>) {
        val result = "testLet".let {
            println(it.length) //輸出 7
            1000 //在函數塊內能夠經過 it 指代該對象。
        }
        //返回值爲函數塊的最後一行或指定return表達式。1000
        println(result) //輸出1000
    }    
複製代碼

2.with

with 將某對象做爲函數的參數，在函數塊內能夠經過 this 指代該對象。返回值爲函數塊的最後一行或指定return表達式。

with(object){
   //todo
 }
複製代碼

java示例:
------------
	public final void main(@NotNull String[] args) {
        Intrinsics.checkParameterIsNotNull(args, "args");
        User user = new User("Kotlin", 1, "1111111");
        System.out.println("my name is " + user.getName() + ", I am " + user.getAge() + " years old, my phone number is " + user.getPhoneNum());
        //輸出 my name is Kotlin, I am 1 years old, my phone number is 1111111
        int result = 1000;
        System.out.println("result: " + result); //輸出 1000
    }

	private class User {
        String name;
        Integer age;
        String phoneNum;

        public User(String name, int age, String phoneNum) {
        }

        public String getName() {
            return name;
        }

        public Integer getAge() {
            return age;
        }

        public String getPhoneNum() {
            return phoneNum;
        }

    }

kotlin示例:
------------
	 fun main(args: Array<String>) {
        val user = User("Kotlin", 3, "1111111")
        val result = with(user) {
	        //這裏this 指 user,this能夠省略
            println("my name is $this.name, I am $age years old, my phone number is $phoneNum")
            //輸出 my name is Kotlin, I am 1 years old, my phone number is 1111111
            1000
        }
        //返回值爲函數塊的最後一行或指定return表達式。1000
        println("result: $result")//輸出 1000
    }
    
	class User(name: String, age: Int, phoneNum: String) {
        var name: String
            get() {
                return name
            }
            set(value) {}

        var age: Int
            get() {
                return age
            }
            set(value) {}

        var phoneNum: String
            get() {
                return phoneNum
            }
            set(value) {}
    } 
複製代碼

3.run

run 函數實際上能夠說是let和with兩個函數的結合體，run函數只接收一個lambda函數爲參數，以閉包形式返回，返回值爲最後一行的值或者指定的return的表達式。

object.run{
	//todo
}
複製代碼

java示例:
------------
    public final void main(@NotNull String[] args) {
        Intrinsics.checkParameterIsNotNull(args, "args");
        User user = new User("Kotlin", 1, "1111111");
        System.out.println("my name is " + user.getName() + ", I am " + user.getAge() + " years old, my phone number is " + user.getPhoneNum());
        int result = 1000;
        System.out.println("result: " + result);//輸出 1000
    }

kotlin示例:
------------
    fun main(args: Array<String>) {
        val user = User("Kotlin", 1, "1111111")
        val result = user.run {
	        //這裏this 指 user,this能夠省略.
            println("my name is $this.name, I am $age years old, my phone number is $phoneNum")
            1000
        }
        //返回值爲最後一行的值或者指定的return的表達式 1000
        println("result: $result")//輸出 1000
    }  
複製代碼

4.apply

apply 函數和run函數很像，惟一不一樣點就是它們各自返回的值不同，run函數是以閉包形式返回最後一行代碼的值，而apply函數的返回的是傳入對象的自己。

object.apply{
	//todo
}
複製代碼

java示例:
------------
    public final void main(String[] args) {
        User user = new User("Kotlin", 1, "1111111");
        String var5 = "my name is " + user.getName() + ", I am " + user.getAge() + " years old, my phone number is " + user.getPhoneNum();
        System.out.println(var5);
        String var3 = "result: " + user;
        System.out.println(var3); //打印 user對象
    }

kotlin示例:
------------
    fun main(args: Array<String>) {
        val user = User("Kotlin", 1, "1111111")
        val result = user.apply {
	        //這裏this 指 user,this能夠省略.
            println("my name is $this.name, I am $age years old, my phone number is $phoneNum")
            1000
        }
        //apply函數的返回的是傳入對象的自己 user
        println("result: $result") //打印 user對象
    }
複製代碼

5.also

also 函數的結構實際上和let很像惟一的區別就是返回值的不同，let是以閉包的形式返回，返回函數體內最後一行的值，若是最後一行爲空就返回一個Unit類型的默認值。而also函數返回的則是傳入對象的自己。

object.also{
	//todo
}
複製代碼

java示例:
------------
    public void main(String[] args) {
        String var1 = "test";
        System.out.println(var1.length());//輸出 4
        System.out.println(var1);//輸出 test
    }

kotlin示例:
------------
    fun main(args: Array<String>) {
        val result = "test".also {
	        //it 指的是 "test"
            println(it.length) //輸出 4
            1000
        }
        //also函數返回的是傳入對象的自己 "test"
        println(result) //輸出 test
    }
複製代碼

函數小結：let,with,run,apply,also函數區別

函數名	使用方法	it,this對象	返回值	是不是擴展函數	適用的場景
let	object.let{ it.xxx }	it指代當前對象	閉包形式返回	是	適用於處理不爲null的操做場景
with	with(object){ xxx }	this指代當前對象或者省略	閉包形式返回	否	適用於調用同一個類的多個方法時，能夠省去類名重複，直接調用類的方法便可，常常用於Android中RecyclerView中onBinderViewHolder中，數據model的屬性映射到UI上
run	object.run{ xxx }	this指代當前對象或者省略	閉包形式返回	是	適用於let,with函數任何場景。
apply	object.apply{ xxx }	this指代當前對象或者省略	返回this	是	一、適用於run函數的任何場景，通常用於初始化一個對象實例的時候，操做對象屬性，並最終返回這個對象。二、動態inflate出一個XML的View的時候須要給View綁定數據也會用到. 三、通常可用於多個擴展函數鏈式調用四、數據model多層級包裹判空處理的問題
also	object.also{ xxx }	it指代當前對象	返回it	是	適用於let函數的任何場景，通常可用於多個擴展函數鏈式調用