前言

本文主要讲解内置类型，主要包括：基本类型、数组、区间、集合框架、函数、案例：计算器

---

Kotlin文章列表

Kotlin文章列表: 点击此处跳转查看

---

目录

---

（一）基本类型

（1）Kotlin与Java基本类型比较

（2）声明变量

（2.1）kotlin声明变量

（2.2）kotlin与java声明变量比较

java：

int a = 2；
final String b = "Hello Java"；

kotlin：

var a : lnt = 2
val b：String = "Hello Kotlin"

---

（2.3）kotlin声明变量类型自动推导

var a = 2
val b：String = "Hello Kotlin"

---

（2.4） kotlin与java易混淆的Long类型标记

java：

long c = 12345678910l;  // ok but not good.    
long d = 12345678910L; // ok

kotlin：

val c = 12345678910l // compile error    
val d = 1234567890L; // ok

---

（2.5）kotlin的数值类型转换

java：

int e = 10;    
long f = e; // implicit conversion

kotlin：

val e : Int =10    
val f : Long = e.toLong() // ok

---

（2.6）kotlin无符号类型

---

（3）kotlin的字符串

字符串比较 a == b：比较内容，等价于Java的equals
a === b：比较对象是否是同一个对象

字符串模板 "Hello, $name" => "Hello,小明"

val j = "I love China"
println("Value of String 'j' is: $j) // no need brackets  
println("Length of String 'j' is: ${j.length})") // need brackets
System. out.printf("Length of String 'j' is: %d\n", j.length)

---

（二）数组

（1）kotlin与java数组比较

（2）kotlin与java数组的创建

java：

int[] c = new int[]{1, 2, 3, 4, 5};

kotlin：

val c = intArayof(1, 2, 3, 4, 5)
val c1 = IntArray(size: 5){it + 1} 
it 为数组下标，从0到size - 1   

例如：

val c = IntArray( size: 5){3 * (it + 1))}    // y = 3 * (x + 1)
it的取值为0, 1, 2, 3, 4
c的值为[3, 6, 9，12，15]

---

（3）kotlin与java数组的长度

java：

int[] a = new int[5];    
System.out.println(a.length);

kotlin：

val a = IntArray(5)    
println(a.size) 

---

（4）kotlin与java数组的读写

java：

String[] d = new String[]{"Hello","World"};
d[1] = "Java"；
System.outprintln(d[0] + "," + d[1]);

kotlin：

val d = arrayof{"Hellb", "World")
d[1] = "Kotlin"
println("${d[0]}, $(d[1]}")

---

（5）kotlin与java数组的遍历

java：

float[] e = new float[]{1, 3, 5, 7}; 
for (float element : e) {
     System. out println(element);
}

kotlin：

val e = floatArrayof(1f, 3f, 5f, 7f)    
for (element in e) {
    println(element)
}

或者另一种写法

e.forEach { element ->
        println(element)
}

---

（6）kotlin与java数组的包含关系

java：

for (float element : e) {
      if (element == 1f) {
          System. out.println("If exists in variabl 'e'");
          break;
      }
}

kotlin：

if (1f in e) {
    println("If exists in variabl 'e'");
}

---

（三）区间

（1）闭区间的创建

.. 表示闭区间

val intRange = 1 .. 10     // [1, 10]    
val charkange = 'a' .. 'z'    
val longRange = 1L .. 100L

---

（2）开区间的创建

until表示开区间，但是不包含结束值

val intRangeExclusive = 1 until 10   // [1, 10)    
val charRangeEXclusive = 'a' until 'z'    
val long RangeExclusive = 1L until 100L

---

（3）倒序区间的创建

downTo为倒序区间，也是闭区间

val intRangeReverse = 10 downTo 1  // [10, 9..…,1]
val charRangeReverse = 'z' downTo 'a'
val longRangeReverse = 100L downTo 1L

---

（4）区间的步长

val intRangeWithStep = 1 .. 10 step 2    
val charRangeWithStep = 'a' .. 'z' step 2    
val longRangeWithStep = 1L .. 100L step 5

---

（5）区间的迭代与包含

for (element in intRange) {
     println(element)
}

intRange.forEach {
    println(it)
}

if (3 in intRange) {
    println("3 in range 'intRange'")
}

if (12 !in intRange) {
     println("12 not in range 'intRange'")
}

---

（6）区间的应用

val array = intArrayOf(1, 3, 5, 7)
for(i in array.indices) {
    println(array[i])
}

indices返回[0, array.size)

---

（四）集合框架

（1）kotlin集合框架的特点

增加了“不可变”集合框架的接口
没有另起炉灶，复用 Java API的所有实现类型
提供了丰富易用的方法，例如 forEach/map/flatMap
运算符级别的支持，简化集合框架的访问

---

（2）kotlin与java集合框架的接口类型对比

