一基本數(shù)據(jù)類型

Kotlin的基本數(shù)據(jù)類型跟java高級(jí)語(yǔ)言一樣，包括整型，長(zhǎng)整型，浮點(diǎn)型，雙精度，布爾型，字符型，字符串這幾種常見(jiàn)類型。

1.1Kotlin和Java的基本數(shù)據(jù)類型的對(duì)比

1.2變量的聲明

格式：var 變量名：變量類型
例如： var i:Int =0;至于后面的分號(hào)，則看代碼行后面是否還有其他語(yǔ)句，如果變量聲明完畢直接回車換行，那么后面無(wú)需帶分號(hào)；如果沒(méi)有回車換行，而是添加其他語(yǔ)句，那么變量聲明語(yǔ)句要帶上分號(hào)

1.3變量之間的轉(zhuǎn)換

Kotlin變量的另一個(gè)重要特點(diǎn)是類型轉(zhuǎn)換，在Java開(kāi)發(fā)中，如int、 long、 float、 double類型的變量可以直接在變量名前面加上諸如(int) 、(long) 、(float)、(double) 這種表達(dá)式進(jìn)行強(qiáng)制類型轉(zhuǎn)換;對(duì)于int (整型)和char (字符型)這兩種類型，甚至都無(wú)須類型，只能調(diào)用類型轉(zhuǎn)換函數(shù)輸出其他類型的變量，表2-2是常見(jiàn)的幾種類型轉(zhuǎn)換函數(shù)的說(shuō)明。.

        val origin: Float = 65f;
        tv_string.text = origin.toString()

        var int: Int;
        int = origin.toInt();
        tv_integer.text = int.toString();

        var long: Long;
        long = origin.toLong()
        tv_long.text = long.toString()

        var double: Double
        double = origin.toDouble();
        tv_double.text = double.toString()

        var boolean: Boolean
        boolean = origin.isNaN()
        tv_boolean.text = boolean.toString()

        var char: Char
        char = origin.toChar()
        tv_char.text = char.toString()

注意到上述類型轉(zhuǎn)換代碼的第一行變量聲明語(yǔ)句以val開(kāi)頭，而其余的變量聲明語(yǔ)句均以var開(kāi)頭，這是為什么呢?其實(shí)val和var的區(qū)別在于，前者修飾過(guò)的變量只能在第一次聲明時(shí)賦值，后續(xù)不能再賦值;而后者修飾過(guò)的變量在任何時(shí)候都允許賦值。方便記憶的話，可以把val看作是Java里的final關(guān)鍵字;至于var, Java里面沒(méi)有對(duì)應(yīng)的關(guān)鍵字，就當(dāng)它是例行公事好了。

二：數(shù)組

2.1數(shù)組變量的聲明

java中聲明一個(gè)整型數(shù)組如下：
int[] int_array=new int[]{1,2,3,4};
其他的類型只要把int替換成long,float,double,boolean,char,其中之一即可。
但是在Kotlin中，聲明并初始化一個(gè)整型數(shù)組是下面這樣的：
var int_array:IntArray= intArrayOf(1,2,3,4)
Kotlin與Java之間的區(qū)別：

• Kotlin另外提供了新的整型數(shù)組類型，即IntArray
• 分配一個(gè)常量數(shù)組，Kotlin調(diào)用的是intArrayOf方法，并不使用new關(guān)鍵字
  其他的基本數(shù)組類型：

