【Kotlin】和【Java】使用对比小结

本文对比了Kotlin和Java在变量访问权限、类型系统、函数返回值、数组、基本数据类型、静态方法调用、构造函数以及集合等方面的差异。Kotlin中变量默认为私有,使用get/set,public需加@JvmField。Java的void对应Kotlin的Unit。推荐使用Kotlin的IntArray等避免装箱。Kotlin无static,可通过object或companion object实现类似功能。Kotlin的List默认不可变,常用ArrayList或MutableList。
  1. Kotlin中的private和public
    Kotlin中创建的默认变量都是私有类型,会隐式生成对应的get/set函数。调用的时候虽然是直接通过变量名调用,实际上调用的是变量对应的get/set方法。要是变量变为public 需要使用@JvmFiled注解。
    私有变量:

    	class User{
    		    var name:String? = null      //相当于private
    		        //如果对get set只是返回变量值,则可以省略
    		        set(value){
    		            filed = value //field为中间变量
    		        }
    		        get(){
    		            return field
    		        }
    		}
    

    公有变量:

    class User{
        @JvmField
        var name:String? = null      //相当于public修饰
    }
    
  2. Kotlin中的类型系统
    Java中所有类的基类是Object,Kotlin中是Any。

    class Java extents Object{
    }
    
    class Kotlin : Any() {
    }
    

    Java中函数无返回值使用void,Kotlin中使用Unit。

    public void test(){ }
    
    public fun test(): Unit{ } //Unit可以省略
    
  3. 数组

    private String[] array = new String[]{"a","a","a"}; //java
    
    private var array = arrayOf("a","a","a”) //kotlin
    

    使用基本类型数组时,arrayOf会将数据进行装箱拆箱操作,会增加内存开销 。推荐使用IntArray,FloatArray等。。

    var intArray == intArrayOf(1,2,3,4) //InArray
    var floatArray == floatArrayOf(1,2,3,4) //FloatArray
    
  4. 基本数据类型
    基本数据类型的特点:不可为null,有默认值。如Java中int, double, float等,在Kotlin中对应的是Int, Double, Float。看起来有点像Java中基本数据类型的封装类,但是并不是。封装类是可空的,所以Java中基本数据类型的封装类(Int, Double, Float等)对应的Kotlin类为(Int?, Double?, Float?)。

  5. 静态方法
    Java中Utils中通常都是静态方法,为了方便调用。Kotlin中取消了static关键字,声明静态方法有2种方式:
    1.直接在文件中创建方法。
    Kotlin中的方法是可以直接写在文件中的,这样调用的时候只需import一下文件名即可调用。
    2.使用object创建
    object修饰的类中的方法可以通过ClassName.methordName( )直接调用。虽然用法一样但是并不是创建了静态方法,而是创建了一个单例对象。 object在kotlin中的作用就是创建单例对象。所以在Java中调用的时候要通过Instance实力调用。

     object Utils {
         fun getLength(content:String) : Int{
             return content.length 
         }
     }
    

    调用

    	Utils.getLength("asdasdas") //kotlin
    
    Utils.INSTANCE.getLength(" sadads ")//java 
    

    3.使用companion object创建, 并用使用JvmStatic注解

    class MainActivity : BaseActivity(){
       companion object {
            const val VERSION_CODE = 10 //静态常量用const修饰,在编译期赋值
    
            @JvmStatic
            fun getLength():Int { //… } 
        }
    }
    

    调用:

    MainActivity.getLength("asdasdas") //kotlin
    MainActivity.getLength(" sadads ")//java 
    
  6. 构造函数
    Kotlin中构造函数使用constructor关键字声明:

    class Apple:Fruit{
        constructor():this("") {} 
        constructor(name:String):super(name) {} //调用父类的构造方法
    
    }
    
  7. 集合
    Kotlin中的List是不支持修改的,通常使用ArrayList或者MutableList。同理Map也是不支持修改的,通常使用HashMap

    var list: MutableList = ArrayList()
    var arrayList1 = mutableListOf(1,2,3)
    var arrayList2 = arrayListOf(1,2,3)
    var map = hashMapOf<>()
    var map2 = mutableMapOf()
    
  8. internal修饰符
    Kotlin中的对象和方法默认是public的,如果使用internal 修饰,则只能在当前Moudle中调用。internal也可以用来修饰class

<think>我们正在讨论Kotlin中的firstOrNull函数。根据引用内容,我们可以提取以下信息: 1. 引用[1]提到了findfirstOrNull的对比,说明二者在功能上有相似之处,但可能有性能或使用场景的差异。 2. 引用[2]提到flow中firstOrNulllastOrNull的行为:firstOrNull取第一个,lastOrNull取最后一个。 3. 引用[3]是关于KotlinJava互操作性的内容,与firstOrNull直接关系不大。 4. 引用[4]介绍了lastIndex扩展属性,表明Kotlin提供了一些便捷的扩展。 5. 引用[5]提到了类型别名,与firstOrNull无关。 因此,我们重点参考引用[1][2]来回答。 首先,firstOrNull是Kotlin标准库中用于集合(或序列)的一个扩展函数,它的作用是返回集合中满足条件的第一个元素,如果没有满足条件的元素则返回null。 根据引用[1],我们需要注意与`find`函数的对比。实际上,在Kotlin中,`find`函数是`firstOrNull`的一个别名,也就是说它们的实现是完全一样的。因此,在性能上没有任何区别,可以互换使用。选择哪个主要取决于代码的可读性。 根据引用[2],在Flow中也有firstOrNulllastOrNull,它们的作用分别是取第一个元素或最后一个元素(满足条件的话)。在Flow中,firstOrNull会收集直到找到第一个满足条件的元素就取消后续收集,而lastOrNull则会收集整个流然后取最后一个满足条件的元素。 下面,我们将详细说明firstOrNull函数的使用指南。 # Kotlin firstOrNull函数使用指南 `firstOrNull`函数是Kotlin集合操作中常用的一个函数,它用于查找集合中满足给定条件的第一个元素。如果集合为空或没有满足条件的元素,则返回null。 ## 函数定义 在Kotlin标准库中,`firstOrNull`有多个重载版本,但最常见的版本是: ```kotlin public inline fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T? { for (element in this) if (predicate(element)) return element return null } ``` 对于数组也有对应的扩展函数。 ## 基本用法 假设我们有一个整数列表,我们想找到第一个大于10的数: ```kotlin val numbers = listOf(1, 2, 3, 15, 20, 10, 8) val firstGreaterThan10 = numbers.firstOrNull { it > 10 } println(firstGreaterThan10) // 输出:15 ``` 如果没有找到,则返回null: ```kotlin val firstGreaterThan100 = numbers.firstOrNull { it > 100 } println(firstGreaterThan100) // 输出:null ``` ## 与`find`的关系 在Kotlin中,`find`函数与`firstOrNull`完全等价。实际上,`find`就是`firstOrNull`的别名: ```kotlin @kotlin.internal.InlineOnly public inline fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T? { return firstOrNull(predicate) } ``` 因此,你可以根据自己的喜好选择使用`firstOrNull`或`find`。通常,当我们需要强调“查找”操作时用`find`,而强调“第一个”时用`firstOrNull`。 ## 在Flow中的使用Kotlin Flow中,`firstOrNull`是一个终端操作符,它会收集流直到找到第一个满足条件的元素,然后取消流的剩余部分。如果没有找到,则返回null。 例如: ```kotlin fun main() = runBlocking { val flow = flow { emit(1) emit(2) emit(3) } val result = flow.firstOrNull { it > 1 } println(result) // 输出:2 } ``` 注意:Flow的`firstOrNull`会取消流的后续收集,因此如果条件满足得早,可以减少不必要的计算。 ## 与`first`函数的对比 Kotlin中还有一个`first`函数,它用于返回满足条件的第一个元素,但如果找不到元素,它会抛出`NoSuchElementException`。因此,当我们不确定集合中是否有满足条件的元素时,使用`firstOrNull`更安全。 例如: ```kotlin val numbers = listOf(1, 2, 3) // 使用first,找不到会抛出异常 val value = numbers.first { it > 10 } // 抛出NoSuchElementException // 使用firstOrNull,找不到返回null val safeValue = numbers.firstOrNull { it > 10 } // 返回null ``` ## 注意事项 1. 当在空集合上调用`firstOrNull`(不带条件)时,它会返回null。例如:`emptyList<Int>().firstOrNull()`返回null。 2. 对于可空类型的集合,`firstOrNull`返回的元素类型也是可空的。例如:`listOf<Int?>(null, 2).firstOrNull()`返回`null`(因为第一个元素就是null)。 3. 在序列(Sequence)中,`firstOrNull`是中间操作,并且是短路的,即找到符合条件的元素后就不再处理后续元素。 ## 总结 使用`firstOrNull`可以安全地获取集合中满足条件的第一个元素,避免异常。它与`find`函数完全等价,可以根据代码可读性选择使用。在Flow中,`firstOrNull`同样具有短路特性,能够提高效率。 更多细节可以参考标准库源代码,路径如引用[1]所述:`libraries/stdlib/src/kotlin/collections/`目录下的相关文件。 §§相关问题§§ 1. Kotlin中的`firstOrNull``find`函数有什么区别? 2. 在Kotlin Flow中,`firstOrNull``lastOrNull`的行为有什么不同? 3. 如何安全地使用`first`函数以避免`NoSuchElementException`? 4. Kotlin集合操作中,哪些函数具有短路特性? </think>### Kotlin `firstOrNull` 函数使用指南 `firstOrNull` 是 Kotlin 标准库中用于集合操作的扩展函数,其核心功能是**安全地获取集合中满足条件的第一个元素**。若找不到符合条件的元素,则返回 `null`,避免抛出异常。以下是详细指南: --- #### 1. **基础语法** ```kotlin // 集合版本 inline fun <T> Iterable<T>.firstOrNull(): T? inline fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T? // 数组版本 (如 IntArray, Array<T> 等) fun <T> Array<out T>.firstOrNull(): T? fun <T> Array<out T>.firstOrNull(predicate: (T) -> Boolean): T? ``` --- #### 2. **核心特性** | **场景** | **行为** | **返回值** | |-------------------------|--------------------------------------------------------------------------|-------------| | 集合非空且元素存在 | 返回第一个元素(或首个满足 `predicate` 的元素) | `T` | | 集合为空或无匹配元素 | 返回 `null` | `null` | | 带条件查询 | 遍历集合直至找到首个匹配项(短路操作) | `T` 或 `null` | --- #### 3. **使用示例** **示例 1:基础查询** ```kotlin val numbers = listOf(1, 2, 3, 4, 5) // 获取第一个元素 println(numbers.firstOrNull()) // 输出:1 // 获取首个大于 3 的元素 println(numbers.firstOrNull { it > 3 }) // 输出:4 // 查询不存在的元素 println(numbers.firstOrNull { it > 10 }) // 输出:null ``` **示例 2:安全处理空集合** ```kotlin val emptyList = emptyList<String>() println(emptyList.firstOrNull()) // 输出:null(无异常) ``` **示例 3:与 `lastOrNull` 对比** ```kotlin val flow = flowOf(1, 2, 3, 4) runBlocking { println(flow.firstOrNull { it % 2 == 0 }) // 输出:2(首个偶数) println(flow.lastOrNull { it % 2 == 0 }) // 输出:4(末个偶数)[^2] } ``` --- #### 4. **与 `find` 的关系** - **`find` 是 `firstOrNull` 的别名**,两者完全等效: ```kotlin // 以下代码等价 list.find { it > 3 } list.firstOrNull { it > 3 } ``` - 性能无差异,选择依据代码可读性(强调“查找”用 `find`,强调“首个”用 `firstOrNull`)[^1]。 --- #### 5. **与 `first()` 的对比** | **函数** | 无匹配元素时的行为 | 推荐场景 | |----------------|--------------------------|------------------------------| | `first()` | 抛出 `NoSuchElementException` | 确定元素必存在时使用 | | `firstOrNull` | 返回 `null` | 需安全处理未知数据的场景 | ```kotlin val list = listOf(1, 2, 3) list.first { it > 5 } // 抛出异常 list.firstOrNull { it > 5 } // 返回 null ``` --- #### 6. **在 Flow 中的行为** - 作为**终端操作符**,会启动流的收集。 - **短路特性**:找到首个匹配元素后立即取消流: ```kotlin flow { emit(1); emit(2); emit(3) }.firstOrNull { it > 1 } // 收到 2 后停止收集[^2] ``` --- #### 7. **最佳实践** 1. **替代 `first()`**: 当不确定元素是否存在时,优先使用 `firstOrNull` 避免异常。 2. **与安全调用结合**: ```kotlin val name = userList.firstOrNull()?.name ?: "Unknown" ``` 3. **性能优化**: 对大型集合使用 `asSequence()` 延迟计算: ```kotlin largeList.asSequence().firstOrNull { heavyCondition(it) } ``` --- #### 8. **源码实现** 逻辑位于标准库的 `_Collections.kt` 中: ```kotlin public inline fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T? { for (element in this) if (predicate(element)) return element return null } ``` [^1] --- ### 小结 `firstOrNull` 是 Kotlin 集合操作的**安全查询工具**,核心价值在于避免异常、简化空安全处理。与 `find` 完全互通,与 `first()` 的区别在于对空结果的容忍度。在 Flow 中具备短路特性,适合处理流式数据。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值