Kotlin基础学习第3章—内置类型

一丶基本类型

二丶数组

package com.wangrui.kotlin

fun main(){

    方式一：创建一个可变长度的整型数组
    val c0 = intArrayOf(1,2,3,4,5)
    方式二：创建整型数组并且按照每个下标（0~4）依次+1 赋值给数组 c1
    val c1 = IntArray(5){it + 1}
    println(c1.contentToString());

    val c0 = intArrayOf(1,2,3,4,5);
    创建整型数组并且按照每个下标（0~4）依次(坐标+1)*3 赋值给数组c1
    val c1 = IntArray(5){(it + 1)*3}

    println(c0.contentToString());
    println(c1.contentToString());

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

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

    val d = arrayOf("Hello","World")
    d[1] = "Kotlin"

    println("${d[0]},${d[1]}")

    val e = floatArrayOf(1f,2f,3f,4f,5f)
    in—遍历
    for (a in e){
        println(a)
    }

    array.foreach()    高阶函数遍历
    e.forEach { a -> println(a) }

    val e = floatArrayOf(1f,2f,3f,4f,5f)
    for (a in e){
        println(a)
    }
    e.forEach { a -> println(a) }
}

三丶区间

package com.wangrui.kotlin

fun main(){

    in—包含
        if (1f in e){
        println("包含")
    }

    if (20f !in e){
        println("不包含")
    }

    val intRange = 1..10
    val charRange = 'a'..'z'
    val longRange = 1L..100L

    val floatRange = 1f..2f
    val doubRange = 1.0..2.0

    println(intRange.joinToString())
    println(floatRange.toString())

    区间（正序）
    val intRange = 1..10
    val charRange = 'a'..'z'
    val longRange = 1L..100L

    val floatRange = 1f..2f
    val doubRange = 1.0..2.0

    println(intRange.joinToString())
    println(floatRange.toString())

    止步——step
    val intRangeWitStep = 1..10 step 2
    val charRangeWithStep = 'a'..'z' step 2
    val longRanWitStep = 1L..100L step 5

    println(longRanWitStep.joinToString())

    倒叙区间
    val intRangeReverse = 10 downTo 1
    val charRangeReverse = 'z' downTo 'a'
    val longRangeReverse = 100L downTo 1L

    println(longRangeReverse.joinToString())

    if (12 !in intRange){
        println("不在区间内")
    }

    val array = intArrayOf(1,3,5,7)
    遍历方式1
    for (i in (0 until array.size)){
        println(array[i])
    }

    遍历方式2
    for (i in array.indices){
        println(array[i])
    }
}

四丶集合框架

package com.wangrui.kotlin

fun main(){

      创建List集合的方式一：不能添加元素或者删除元素
    val intList: List<Int> = listOf(1,2,3)
      创建List集合的方式二：可以添加元素或者删除元素
    val intList2: MutableList<Int> = mutableListOf(1,2,3)

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

      创建Map集合的方式一：不能添加元素或者删除元素
      Any等价于Java中的 Object
     to 可以理解为：Key-Value
    val map:Map<String,Any> = mapOf("name" to "benny","age" to 20)
      创建Map集合的方式二：可以添加元素或者删除元素
    val map2:Map<String,Any> = mutableMapOf("name" to "benny","age" to 20)

    val stringList:MutableList<String> = mutableListOf("98","99","100")
      对集合添加元素、删除元素
    for (i in 0..10){
          添加元素
        stringList += "num：$i"  等价于  stringList.add("num：$i")
          删除元素
        stringList -= "num：$i"  等价于  stringList.remove("num：$i")
    }

      Map集合赋值
    stringList[5] = "HelloWorld"    等价于 stringList.set(5,"HelloWorld")
    val valueAt5 = stringList[5]    等价于 String valueAt5 = stringList.get(5)

    val map = HashMap<String,Int>()
    map["Hello"] = 10
     '[]' 内的值实际上就是Key
    println(map["Hello"])

      解构：val (x,y) = pair
    val pair = "Hello" to "Kotlin"
    val pair2 = Pair("Hello","Kotlin")
    val first = pair.first
    val second = pair.second
    println(first)
    println(second)

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

    println(first)
    println(second)
    println(third)

    作业：
    一、集合该如何遍历
    val intNumber: List<Int> = listOf(1,2,3,4,5,6)
    intNumber.forEach{a -> println(a)}

    二、集合的包含关系如何判断？
    val intNumber2: List<Int> = listOf(1,2,3,4,5,6)
    if (4 in intNumber2){
        println("4包含于集合intNumber2")
    }
    if (400 !in intNumber2){
        println("400不包含于集合intNumber2")
    }

    三丶Scala 选择自己全新构建了一套集合框架，为什么 Kotlin没有？
    
}

五丶函数

package com.wangrui.kotlin

import java.util.*

  在类里定义函数
class Foo{
    fun bar(p0:String,p1:Long):Any{ TODO()}
}

  不用定义类，直接定义函数
fun yy(p:(Foo,String,Long)->Any){

}

  ★函数的类型
fun foo(){}    等价于     ()  ->Util
fun foo(p0:Int):String{...}     等价于     (Int)->String
class Foo{
      Foo 实际上就是 bar 方法的 receiver
    fun bar(p0:String,p1:Long):Any{...}
    Foo.(String,Long) -> Any    等价于     (Foo,String,Long) -> Any
}

    ★函数的引用
例1：
  函数的引用类似C语言中的指针，可用于函数传递
fun foo(){}     等价于     val f = ::foo
fun foo(p0:Int):String{...}     等价于     val g = ::foo
class Foo{
    fun bar(p0:String,p1:Long):Any{...}     等价于     val h = Foo:bar   也等价于    Function3<Foo,String,Long,Any>
}

例2：
val foo = Foo()
val m:(String,Long) -> Any = foo::bar

    ★变长参数   vararg
fun main(vararg args:String){
    println(args.contentToString())
}
等价于
public void static main(String[] args){
    System.out.println(Arrays.toString(args));
}

    ★多返回值
fun multiReturenValues():Triple<Int,Long,Double>{
    return Triple(1,3L,4.0)
}

fun main(vararg args:String){
    val (a,b,c) = multiReturenValues()  //伪多返回值
    val r = a + b
    val r1 = a + c
    println(r)  //4
    println(r1) //5.0
}

    ★默认参数
fun defalutParameter(x:Int,y:String,z:Long = 0L){
    TODO()
}

defaultParameter(5,"Hello") //正确
defaultParameter("Hello")   //错误
解决方法：★具名参数
defaultParameter(y = "Hello")

六丶案例：四则计算器

package com.wangrui.kotlin

/*
    input: 3 * 4
 */

fun main(vararg args: String){
    if (args.size < 3){
        return showHelp()
    }

    //▲暂时不是很理解 to::plus
    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())
}

七丶本章小结