不知讀者有沒(méi)有注意到，上面的Kotlin數(shù)組類型不包括字符串?dāng)?shù)組，而Java是允許使用字符串?dāng)?shù)組的，聲明字符串?dāng)?shù)組的Java代碼示例如下:
String[] string_array=new String[]{"how","are","you"}但在Kotlin這里，并不存在名為StringArray的數(shù)組類型，因?yàn)镾tring是一種特殊的基 本數(shù)據(jù)類型。要想在Kotlin中聲明字符串?dāng)?shù)組，得使用Array<String>類型，也就是把“String"”用尖括號(hào)包起來(lái)。同時(shí)，分配字符串?dāng)?shù)組的方法也相應(yīng)變成了arrayOf,下面是聲明字符串?dāng)?shù)組的Kotlin代碼:這種字符串?dāng)?shù)組的聲明方式是不是很熟悉?看起來(lái)就跟Java里面的ArrayList用法差不多，都是在尖括號(hào)中間加入數(shù)據(jù)結(jié)構(gòu)的類型。同理，其他類型的數(shù)組變量也能通.過(guò)“Array<數(shù)據(jù)類型>”的方式來(lái)聲明，像前面介紹的整型數(shù)組，其實(shí)可以使用類型Array<Int>，以此類推，改造之后的各類型數(shù)組變量的聲明代碼如下所示:

var int_ array :Array<Int> = array0f(1, 2, 3)
var long_ array :Array<Long> = array0f(1, 2，3)
var float_ array : Array<F1oat> = array0f(1.0f， 2.0f, 3.0f)
var double_ array: Array<Doub1e> = array0f(1.0， 2.0，3.0)
var boolean_ array : Array<Boolean> = arrayOf(true, false, true)
var char_ array :Array<Char> = arrayOf('a', 'b', 'c')

  class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
      
        //聲明整型數(shù)組
        var int_array: IntArray = intArrayOf(1, 2, 3, 4);
        //也可以按下面方式聲明
        var int_array2: Array<Int> = arrayOf(1, 2, 3, 4)
        tv_integer.setOnClickListener { setArrayStr(int_array2) }

        //聲明長(zhǎng)整型數(shù)組
        var long_array: LongArray = longArrayOf(1, 2, 3);
        var long_array2:Array<Long> = arrayOf(1, 2, 3)
        tv_long.setOnClickListener { setArrayStr(long_array2) }

        //聲明浮點(diǎn)數(shù)組
        var float_array: FloatArray = floatArrayOf(1.0f, 2.0f, 3.0f);
        var float_array2:Array<Float> = arrayOf(1.0f, 2.0f, 3.0f)
        tv_float.setOnClickListener { setArrayStr(float_array2) }

        //聲明雙精度數(shù)組
        var double_array: DoubleArray = doubleArrayOf(1.0, 2.0, 3.0);
        var double_array2:Array<Double> = arrayOf(1.0, 2.0, 3.0)
        tv_double.setOnClickListener { setArrayStr(double_array2) }

        //聲明布爾型數(shù)組
        var boolean_array: BooleanArray = booleanArrayOf(false, true, false);
        var boolean_array2:Array<Boolean> = arrayOf(false, true, false)
        tv_boolean.setOnClickListener {
            var str:String = ""
            for (item in boolean_array2) {
                str = str + item.toString() + ", "
            }
            tv_text.text = str }

        //聲明字符數(shù)組
        var char_array: CharArray = charArrayOf('a', 'b', 'c');
        var char_array2:Array<Char> = arrayOf('a', 'b', 'c')
        tv_char.setOnClickListener {  var str:String = ""
            for (item in char_array) {
                str = str + item.toString() + ", "
            }
            tv_text.text = str }

        //聲明字符串?dāng)?shù)組
        var string_array: Array<String> = arrayOf("hao", "are", "you");
        tv_string.setOnClickListener {
            var str:String = ""
            var i:Int = 0
            while (i<string_array.size) {
                str = str + string_array[i] + ", "
                //數(shù)組元素可以通過(guò)下標(biāo)訪問(wèn)，也可通過(guò)get方法訪問(wèn)
                //str = str + string_array.get(i) + ", "
                i++
            }
//            for (item in string_array) {
//                str = str + item + ", "
//            }
            tv_text.text = str
        }


    }

    inline fun <reified T : Number> setArrayStr(array: Array<T>) {
        var str: String = ""
        for (item in array) {
            str = str + item.toString() + ",";
        }
        tv_text.text = str
    }
}

2.2數(shù)組元素的操作

