Kotin练习

package com.example.kotlin

import android.os.Bundle
import android.security.identity.IdentityCredentialException
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import kotlinx.android.synthetic.main.activity_main.*
import java.lang.IndexOutOfBoundsException
import java.util.*
import kotlin.collections.ArrayList
import kotlin.collections.HashMap
import kotlin.math.max
import kotlin.math.min

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        tv_btn.setOnClickListener{
            Log.d("das","da")
        }


        main()
        main2()
        main3()
        val uu = metnuber(17,6)
       println("**-"+uu)
       val i = ifmax(5,7)
        println("**"+i)
        println("输出"+scroc("6"))
        println("输出21*"+getscroc("8"))
        forNumber(0,6)
        forNumber2(0,10)
        fordown(0,10)
        Student("lp",55)
        main4()
        Singleton.sigletonTest()

        var list = listOf("1","2","3")
        for (i in list) {
            println(i)
        }
        listAdd()
        setOf()
        listOf()
        map()
        Api()
        filter()
        api2()
        Threads()
        noNUll()
      val uud = textlength("45")
        println("输出"+uud)
        Stringprice()
        var id= ArrayList<Int>(4)
        id.add(6)
        id.add(5)
        id.add(8)
        id.add(2)
        paixun(id)

        for (i in id) {
            println("打2d"+i)
        }
        quicksort(id,0,2)
        for (i in id) {
            println("打2dd"+i)
        }
    }
    fun main() {
        println("dada213")
    }
    fun main2() {
        var i =5;
        println("i="+i*i)
    }
    fun main3() {
        var i =5
        i+=i
        println(""+i)
    }
    fun metnuber(parmal : Int,parmal2 : Int) : Int {
        return min(parmal,parmal2)
    }
    fun ifmax(parmal: Int,parmal2: Int) =if (parmal > parmal2)parmal else parmal2
    fun scroc(nuber:String) = if (nuber.equals("1")) 1 else if (nuber.equals("2")) 2 else 3
    fun getscroc(name:String) = when(name) {
        "1"->1
        "2"->2
        "3"->3
        else -> 0
    }
    //i..u 表示i到u的区间
    fun forNumber(i : Int,u :Int) {
        for (i in i..u) {
            println("*"+i)
        }
    }
    //依次递减2
    fun forNumber2(i : Int ,u : Int) {
        for (i in i until u step 2) {
            println("**"+i)
        }
    }
    //倒序 从 u 到 i
    fun fordown(i : Int,u : Int) {
        for (i in u downTo i) {
            println("***"+i)
        }
    }
    fun main4() {
        val student = Student("jack",19)
        doStudy(student)
        val cellphone1 = Cellphone("Samsung",1299.99)
        val cellphone2 = Cellphone("Samsung",1299.99)
        println("**"+cellphone1+"*"+(cellphone2==cellphone1))
    }
    fun doStudy(study: Study?) {
        if (study != null) {
            study.readBooks()
            study.doHomework()
            //效果一样 ？表示不为空
            study?.readBooks()
            study?.doHomework()
        }
        //it 是Lambda 表达式 it表示当参数只有一个时可用it代替 let是处理全局判空
        study?.let {
            it.readBooks()
            it.doHomework()
        }
    }

