zoukankan      html  css  js  c++  java

  • [Kotlin参考]一、总览-(10)1.3新增功能

    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
    ➤微信公众号：山青咏芝（let_us_code）
    ➤博主域名：https://www.zengqiang.org
    ➤GitHub地址：https://github.com/strengthen/LeetCode
    ➤原文地址：https://www.cnblogs.com/strengthen/p/12152310.html
    ➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
    ➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

    Kotlin 1.3的新功能

    协程发布

    经过长时间和广泛的战斗测试，协程现已发布！这意味着从Kotlin 1.3开始，语言支持和API 完全稳定。查看新的协程概述页面。

    Kotlin 1.3在Reflection API中引入了有关暂停功能和协程支持的可调用引用。

    Kotlin /本机

    Kotlin 1.3继续改进和完善了Native目标。有关详细信息，请参见Kotlin / Native概述。

    多平台项目

    在1.3中，我们已经完全重新设计了多平台项目的模型，以提高表达能力和灵活性，并使共享通用代码更加容易。此外，现在还支持Kotlin / Native作为目标之一！

    与旧模型的主要区别在于：

    • 在旧模型中，需要将公共代码和特定于平台的代码放在独立的模块中，并通过expectedBy依赖关系进行链接。现在，通用的和特定于平台的代码被放置在同一模块的不同源根目录中，从而使项目更易于配置。
    • 现在，存在针对不同支持平台的大量预设平台配置。
    • 的依赖关系的配置已经被改变; 现在为每个源根分别指定依赖项。
    • 现在可以在平台的任意子集之间共享源集（例如，在针对JS，Android和iOS的模块中，您可以具有仅在Android和iOS之间共享的源集）。
    • 现在支持发布多平台库。

    有关更多信息，请参考Multiplatform Programming文档。

    合约

    Kotlin编译器会进行大量的静态分析，以提供警告并减少样板。最著名的功能之一是智能广播-具有基于执行的类型检查自动执行强制转换的功能：

     
     
     
     
     
    fun  foo（s：String ？）{
        if（s  ！=  null）s。length  //编译器自动将's'强制转换为'String'
    }
     
     
     

    但是，一旦在单独的功能中提取了这些检查，所有智能广播就会立即消失：

     
     
     
     
     
    有趣的 字符串？。isNotNull（）：布尔值 =  此 ！=  null
    ​
    fun  foo（s：String ？）{
        如果（小号。isNotNull（））š。长度 //没有智能广播:(
    }
     
     
     

    为了改善这种情况下的行为，Kotlin 1.3引入了称为合同的实验机制。

    合同允许函数以编译器可以理解的方式显式描述其行为。当前，支持两种情况：

    • 通过声明函数的调用结果与传递的参数值之间的关系来改进智能广播分析：
     
     
     
     
     
    有趣的 需求（条件：布尔值）{
        //这是一种语法形式，它告诉编译器：
        //“如果此函数成功返回，则传递的'condition'为true”
        合同 { return（）表示 条件 }
        如果（！条件）抛出 IllegalArgumentException（...）
    }
    ​
    fun  foo（s：String ？）{
        require（s  是 String）
        //此处将s智能广播到'String'，因为否则
        //'require'将引发异常
    }
     
     
     
    • 在存在高阶函数的情况下改进变量初始化分析：
     
     
     
     
     
    有趣的 同步（锁定：任何？，块：（）->  单位）{
        //它告诉编译器：
        //“此函数将在此立即调用'block'，并且恰好一次”
        合同 { callsInPlace（block，EXACTLY_ONCE）}
    }
    ​
    有趣的 foo（）{
        VAL  X：诠释
        同步（锁定）{
            x  =  42  //编译器知道传递给'synchronize'的lambda被称为
                   //仅一次，因此不会报告任何重新分配
        }
        println（x）//编译器知道绝对会调用lambda，执行
                   //初始化，因此此处将'x'视为已初始化
    }
     
     
     

    stdlib中的合约

    stdlib已经使用了合同，因此可以改善上述分析。合同的这部分内容是稳定的，这意味着您可以立即从改进的分析中受益，而无需任何其他选择：

     
     
     
     
     
     
     
    娱乐 栏（x：字符串？）{
        如果（！X。isNullOrEmpty（））{
            println（“'$ x'的长度是$ {x.length}”）//是的，智能广播为非空！
        }
    }
     
     
     
    目标平台：JVM 。运行在科特林v 61年3月1日

    定制合同

    可以为您自己的函数声明合同，但是此功能是实验性的，因为当前语法处于早期原型状态，并且很可能会更改。另外，请注意，当前Kotlin编译器不验证合同，因此编写正确和合理的合同是程序员的责任。

    自定义合同是通过调用contractstdlib函数引入的，该函数提供了DSL范围：

     
     
     
     
     
    有趣的 字符串？。isNullOrEmpty（）：布尔值 {
        合同 {
            返回（false）隐含（此@isNullOrEmpty  ！=  null）
        }
        返回 此 ==  null  ||  isEmpty（）
    }
     
     
     

    请参阅KEEP中有关语法的详细信息以及兼容性声明。

    捕获when变量中的主题

    在Kotlin 1.3中，现在可以将when主题捕获为变量：

     
     
     
     
     
    有趣的 请求。getBody（）=
            when（val  response  =  executeRequest（））{
                是 成功 ->  响应。身体
                是 HttpError  - >  抛出 HttpException（响应。状态）
            }
     
     
     

    尽管已经可以在之前提取此变量when，但是valin when的范围已适当地限制于的主体when，因此可以防止名称空间污染。请参阅when 此处的完整文档。

    接口伴侣中的@JvmStatic和@JvmField

    使用Kotlin 1.3，可以companion使用注释@JvmStatic和标记接口对象的成员@JvmField。在类文件中，此类成员将被提升到相应的接口并标记为static。

    例如，以下Kotlin代码：

     
     
     
     
     
    界面 Foo {
        伴随 对象 {
            @JvmField
            val  答案：Int  =  42
    ​
            @JvmStatic
            有趣的 sayHello（）{
                println（“您好，世界！”）
            }
        }
    }
     
     
     

    等效于以下Java代码：

     
     
     
     
     
    界面 Foo {
        public  static  int  答案 =  42 ;
        公共 静态 无效的 sayHello（）{
            // ...
        }
    }
     
     
     

    注释类中的嵌套声明

    在Kotlin 1.3中，注释可能具有嵌套的类，接口，对象和同伴：

     
     
     
     
     
    注释 类 Foo {
        枚举 类 方向 { UP，DOWN，LEFT，RIGHT }
    

        注释 类 栏
    

    ​
    

        伴随 对象 {
    

            fun  foo（）：Int  =  42
    

            val  bar：整数 =  42
    

        }
    

    }
    

    

    

    

    

    

     
    

     
    

    

    

    

     
    

    

    

    

    无参数 main
    

    按照惯例，Kotlin程序的入口点是带有签名的函数，如main(args: Array<String>)，其中args表示传递给程序的命令行参数。但是，并非每个应用程序都支持命令行参数，因此该参数通常最终不被使用。
    

    Kotlin 1.3引入了一种main不带参数的简单形式。现在，科特林的“ Hello，World”要短19个字符！
    

    

    

    

     
    

    

    

     
    

    

    

    

    

    

     
    

     
    

     
    

     
    

    

    有趣的 主要（）{
    

        println（“您好，世界！”）
    

    }
    

    

    

    

    

    

     
    

     
    

    

    

    

     
    

    

    目标平台：JVM 。运行在科特林v 61年3月1日
    

    

    

    功能强大
    

    在科特林，功能类型表示为泛型类采取不同数量的参数：Function0<R>，Function1<P0, R>，Function2<P0, P1, R>，...这种方法在这份名单是有限的有一个问题，它目前与结束Function22。
    

    Kotlin 1.3放宽了此限制，并增加了对功能更大的支持：
    

    

    

    

    

    

     
    

    

    

    

    

    

     
    

     
    

     
    

     
    

    

    有趣的 trueEnterpriseComesToKotlin（块：（任何，任何，... / * 42个更多* /，任何）->  任何）{
    

        块（任何（），任何（），...，任何（））
    

    }
    

    

    

    

    

    

     
    

     
    

    

    

    

     
    

    

    

    

    渐进模式
    

    Kotlin非常关心代码的稳定性和向后兼容性：Kotlin兼容性策略指出，“重大更改”（例如，使代码能够正常编译而不是不再编译的更改）只能在主要版本（1.2）中引入，1.3等）。
    

    我们认为，许多用户可以使用更快的周期，在此周期内，关键的编译器错误修复程序会立即到达，从而使代码更安全，更正确。因此，Kotlin 1.3引入了渐进式编译器模式，可以通过将参数传递-progressive给编译器来启用它。
    

    在渐进模式下，语言语义上的某些修复可以立即到达。所有这些修复程序都有两个重要的属性：
    

      

    • 它们保留了源代码与较早版本的编译器的向后兼容性，这意味着渐进式编译器可编译的所有代码都将由非渐进式编译器很好地编译。
      • 

    • 它们只能使代码在某种意义上更加安全 -例如，可以禁止某些不正确的智能广播，可以将生成的代码的行为更改为更可预测/更稳定，等等。
      • 

    

    启用渐进模式可能需要您重写一些代码，但不要太多-精心挑选，检查并在渐进模式下启用的所有修复程序，并提供工具迁移帮助。我们希望渐进模式将是任何积极维护的代码库的理想选择，这些代码库会迅速更新到最新的语言版本。
    

    内联类
    

    

    内联类仅自Kotlin 1.3起可用，目前仍处于实验阶段。看到细节的参考。
    

    

    Kotlin 1.3引入了一种新的声明— inline class。可以将内联类视为常规类的受限版本，特别是，内联类必须具有一个完全相同的属性：
    

    

    

    

    

    

     
    

    

    

    

    

    

     
    

     
    

     
    

     
    

    

    内联 类 名称（val  s：String）
    

    

    

    

    

    

     
    

     
    

    

    

    

     
    

    

    

    

    Kotlin编译器将使用此限制来积极优化内联类的运行时表示形式，并用基础属性的值替换其实例，并在可能的情况下删除构造函数调用，GC压力并启用其他优化：
    

    

    

    

     
    

    

     
    

    

     
    

    

    

    

    

    

     
    

     
    

     
    

     
    

    

    有趣的 主要（）{
    

        //在下一行中，没有构造函数调用发生，并且
    

        //在运行时'name'仅包含字符串“ Kotlin”
    

        val  name  =  名称（“ Kotlin”）
    

        的println（名称。小号）
    

    }
    

    

    

    

    

    

     
    

     
    

    

    

    

     
    

    

    目标平台：JVM 。运行在科特林v 61年3月1日
    

    

    

    请参见参考内联类的细节。
    

    无符号整数
    

    

    自Kotlin 1.3起，无符号整数才可用，目前尚处于实验阶段。看到细节的参考。
    

    

    Kotlin 1.3引入了无符号整数类型：
    

      

    • kotlin.UByte：一个无符号的8位整数，范围从0到255
      • 

    • kotlin.UShort：一个无符号的16位整数，范围从0到65535
      • 

    • kotlin.UInt：一个无符号的32位整数，范围从0到2 ^ 32-1
      • 

    • kotlin.ULong：一个无符号的64位整数，范围从0到2 ^ 64-1
      • 

    

    无符号对应项也支持大多数带符号类型的功能：
    

    

    

    

     
    

    

     
    

    

     
    

    

    

    

    

    

     
    

     
    

     
    

     
    

    

    //您可以使用文字后缀定义无符号类型
    

    val  uint  =  42u 
    

    val  ulong  =  42u L
    

    val  ubyte：UByte  =  255u
    

    ​
    

    //您可以通过stdlib扩展将有符号类型转换为无符号类型，反之亦然：
    

    val  int  =  uint。toInt（）
    

    val  byte  =  ubyte。toByte（）
    

    val  ulong2  =  字节。toULong（）
    

    ​
    

    //无符号类型支持类似的运算符：
    

    值 x  =  20u  +  22u
    

    val  y  =  1u  shl  8
    

    val  z  =  “ 128”。toUByte（）
    

    val  范围 =  1u .. 5u
    

    

    

    

    

    

     
    

     
    

    

    

    

     
    

    

    目标平台：JVM 。运行在科特林v 61年3月1日
    

    

    

    有关详细信息，请参见参考。
    

    @JvmDefault
    

    

    @JvmDefault仅从Kotlin 1.3起可用，并且目前处于试验阶段。请参阅参考页中的详细信息。
    

    

    Kotlin面向广泛的Java版本，包括Java 6和Java 7，其中不允许界面中的默认方法。为方便起见，Kotlin编译器可解决该限制，但是此解决方法与defaultJava 8中引入的方法不兼容。
    

    这可能是Java互操作性的问题，因此Kotlin 1.3引入了@JvmDefault注释。带有此注释的default方法将作为JVM的方法生成：
    

    

    

    

    

    

     
    

    

    

    

    

    

     
    

     
    

     
    

     
    

    

    界面 Foo {
    

        //将作为“默认”方法生成
    

        @JvmDefault
    

        fun  foo（）：Int  =  42
    

    }
    

    

    

    

    

    

     
    

     
    

    

    

    

     
    

    

    

    

    

    警告！注释您的API @JvmDefault会对二进制兼容性产生严重影响。在生产中使用之前，请确保仔细阅读参考页@JvmDefault。
    

    

    标准库
    

    多平台 Random
    

    在Kotlin 1.3之前，没有统一的方法在所有平台上生成随机数-我们不得不诉诸于平台特定的解决方案，例如java.util.Random在JVM上。此版本通过引入class kotlin.random.Random在所有平台上都可以解决此问题：
    

    

    

    

     
    

    

     
    

    

     
    

    

    

    

    

    

     
    

     
    

     
    

     
    

    

    VAL  数 =  随机。nextInt（42）   //数字在[0，限制）范围内
    

    println（编号）
    

    

    

    

    

    

     
    

     
    

    

    

    

     
    

    

    目标平台：JVM 。运行在科特林v 61年3月1日
    

    

    

    isNullOrEmpty / orEmpty扩展
    

    isNullOrEmpty并且orEmptystdlib中已经存在某些类型的扩展名。true如果接收方为null或为空，则第一个返回，如果接收方为，则第二个回退为空实例null。Kotlin 1.3在对象的集合，地图和数组上提供了类似的扩展。
    

    在两个现有数组之间复制元素
    

    在array.copyInto(targetArray, targetOffset, startIndex, endIndex)为现有的阵列类型，包括无符号阵列的功能，使之更容易实现在纯科特林基于阵列的容器。
    

    

    

    

     
    

    

     
    

    

     
    

    

    

    

    

    

     
    

     
    

     
    

     
    

    

    val  sourceArr  =  arrayOf（“ k”，“ o”，“ t”，“ l”，“ i”，“ n”）
    

    val  targetArr  =  sourceArr。copyInto（arrayOfNulls < String >（6），3，startIndex  =  3，endIndex  =  6）
    

    的println（targetArr。contentToString（））
    

    ​
    

    sourceArr。copyInto（targetArr，startIndex  =  0，endIndex  =  3）
    

    的println（targetArr。contentToString（））
    

    

    

    

    

    

     
    

     
    

    

    

    

     
    

    

    目标平台：JVM 。运行在科特林v 61年3月1日
    

    

    

    associateWith
    

    拥有键列表并希望通过将这些键中的每个键与某个值相关联来构建映射是一种很常见的情况。以前可以使用此associate { it to getValue(it) }功能来实现此功能，但现在我们引入了一个更高效，更容易探索的替代方法：keys.associateWith { getValue(it) }。
    

    

    

    

     
    

    

     
    

    

     
    

    

    

    

    

    

     
    

     
    

     
    

     
    

    

    val  键 =  'a' .. 'f'
    

    val  map  =  键。associateWith { 它。toString（）。重复（5）。大写（）}
    

    地图。forEach { println（it）}
    

    

    

    

    

    

     
    

     
    

    

    

    

     
    

    

    目标平台：JVM 。运行在科特林v 61年3月1日
    

    

    

    ifEmpty和ifBlank函数
    

    集合，映射，对象数组，char序列和序列现在具有一个ifEmpty函数，该函数允许指定一个后备值，如果该值是空的，它将代替接收者使用：
    

    

    

    

     
    

    

     
    

    

     
    

    

    

    

    

    

     
    

     
    

     
    

     
    

    

    fun  printAllUppercase（数据：列表< 字符串>）{
    

        val  结果 =  数据
    

        。过滤 { 它。全部 { c-  >  c。isUpperCase（）}}
    

            。ifEmpty { listOf（“ <无大写字母>”）}
    

        结果。forEach { println（it）}
    

    }
    

    ​
    

    printAllUppercase（listOf（“ foo”，“ Bar”））
    

    printAllUppercase（listOf（“ FOO”，“ BAR”））
    

    

    

    

    

    

     
    

     
    

    

    

    

     
    

    

    目标平台：JVM 。运行在科特林v 61年3月1日
    

    

    

    Char序列和字符串还具有与ifBlank扩展相同的扩展名ifEmpty，但检查的字符串全是空格而不是空。
    

    

    

    

     
    

    

     
    

    

     
    

    

    

    

    

    

     
    

     
    

     
    

     
    

    

    val  s  =  “  n”
    

    的println（小号。ifBlank { “<空白>” }）
    

    的println（小号。ifBlank { 空 }）
    

    

    

    

    

    

     
    

     
    

    

    

    

     
    

    

    目标平台：JVM 。运行在科特林v 61年3月1日
    

    

    

    密封类的反思
    

    我们向其中添加了一个新的API，kotlin-reflect该API 可用于枚举一个sealed类的所有直接子类型，即KClass.sealedSubclasses。
    

    较小的变化
    

      

    • Boolean 类型现在有同伴。
      • 

    • Any?.hashCode()扩展名，它为返回0 null。
      • 

    • Char现在提供MIN_VALUE/ MAX_VALUE常量。
      • 

    • SIZE_BYTES和SIZE_BITS基本类型随播广告中的常量。
      • 

    

    工装
    

    IDE中的代码样式支持
    

    Kotlin 1.3引入了对IDE中推荐代码风格的支持。请查看此页面以获取迁移指南。
    

    Kotlinx序列化
    

    kotlinx.serialization是一个库，为Kotlin中的对象（反序列化）提供多平台支持。以前，这是一个单独的项目，但自Kotlin 1.3起，它与Kotlin编译器发行版一起提供，与其他编译器插件同等。主要区别在于您无需手动注意与您使用的Kotlin IDE插件版本兼容的序列化IDE插件：现在，Kotlin IDE插件已经包含序列化！
    

    有关详细信息，请参见此处。
    

    

    请注意，即使kotlinx.serialization现在随Kotlin Compiler发行版一起提供，它仍被认为是实验功能。
    

    

    脚本更新
    

    

    请注意，脚本编写是一项实验性功能，这意味着未提供API的兼容性保证。
    

    

    Kotlin 1.3继续发展和改进脚本API，引入了一些实验性的脚本自定义支持，例如添加外部属性，提供静态或动态依赖关系等。
    

    有关更多详细信息，请咨询KEEP-75。
    

    划痕支持
    

    Kotlin 1.3引入了对可运行Kotlin 暂存文件的支持。Scratch文件是带有.kts扩展名的kotlin脚本文件，您可以运行该文件并直接在编辑器中获取评估结果。
    

    有关详细信息，请查阅Scratches常规文档。
    

    
    
                
    
                
              
    • 
              
    
              
  • 

                相关阅读:
    
                
                  「Baltic2015」Network
                    
    noip模拟赛 蒜头君的排序
                    
    noip模拟赛 蒜头君的兔子
                    
    codevs2171 棋盘覆盖
                    
    noip模拟赛 蒜头君的坐骑
                    
    noip模拟赛 蒜头君的树
                    
    noip模拟赛 蒜头君打地鼠
                    
    noip模拟赛 密码
                    
    noip模拟赛 轰炸
                    
    noip模拟赛 毁灭
                    
                        
              
    • 
              
    
              
  • 
                原文地址：https://www.cnblogs.com/strengthen/p/12152310.html
              
    • 

            

          



          
          

            

            

          

        

      

      



      

      

        

          Copyright © 2011-2022 走看看