• (1)對(duì)于如何獲取數(shù)組長(zhǎng)度，Java使用.length，而Kotlin使 用size
• (2)對(duì)于如何獲取指定位置的數(shù)組元素，Java通過(guò)方括號(hào)加下標(biāo)來(lái)獲取，比如"int_ array[0]"指的是得到該數(shù)組的第一個(gè)元素 ; Kotlin也 能通過(guò)方括號(hào)加下標(biāo)來(lái)獲取指定元素，不過(guò)Kotlin還擁有g(shù)et和set兩個(gè)方法，通過(guò)get方法獲取元素值，通過(guò)set方法修改元素值，看起來(lái)就像在操作ArrayList隊(duì)列。

 var str_array: Array<String> = arrayOf("how", "are", "you")
        btn_shuzu.setOnClickListener {
            var str: String = ""
            var i: Int = 0
            while (i < str_array.size) {
                str = str + str_array[i] + ","
                //數(shù)組元素可以通過(guò)下標(biāo)訪問(wèn)，也可以通過(guò)get方法訪問(wèn)
                //str=str+str_array.get(i)
                i++
            }
            btn_shuzu.text = str
        }

2.3 字符串

2.3.1 字符串與基本類型的轉(zhuǎn)換

首先要說(shuō)明的是字符串類型與基本變量類型之間的轉(zhuǎn)換方式，在前面的“2.1.2簡(jiǎn)單變量之間的轉(zhuǎn)換”中，提到基本數(shù)據(jù)類型的變量可以通過(guò)toString方法轉(zhuǎn)換為字符串類型。反過(guò)來(lái)，字符串類型又該如何轉(zhuǎn)換為基本變量類型呢?表2-4展示使用Kotlin和Java編碼將字符串轉(zhuǎn)換為基本數(shù)據(jù)類型的對(duì)照方式說(shuō)明。

2.3.2字符串的常用方法

當(dāng)然，轉(zhuǎn)換類型只是字符串的基本用法，還有更多處理字符串的其他用法，比如查找子串、替換子串、截取指定位置的子串、按特定字符分隔子串等，在這方面Kotlin基本兼容Java的相關(guān)方法。對(duì)于查找子串的操作，二者都調(diào)用indexOf方法;對(duì)于截取指定位置子串的操作，二者都調(diào)用substring方法;對(duì)于替換子串的操作，二者都調(diào)用replace方法;對(duì)于按特定字符分隔子串的操作，二者都調(diào)用split方法。

//2.3.2字符串的常用方法
        //查找子串indexOf、截取指定位置子串substring()、替換子串replace()、分隔子串split()、
        var origin_str: String = "123456.789"
        if (origin_str.indexOf('.') > 0) {
            btn_str.text = origin_str.substring(0, origin_str.indexOf('.'))

        }

        //注意：split()方法返回的時(shí)隊(duì)列，即List<String>
        btn_split.setOnClickListener {
            var strList: List<String> = origin_str.split('.')
            var strResult: String = ""
            for (item in strList) {
                strResult = strResult + item + ","
            }
            btn_split.text = strResult
        }

//獲取指定位置的字符串
        btn_get_char.setOnClickListener {
            btn_get_char.text = origin_str.get(3).toString()
        }

2.3.3 字符串模板及其拼接

kotlin進(jìn)行了優(yōu)化，何必引入這些麻煩的格式轉(zhuǎn)換符呢?直接在字符串中加入“$變量名”即可表示此處引用該變量的值，豈不妙哉!
例如：

     //2.3.3字符串模板及其拼接
       var origin: String = "123456.789"
       //模板
       btn_format.setOnClickListener { btn_format.text = "字符串模板為：$origin" }

這里要注意，符號(hào)$后面跟變量名，系統(tǒng)會(huì)自動(dòng)匹配最長(zhǎng)的變量名。比如下面這行代碼，打印出來(lái)的是變量origin_str的值，而不是origin的值:
例如：

  //2.3.3字符串模板及其拼接
        var origin_str: String = "123456.789"
        //模板
        btn_format.setOnClickListener { btn_format.text = "字符串模板為：$origin_str" }