//    listOf不可变list数组
//    mutableListOf可变list数组
    fun listAdd() {
        var list = mutableListOf("5","6","7");
        list.add("4")
        for (i in list) {
            println("*"+i)
        }
    }
    //setof 和 mutablesetof 和list差不多但是，set因为是映射，使用无法保证有序
    fun setOf() {
        var set = setOf("5","6","4","2")
        println("*/*"+set.maxOrNull())

    }
    fun listOf() {
        val list2 = mutableListOf("5","6","4","2","3","3")
        list2.sort()
        for (ii in list2) {
            println(ii)
            for (j in list2) {
              //  if (ii == j) list2.remove(ii) else
                println(ii)
            }
        }
    }
    //map
    fun map() {
        val map = HashMap<String,Int> ()
        map.put("55",5)
        map["appp"] =1
        map["appd"] =2
       println("*da"+map.get("appd"))

        val  map2 = mapOf<String,Int>("app" to 1,"adp" to 2,"adpd2" to 3,"adpd" to 4)
        for ((Str,int) in map2) {
            println("shud"+Str+"*"+int)
        }
    }
    fun Api() {
        val list = listOf("1adad","2a","33")
        val maxlist = list.maxByOrNull{ it.length }
        Log.d("sc","*"+maxlist)

        val lambda = {fruit : String -> fruit.length}
        Log.d("sc2", "*" + list.maxByOrNull(lambda))
    }
    //输出长度小于5的list集合
    fun filter() {
        val list = listOf("55d","dasd","dasdadad","1")
        val filter = list.filter { it.length<5 }
            .map { it.uppercase(Locale.getDefault()) } //toUppcrCase 小写字母转为大写字母
        for (i in filter) {
            println(i)
        }
    }
    //all 全部满足 any至少一个满足
    fun api2() {
        val list = listOf("12","add","dasda","daad")
        val all = list.all { it.length <5 }
        val any = list.any { it.length <5 }
        println(""+all+ any)
    }

    fun Threads(){
        Thread(object : Runnable {
            override fun run() {
                Log.d("","55")
            }
        }).start()

        Thread(object : Runnable{
            override fun run() {
                Log.d("","5s5")
            }
        }).start()
        Thread(Runnable {
            Log.d("","5s5")
        }).start()
    }
    //判断非空kotlin ?表示为空时什么都不做
    fun noNUll() {
        val a : String
        val b :String
        a = ""
        b = "1"
       val c = if (a != null) {
           a
       }else {
           b
       }
        val cc= a?:b
        Log.d("输出ss","*"+c+cc)
    }
    fun textlength(text : String?) : Int{
        if (text != null) {
           return text.length
        }
        return 0
    }
    fun textLength(text :String?) = text?.length ?: 0
    //$连接符
    fun Stringprice() {
        val brand = "samsung"
        val price = 1299.3
        Log.d("输出的","brand"+brand+"price"+price)
        Log.d("输出的","Cellphone(brand=$brand,price=$price)")

    }
    fun swap(list: ArrayList<Int>, index1:Int, index2:Int) {
        val maxIndex = list.size -1
        val minIndex = 0
        if (index1 < minIndex || index1 > maxIndex) throw IndexOutOfBoundsException()
        if (index2 < minIndex || index2 > maxIndex) throw IndexOutOfBoundsException()
        val tmp = list[index1]
        list[index1] = list[index2]
        list[index2] = tmp
        println("打2"+list)
    }
    //冒泡排序
    fun paixun(list: ArrayList<Int>) {
        if (list.size == 0) return
        val maxindex =list.size -1
        var boolean = false
        for (n in 0 until maxindex) {
            Log.d("输出服从d",""+n)
            for (i in 0 until maxindex-n) {
                if (list[i] > list[i+1]) {
                    swap(list,i,i+1)
                    boolean = true
                }
            }
            if (!boolean) return
        }
    }
    //快速排序
    fun quicksort(list: ArrayList<Int>, minIndex:Int, maxIndex:Int) {
        if (minIndex >= maxIndex) return
        var i = minIndex -1;
        var tmp = list[maxIndex]
        for (j in minIndex until maxIndex) {
            if (list[j] <= tmp) {
                i++
                swap(list,i,j)
            }
        }
        swap(list,i+1,maxIndex)
        quicksort(list,minIndex,i)
        quicksort(list,i+2,maxIndex)
    }
    //选择排序
    fun max(list: ArrayList<Int>, lastIndex: Int) : Int {
        if(lastIndex == 0) return 0
        var maxIndex = 0
        var maxValue = list[0]
        for (i in 1..lastIndex) {
            if (list[i] > maxValue) {
                maxValue = list[i]
                maxIndex = i
            }
        }
        return maxIndex
    }
    //实现选择排序
    fun selectionSort(list: ArrayList<Int>) {
        val maxIndex = list.size-1
        for (i in maxIndex downTo 0) {
            var idx = max(list,i)
            swap(list,idx,i)
        }
    }
    //插入排序
    fun insertionSort(list: ArrayList<Int>) {
        val maxIndex = list.size -1
        for (i in 1..maxIndex) {
            val target = list[i]
            var idx = binarySearch(list,target,0,i-1)
            for (j in i downTo  idx+1) {
                list[j] = list[j-1]
            }
            list[idx] = target
        }
    }
    //归并排序
    fun merge(list: ArrayList<Int>, lo:Int, mi:Int, hi:Int) {
        //初始化两个数组，主要是为了在最后加上哨兵
        var leftLength = mi -lo +1
        var rightLength = hi -mi+1
        var leftList = ArrayList<Int>(leftLength)
        var rightList = ArrayList<Int>(rightLength)
        for (i in lo until mi) {
            leftList.add(list[i])
        }
        leftList.add(Int.MAX_VALUE)//哨兵
        for (i in mi until hi) {
            rightList.add(list[i])
        }
        rightList.add(Int.MAX_VALUE)//哨兵
        //归并
        var leftIndex =0
        var rightIndex =0
        var idx =lo
        val n = hi-lo
        for (i in 1..n) {//循环次数
            when {
                leftList[leftIndex] < rightList[rightIndex] -> {
                    list[idx] = leftList[leftIndex]
                    leftIndex++
                }
                leftList[leftIndex] >= rightIndex -> {
                    list[idx] = rightList[rightIndex]
                    rightIndex++
                }
            }
            idx++
        }
    }
    fun mergeSort(list: ArrayList<Int>, minIndex: Int, maxIndex: Int) {
        if (minIndex > maxIndex) return
        if (maxIndex == minIndex) return
        val mi = (minIndex+maxIndex)/2
        mergeSort(list,minIndex,mi)
        mergeSort(list,mi+1,maxIndex)
        merge(list,minIndex,mi+1,maxIndex+1)//这里主要需要+1是因为归并的实现是右开区间
    }

}