不可变的意思是：不能添加或者删除元素 可变的意思是：可以添加或者删除元素

---

（3）kotlin与java集合框架的创建

java：

List<String> stringList = new ArraylList<>();
List<Integer> intList = new ArraylList<>(Arrays.asList(1, 2, 3));

kotlin：

var stringList = ArrayList<String>()

val intList : List<Int>= listof(1, 2, 3)
val intList2 : MutableList<Int> = mutableListof(1, 2, 3)

val map: Map<String, Any> = mapOf("name" to "benny", "age" to "20")
val map2: Map<String, Any> = mutableMapOf("name" to "benny", "age" to "20")

"name" to "benny"可以理解为，k - v
Any等价与java中的object

---

（4）kotlin与java集合框架的修改

java：

for (int i = 0; i < 10;  i++) {
    stringList.add(num: " 1)
}

kotlin：

for (i in 0.. 10) {
    stringList +="num : $i"
}

---

（5）kotlin与java集合框架的读写

java： （1）List

stringList.set(5, "HelloWorld");
String valueAt5 = stringList.get(5);

（2）Map

HashMap<String, Integer> map = new HashMap<>;    
map.put("Hello, 10);
System.out.printIn(map. get( "Hello" );

kotlin： （1）Map

stringList[5] = "HelloWorld"
val valueAt5 = stringList[5]

（2）Map

val map = HashMap<String, Int>()
map["Hello"] = 10
println(map["Hello"])

---

（6）pair triple

val pair = "Hello" to "Kotlin"
val pair2 = Pair("Hello", "Kotlin'")    两种创建方式
val first = pair.first
val second = pair.second   获取对应元素
val(x, y) = paik

val triple = Triple("x", 2, 3.0)
val first = triple.first
val second = triple.second 
val third = triple.third
val(x, y, z) = triple

---

（五）函数

（1）函数的定义

fun main(args:Array<String>) {
    println(args.contentToString())
}                                                                               
iUnit等价于Java的void函数，返回值为Unit可省略

---

（2）函数的类型

在kotlin中如果函数A想作为函数B的参数，那么函数A该怎么写呢？此时就需要了解函数的类型

fun fool{}      () -> Unit

fun foo(p0 : Int) : String {...}    (Int)-> String

class Foo {
     fun bar(p0: String, p1: Long): Any{...}              Foo.(String, Long) -> Any   或者  Foo.(String, Long) -> Any 
}

---

（3）函数的引用

函数的引用类似C语言中的函数指针, 可用于函数传递

fun foo() { }                     ::foo

fun foo(p0: Int): String {...}            ::foo

class Foo {
    fun bar(p0: String, p1 Long): Any(...)                            Foo::bar
}

定义变量来接收值

fun foo() { }                 val f :() -> Unit = ::foo 或者 val f = ::foo          

fun foo(p0: Int): String {...}        val g :(Int) -> String = ::foo 或者 val g = ::foo

class Foo {
    fun bar(p0: String, p1 Long): Any(...)                      val h:(Foo, String, Long) ->Any = Foo::bar 或者 val h = Foo::bar
}

class Foo {
    fun bar(p0: String, p1 Long): Any(...)                     
}
val foo = Foo()
val m = foo::bar

---

（4）变长参数

multiParameters("1", "2", "3")

fun multiParameters(vararg args : String) {
    println(args.contentToString())
}

---

（5）多返回值

fun multiReturnValues() : Triple<Int, Long, Double> {
    return Triple(1, 3L, 4.0)
}

val(a, b, c) = multiReturnValues()
val d = a + b

---

（6）默认参数

函数定义:

fun defaultParameter(x: int, y: String, z: long = 0L)  {

}

函数调用: defaultParameter(5, " Hello") 默认参数应该是最后一个

---

（六）案例：计算器

/**
* 输入的格式如下
* input: 3 * 4
* 
*/
fun main(vararg args: String) {

    if (args.size < 3) {
        return showHelp()
    }

    val operators = mapOf(
        "+" to ::plus,
        "-" to ::minus,
        "*" to ::times,
        "/" to ::div
    )

    val op = args[1]
    val opFunc = operators[op] ?: return showHelp()

    try {
        println("Input: ${args.joinToString(" ")}")
        println("Output: ${opFunc(args[0].toInt(), args[2].toInt())}")
    } catch (e: Exception) {
        println("Invalid Arguments.")
        showHelp()
    }
}

fun plus(arg0: Int, arg1: Int): Int {
    return arg0 + arg1
}

fun minus(arg0: Int, arg1: Int): Int {
    return arg0 - arg1
}

fun times(arg0: Int, arg1: Int): Int {
    return arg0 * arg1
}

fun div(arg0: Int, arg1: Int): Int {
    return arg0 / arg1
}

fun showHelp() {
    println(
        """
        Simple Calculator:
            Input: 3 * 4
            Output: 12
    """.trimIndent()
    )
}