另外，有可能變量會(huì)先進(jìn)行運(yùn)算，再把運(yùn)算結(jié)果拼接到字符串中。此時(shí)，需要用大括號(hào)把運(yùn)算表達(dá)式給括起來(lái)，具體代碼如下所示:

//模板帶有計(jì)算
 btn_format_caculate.setOnClickListener { btn_format_caculate.text = "字符串長(zhǎng)度為：${origin_str.length}" }

在上述的Kotlin格式化代碼中，美元符號(hào)$屬于特殊字符，因此不能直接打印它，必須經(jīng)過(guò)轉(zhuǎn)義才可以打印。轉(zhuǎn)義的辦法是使用“${'***'}”表達(dá)式，
該表達(dá)式外層的"${'*** '}"為轉(zhuǎn)義聲明，
內(nèi)層的“***”為需要原樣輸出的字符串，所以通過(guò)表達(dá)式“${$'}”即可打印一個(gè)美元符號(hào)，示例代碼如下:
 "${'***'}" 打印一個(gè)轉(zhuǎn)義字符 -->"${'$'}"--即打印一個(gè)$符號(hào)
 btn_dollar.setOnClickListener { btn_dollar.text = "美元符號(hào)：${'$'}$origin" }

2.4 容器

2.4.1 容器的基本操作

與Java類似，Kotlin也擁 有三類基本的容器，分別是集合Set、隊(duì)列List、映射Map，然后每類容器又分作只讀與可變兩種類型，這是為了判斷該容器能否進(jìn)行增、刪、改等變更操作。Kotlin對(duì)變量的修改操作很慎重，每個(gè)變量在定義的時(shí)候就必須指定能否修改，比如添加val修飾表示該變量不可修改，添加var修飾表示該變量允許修改。至于容器默認(rèn)為只讀容器，如果需要允許修改該容器變量，就需要加上Mutable前綴形成新的容則器，比如MutableSet表示可變集合，MutableList 表示可變隊(duì)列，MutableMap表 示可變映射，只有可變的容器才能夠?qū)ζ鋬?nèi)部元素進(jìn)行增、刪、改操作。

既然集合Set、隊(duì)列List、映射Map三者都屬于容器，那么它們必定擁有相同的容器方法，這些公共方法具體說(shuō)明如下。
//容器的公共方法

• isEmpty：
• isNotEmpty:
• clear:
• contains:
• iterator:
• count:獲取容器包含的元素的個(gè)數(shù)，也可以通過(guò)size屬性獲取元素?cái)?shù)量
  另外，Kotlin允許在聲明容器變量時(shí)就進(jìn)行初始賦值,例如：

 val satelLites: List<String> = listOf("水星", "金星", "地球", "火星", "木星", "土星")

當(dāng)然，不同容器的初始化方法有所區(qū)別，各種容器與其初始化方法的對(duì)應(yīng)關(guān)系見(jiàn)表2-5。

2.4.2 集合Set/MutableSet

集合是一種最簡(jiǎn)單的容器，它具有以下特性:
(1)容器內(nèi)部的元素不按順序排列，因此無(wú)法按照下標(biāo)進(jìn)行訪問(wèn)。
(2)容器內(nèi)部的元素存在唯- -性，通過(guò)哈希值校驗(yàn)是否存在相同的元素，若存在，則將其覆蓋。
因?yàn)镾et是只讀集合，初始化賦值后便不可更改，所以元素變更的方法只適用于可變集合MutableSet，但MutableSet的變更操作尚有以下限制:
(1) MutableSet的add方 法僅僅往集合中添加元素，由于集合是無(wú)序的，因此不知道添加的具體位置。
(2) MutableSet沒(méi) 有修改元素值的方法，一個(gè)元素一旦被添加，就不可被修改。
(3) MutableSet的remove方 法用于刪除指定元素，但無(wú)法刪除某個(gè)位置的元素，這是因?yàn)榧蟽?nèi)的元素不是按順序排列的。
對(duì)于集合的遍歷操作，Kotlin提供了好幾種方式，有熟悉的for-in循環(huán)、迭代器遍歷，還有新面孔forEach遍歷，這三種集合遍歷的用法說(shuō)明如下。

