Kotlin基础 7

1.apply函数详解  

1.1. DSL

/**
 * 为什么要传入扩展函数(泛型),而不是一个普通的匿名函数
 * T.()->Unit
 * 扩展函数里自带了接收者对象的this隐式调用
 * 为什么是泛型的扩展函数?
 * 因为是由this 隐式调用 this 类型就是泛型类型， 相当于this的扩展函数，就把this的作用域放进去了.
 *
 * 匿名函数，也可以是扩展函数
 *
 *
 */

2.函数式编程

 3.变换函数

3.1 map函数

 

fun main() {
    val animals:List<String> = listOf("zebra", "giraffe", "elephant", "rat")

    val map:List<String> = animals.map { animals -> "A baby $animals" } //相当于stream流 map 然后自动collectList
    println(animals)//不会改变原来的集合
    println(map)
}

 3.2 flapMap

fun main() {

    val flatMap =
        listOf(listOf(1, 2, 3), listOf(4, 5, 6, 7, 8, 9)).flatMap { it -> it.map { it + 1 } } //flatMap是合并泛型里同类型的集合
    println(flatMap)

}

3.3 filter

和Java一样，不需要过多重复

3.4 合并函数

zip

fun main() {

    val employees = listOf("Jack", "Rose", "Jason")
    val shirtSize = listOf("red", "green", "yellow")
    val map:Map<String,String> = employees.zip(shirtSize).toMap()
    println(map)
}

fold

 

fun main() {

    //将每个元素乘以三叠加起来
    val fold = listOf(1, 2, 3, 4).fold(0) { acc, i ->
        println("acc = $acc")
        acc + (i * 3)
    }
    println("sum = $fold")


}

4.序列

none 是 若有一个为 true 则为false ，全为false 则为true

fun Int.isPrime():Boolean{
    ( 2 until this).map {
        if (this % it == 0){
            return false
        }
    }
    return true
}

fun main() {


    //假定0-5000之内，可以找到1000个素数
    val toList = (1..5000).toList().filter { it.isPrime() }.take(1000)//take 拿去前1000个
    println(toList)

    //就是不知道有多少个可变的序列
    val oneTousandPrimes = generateSequence(2) { v ->
        v + 1
    }.filter { it.isPrime() }.take(1000)
    println(oneTousandPrimes.toList().size)

}

 5. Java与Kotlin互操作性和可空性

package javahuixang

fun main() {
    val adversary = Jhava()
    val determineGreeting = adversary.determineGreeting()
    //String! 平台类型  有可能会有空指针 ，需要处理一下
    println(determineGreeting?.toLowerCase())
}

package javahuixang;

public class Jhava {
    public String utterGreeting(){
        return "Hello";
    }

    public String determineGreeting(){
        return null;
    }





}

6.类型映射

package javahuixang;

public class Jhava {

    public int hitPoints = 3322;
    public String utterGreeting(){
        return "Hello";
    }

    public String determineGreeting(){
        return null;
    }





}

package javahuixang

fun main() {
    val jhava = Jhava()
    println(jhava.hitPoints.javaClass)
}

7.属性访问

 

package javahuixang

fun main() {
    val jhava = Jhava()
    println(jhava.hitPoints)
}

package javahuixang;

public class Jhava {

    private int hitPoints = 3322;
    public String utterGreeting(){
        return "Hello";
    }

    public String determineGreeting(){
        return null;
    }

    public int getHitPoints() {
        System.out.println("get");
        return hitPoints;
    }

    public void setHitPoints(int hitPoints) {
        this.hitPoints = hitPoints;
    }
}

8.Java调用kotlin

package javahuixang

fun main() {
    val adversary = Jhava()
    val determineGreeting = adversary.determineGreeting()
    //String! 平台类型  有可能会有空指针 ，需要处理一下
    println(determineGreeting?.toLowerCase())
}


fun makeProclamation() = "Greetings,beast!"

   public static void main(String[] args) {
        String s = HeroKt.makeProclamation();
        System.out.println(s);
    }

9.@file:JvmName 给kotlin文件起别名

@file:JvmName("Hero")
package javahuixang
fun main() {
    val adversary = Jhava()
    val determineGreeting = adversary.determineGreeting()
    //String! 平台类型  有可能会有空指针 ，需要处理一下
    println(determineGreeting?.toLowerCase())
}


fun makeProclamation() = "Greetings,beast!"

 public static void main(String[] args) {
        String s = Hero.makeProclamation();
        System.out.println(s);
    }

10.@JvmField

package javahuixang

class Spellbook{
    @JvmField
    val spells = listOf("a","b")
   
}

  public static void main(String[] args) {
        Spellbook spellbook = new Spellbook();//加了  @JvmField 自动调用 kotlin的get方法 ，给Java提供了Kotlin的语法
        List<String> spells = spellbook.spells;
    }

11.@JvmOverload

@JvmOverloads
fun handOverFood(leftHand:String="berries",rightHand:String = "beef"){
    println("Mmmm... you hand over some delicious $leftHand and $rightHand")
}

 public static void main(String[] args) {
        //Java要支持 用默认值 得重载
        Hero.handOverFood();
    }

kotlin最大的优势就是可以和Java互编

12. @JvmStatic

package javahuixang

class Spellbook{
    @JvmField
    val spells = listOf("a","b")

    companion object{
        @JvmField
        val MX=10
        @JvmStatic
        fun getSpellGreeting() = println("i am a good")
    }

}

    public static void main(String[] args) {
        //Java要支持 用默认值 得重载
//        Spellbook.Companion.getMX();
        System.out.println(Spellbook.MX);
        //让JAVA支持kotlin的写法
        Spellbook.getSpellGreeting();
    }

类加载就加载出来的，在JVM加载不会有线程安全问题

13.Throws

 Kotlin抛出的异常，让JAVA能够catch到

 想要Java 能够catch kotlin 抛出的异常，必须用 这个注解

@kotlin.jvm.Throws(IOException::class)
fun acceptApology() {
    throw IOException()
}

Java 

  try {
            Hero.acceptApology();
        } catch (IOException e) {
            System.out.println("catch");
        }

14.函数类型操作

 Java调用kotlin 匿名函数

val translator= {utterance:String ->
    println(utterance.toLowerCase().capitalize())
}

    public static void main(String[] args) {

        Function1<String, Unit> translator = Hero.getTranslator();

         translator.invoke("TRUCE");


    }