for-in循環(huán)

 val goodsMutSet: Set<String> = setOf("iphone11", "Mate30", "小米9", "oppo11", "VIVO", "魅族17")
        btn_set_for.setOnClickListener {
            var desc = ""
            for (item in goodsMutSet) {
                desc = "${desc}名稱：${item}\n"
            }
            btn_set_for.text = "手機(jī)暢銷榜包含以下${goodsMutSet.size}手機(jī)：\n$desc"
        }

Iterator遍歷

    btn_iterator.setOnClickListener {
            var desc = ""
            val iterator = goodsMutSet.iterator()
            while (iterator.hasNext()) {
                val item = iterator.next()
                desc = "${desc}名稱：${item}\n"
            }
            btn_iterator.text = "手機(jī)暢銷榜包含以下${goodsMutSet.size}手機(jī)：\n$desc"
        }

forEach遍歷

   btn_forEach.setOnClickListener {
            var desc = ""
            goodsMutSet.forEach {
                desc = "${desc}名稱：${it}\n"
                btn_forEach.text = "手機(jī)暢銷榜包含以下${goodsMutSet.size}手機(jī)：\n$desc"
            }
        }

結(jié)合以上有關(guān)SetMutableSet的用法說(shuō)明，可以發(fā)現(xiàn)集合在實(shí)戰(zhàn)中存在諸多不足，主要包括以下幾點(diǎn):
(1) 集合不允許修改內(nèi)部元素的值。
(2)集合無(wú)法刪除指定位置的元素。
(3) 不能通過(guò)下標(biāo)獲取指定位置的元素。

2.4.3 隊(duì)列List/MutableList

隊(duì)列是一種元素之間按照順序排列的容器，它與集合的最大區(qū)別在于多了次序管理。不要小看這個(gè)有序性，正因?yàn)殛?duì)列建立了秩序規(guī)則，所以它比集合多提供了如下功能(注意，凡是涉及增、刪、改的，都必須由MutableList來(lái)完成) :

(1)隊(duì)列能夠通過(guò)get方法獲取指定位置的元素，也可以直接通過(guò)下標(biāo)獲得該位置的元
素。
(2) MutableList的add方 法每次都是把元素添加到隊(duì)列末尾，也可指定添加的位置。
(3) MutableList的set方法允許替換或者修改指定位置的元素。
(4)MutableList的removeAt方 法允許刪除指定位置的元素。
(5) 隊(duì)列除了擁有跟集合一樣的三種遍歷方式(for-in循環(huán)、 迭代器遍歷、forEach遍歷)外，還多了一種按元素下標(biāo)循環(huán)遍歷的方式，具體的下標(biāo)遍歷代碼例子如下:

        val goodsMutList: List<String> = listOf("iphone11", "Mate30", "小米9", "oppo11", "VIVO", "魅族17")
        btn_list_forin.setOnClickListener {
            var desc = ""
            //indices是隊(duì)列的下標(biāo)數(shù)組。如果隊(duì)列大小為10，下標(biāo)數(shù)組的取值為0-9
            for (i in goodsMutList.indices) {
                val item = goodsMutList[i]
                desc = "${desc}名稱：${item}\n"
            }
            btn_list_forin.text = "手機(jī)暢銷榜包含以下${goodsMutList.size}手機(jī)：\n$desc"
        }

(6) MutableList提 供了sort系列方法用于給隊(duì)列中的元素重新排序，其中sortBy方法表示按照指定條件升序排列，sortByDescending方 法表示按照指定條件降序排列。下 面是一個(gè)給隊(duì)列排序的代碼例子(含升序和降序) :

        var sortAsc = true
        btn_list_sort.setOnClickListener {
            //

            if (sortAsc) {
                goodsMutList.sortedBy { it.length }
            } else {
                goodsMutList.sortedByDescending { it.length }
            }

            var desc = ""
            for (item in goodsMutList) {
                desc = "${desc}名稱：${item}\n"
            }
            btn_list_sort.text = "手機(jī)暢銷榜已按照${if (sortAsc) "升序" else "降序"}重新排序：\n$desc"

            sortAsc = !sortAsc
        }

2.4.4 映射Map/MutableMap

映射內(nèi)部保存的是一組鍵值對(duì)(Key-Value) ，也就是說(shuō)，每個(gè)元素都由兩部分構(gòu)成，第一部分 是元素的鍵，相當(dāng)于元素的名字:第二部分是元素的值，存放著元素的詳細(xì)信息。元素的鍵與值是一一對(duì)應(yīng)的關(guān)系，相同鍵名指向的鍵值是唯一的， 所以映射中每個(gè)元素的鍵名各不相同，這個(gè)特性使得映射的變更操作與隊(duì)列存在以下不同之處(注意，增、刪操作必須由MutableMap來(lái)完成) :
(1)映射的containsKey方法判斷是否存在指定鍵名的元素，containsValue方法判斷是否存在指定鍵值的元素。
(2) MutableMap的put方 法不單單是添加元素，而是智能的數(shù)據(jù)存儲(chǔ)。每次調(diào)用put方法時(shí)，映射會(huì)先根據(jù)鍵名尋找同名元素，如果找不到就添加新元素，如果找得到就用新元素替換舊元素。
(3) MutableMap的remove方 法是通過(guò)鍵名來(lái)刪除元素的。
(4)調(diào)用mapOf和mutableMapOf方 法初始化映射時(shí)，有兩種方式可以表達(dá)單個(gè)鍵值對(duì)元素，其一是采取“鍵名to鍵值”的形式，其二是采取Pair配對(duì)方式，形如“Pair(鍵名，鍵值)”。下面是這兩種初始化方式的代碼例子:

 //初始化
        //1.to方式映射
        var goodMap: Map<String, String> =
            mapOf("蘋(píng)果" to "iphone11", "華為" to "huawei30", "小米" to "xiaomi9", "歐珀" to "OPPO", "魅族" to "meizu16")

        //2.Pair方式初始化映射
        var goodsMutMap: MutableMap<String, String> = mutableMapOf(
            Pair("蘋(píng)果", "iphone11"),
            Pair("華為", "mate30"), Pair("歐珀", "OPPO"), Pair("小米", "xiaomi6"), Pair("魅族", "meizu16")
        )

映射的遍歷與集合類似，也有for-in循環(huán)、迭代器遍歷、forEach遍 歷三種遍歷手段。但是由于映射的元素是一一個(gè)鍵值對(duì)，因此它的遍歷方式與集合稍有不同，詳述如下:

for-in

    btn_map_forIn.setOnClickListener {
            var desc = ""
            //使用for-in語(yǔ)句循環(huán)取出映射中的每條記錄
            for (item in goodsMutMap) {
                //item.key表示該配對(duì)的鍵，即廠家名稱；item.value表示該配對(duì)的值，即手機(jī)名稱
                desc = "${desc}廠家;${item.key},名稱：${item.value}\n"
            }
            btn_map_forIn.text = "手機(jī)暢銷榜包含以下${goodsMutMap.size}款手機(jī)：\n$desc"
        }

迭代器遍歷

btn_map_iterator.setOnClickListener {
            var desc = ""
            val iterator = goodsMutMap.iterator()
            while (iterator.hasNext()) {
                val item = iterator.next()
                desc = "${desc}廠家;${item.key},名稱：${item.value}\n"
            }
            btn_map_iterator.text = "手機(jī)暢銷榜包含以下${goodsMutMap.size}款手機(jī)：\n$desc"
        }

forEach遍歷

btn_map_forEach.setOnClickListener {
            var desc = ""
            goodMap.forEach { key, value ->
                desc = "${desc}廠家;${key},名稱：${value}\n"
            }
            btn_map_forEach.text = "手機(jī)暢銷榜包含以下${goodsMutMap.size}款手機(jī)：\n$desc"
        }