Kotlin基本语法(二)

本文介绍Kotlin中的ranges和集合操作技巧,包括如何使用in操作符检查数值是否在指定范围内、如何在范围内迭代、如何使用lambda表达式过滤和映射集合等。
9、使用ranges
使用 in 操作符检查数值是否在某个范围内:
fun main(args: Array<String>) {
  val x = 10
  val y = 9
  if (x in 1..y+1) {
  println("fits in range")
  }
}
检查数值是否在范围外:
fun main(args: Array<String>) {
  val list = listOf("a", "b", "c")
  if (-1 !in 0..list.lastIndex) {
  println("-1 is out of range")
}
 if (list.size !in list.indices) {
  println("list size is out of valid list indices range too")
 }
}
在范围内迭代
fun main(args: Array<String>) {
  for (x in 1..5) {
   print(x)
  }
}
或者使用步进:
fun main(args: Array<String>) {
  for (x in 1..10 step 2) {
   print(x)
  }
  for (x in 9 downTo 0 step 3) {
   print(x)
  }
}
10、使用集合
对一个集合进行迭代:
fun main(args: Array<String>) {
  val items = listOf("apple", "banana", "kiwi")
  for (item in items) {
  println(item)
  }
}
使用 in 操作符检查集合中是否包含某个对象
fun main(args: Array<String>) {
  val items = setOf("apple", "banana", "kiwi")
  when {
   "orange" in items -> println("juicy")
   "apple" in items -> println("apple is fine too")
  }
}
使用lambda表达式过滤和映射集合:
fun main(args: Array<String>) {
  val fruits = listOf("banana", "avocado", "apple", "kiwi")
  fruits
   .filter { it.startsWith("a") }
   .sortedBy { it }
   .map { it.toUpperCase() }
   .forEach { println(it) }
}
以下是 Kotlin 入门的语法相关知识介绍: ### 基本结构 在 Kotlin 中,`fun` 代表函数,`main` 为入口函数,`()` 可添加参数,`{}` 是方法体。例如: ```kotlin fun main() { println("hello world") } ``` 若需要多参数输出打印,可以这样写: ```kotlin fun main() { println("你好") println("我是 kotlin") println("很高兴认识你") } ``` ### 变量声明 - **整型**:可以直接声明整型变量,如 `var num: Int = 10`。 - **字符型**:使用 `Char` 类型,如 `var char: Char = 'A'`。 - **集合**: - **创建 array 数组**:`val array = arrayOf(1, 2, 3)`。 - **创建 list 集合**:`val list = listOf(1, 2, 3)`。 - **不可变类型数组**:`val immutableArray = arrayOf(1, 2, 3)`。 - **Set 集合**:`val set = setOf(1, 2, 3)`,Set 集合不重复添加元素。 - **键值对集合 Map**:`val map = mapOf("key1" to 1, "key2" to 2)` [^3]。 - **Kotlin 特有的数据类型和集合**: - **Any、Nothing**:`Any` 是所有类型的父类型,`Nothing` 是所有类型的子类型。 - **元组 -- Pair**:`val pair = Pair(1, "one")`。 - **三元组 -- Triple**:`val triple = Triple(1, "one", true)` [^3]。 - **const 关键字**:用于声明编译时常量 [^3]。 ### 条件控制和循环语句 - **if...else**: ```kotlin val num = 10 if (num > 5) { println("num 大于 5") } else { println("num 小于等于 5") } ``` - **when**: - **常规用法**: ```kotlin val num = 1 when (num) { 1 -> println("num 是 1") 2 -> println("num 是 2") else -> println("num 不是 1 也不是 2") } ``` - **特殊用法 -- 并列**: ```kotlin val num = 1 when (num) { 1, 2 -> println("num 是 1 或者 2") else -> println("num 不是 1 也不是 2") } ``` - **特殊用法 -- 类型判断**: ```kotlin val obj: Any = "hello" when (obj) { is String -> println("obj 是字符串类型") is Int -> println("obj 是整型类型") else -> println("obj 是其他类型") } ``` - **特殊用法 -- 区间**: ```kotlin val num = 5 when (num) { in 1..10 -> println("num 在 1 到 10 之间") else -> println("num 不在 1 到 10 之间") } ``` - **返回值**: ```kotlin val num = 5 val result = when (num) { in 1..10 -> "num 在 1 到 10 之间" else -> "num 不在 1 到 10 之间" } println(result) ``` - **循环**: - **for..in**: ```kotlin for (i in 1..5) { println(i) } ``` - **forEach**: ```kotlin val list = listOf(1, 2, 3) list.forEach { println(it) } ``` - **迭代器**: ```kotlin val list = listOf(1, 2, 3) val iterator = list.iterator() while (iterator.hasNext()) { println(iterator.next()) } ``` - **【扩展】for..in 中的 withIndex 方法**: ```kotlin val list = listOf(1, 2, 3) for ((index, value) in list.withIndex()) { println("索引 $index 的值是 $value") } ``` - **【扩展】forEachIndexed() 方法**: ```kotlin val list = listOf(1, 2, 3) list.forEachIndexed { index, value -> println("索引 $index 的值是 $value") } ``` - **do...while 和 while**: ```kotlin var i = 0 do { println(i) i++ } while (i < 5) var j = 0 while (j < 5) { println(j) j++ } ``` - **return,break,continue 结束语句的使用**: - **结束循环分支**: ```kotlin for (i in 1..5) { if (i == 3) { break } println(i) } ``` - **标签备注代码块 -- @**: ```kotlin outer@ for (i in 1..5) { for (j in 1..5) { if (i == 3 && j == 3) { break@outer } println("$i, $j") } } ``` - **forEach 退出循环的几种方式**:可以使用 `run` 结合 `return@forEach` 退出循环 [^3]。 ### 区间 - **语法**:使用 `..` 表示区间,如 `1..5` 表示从 1 到 5 的区间。 - **遍历**: ```kotlin for (i in 1..5) { println(i) } ``` - **查找是否在区间内**: ```kotlin val num = 3 if (num in 1..5) { println("num 在 1 到 5 之间") } ``` - **字符区间**: ```kotlin for (c in 'a'..'c') { println(c) } ``` ### 函数 - **函数定义**: ```kotlin fun add(a: Int, b: Int): Int { return a + b } ``` - **infix 关键字**:用于定义中缀函数,如: ```kotlin infix fun Int.add(other: Int): Int { return this + other } val result = 1 add 2 println(result) ``` - **参数省略**:可以为函数参数设置默认值,如: ```kotlin fun printMessage(message: String = "Hello") { println(message) } printMessage() printMessage("World") ``` - **函数类型参数**: ```kotlin fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int { return operation(a, b) } val result = calculate(1, 2) { x, y -> x + y } println(result) ``` - **多参数 -- vararg**: ```kotlin fun printNumbers(vararg numbers: Int) { for (number in numbers) { println(number) } } printNumbers(1, 2, 3) ``` ### 访问和属性修饰符 - **kotlin 修饰符**:包括 `private`、`protected`、`public`、`internal` 等。 - **internal**:表示模块内可见。 - **默认修饰符**:默认是 `public`。 - **open 关键字开启继承并实现**:用于允许类被继承和函数被重写 [^3]。 ### 类与对象 - **声明和调用**: ```kotlin class Person { var name: String = "" var age: Int = 0 } val person = Person() person.name = "John" person.age = 30 println("Name: ${person.name}, Age: ${person.age}") ``` - **get 和 set**:可以自定义属性的 getter 和 setter 方法。 ```kotlin class Person { var name: String = "" get() = field.toUpperCase() set(value) { field = value } } ``` - **init 函数初始化**: ```kotlin class Person { var name: String var age: Int init { name = "John" age = 30 } } ``` - **constructor 构造函数**: - **主构造函数**: ```kotlin class Person constructor(name: String, age: Int) { var name: String = name var age: Int = age } ``` - **级构造函数**: ```kotlin class Person { var name: String = "" var age: Int = 0 constructor(name: String) { this.name = name } constructor(name: String, age: Int) : this(name) { this.age = age } } ``` - **多个构造函数**:可以有多个构造函数。 - **省略主构造函数并写了次构造函数**: ```kotlin class Person { var name: String = "" var age: Int = 0 constructor(name: String, age: Int) { this.name = name this.age = age } } ``` - **类的继承与重写**: - **继承**:使用 `:` 表示继承,如 `class Student : Person()`。 - **继承构造函数初始化**: ```kotlin open class Person(name: String, age: Int) { // ... } class Student(name: String, age: Int, grade: Int) : Person(name, age) { // ... } ``` - **函数的重写**:使用 `open` 关键字允许函数被重写,使用 `override` 关键字重写函数。 ```kotlin open class Person { open fun sayHello() { println("Hello") } } class Student : Person() { override fun sayHello() { println("Hello, I'm a student") } } ``` - **属性的重写**:使用 `open` 关键字允许属性被重写,使用 `override` 关键字重写属性。 ```kotlin open class Person { open val name: String = "John" } class Student : Person() { override val name: String = "Alice" } ``` - **抽象类、嵌套类和内部类**: - **抽象类**:使用 `abstract` 关键字定义抽象类,抽象类中可以有抽象方法。 - **嵌套类**:在类中定义的类,默认是静态的。 - **内部类**:使用 `inner` 关键字定义内部类,内部类可以访问外部类的成员 [^3]。 ### 自定义注解 可以使用 `@Retention`、`@Target` 等注解来定义自定义注解。 ### 接口与接口实现 - **接口定义与实现**: ```kotlin interface Animal { fun eat() } class Dog : Animal { override fun eat() { println("Dog is eating") } } ``` - **接口成员变量**: - **单个接口函数复写**:如上述示例。 - **多个接口同名函数复写**: ```kotlin interface A { fun foo() { println("A.foo()") } } interface B { fun foo() { println("B.foo()") } } class C : A, B { override fun foo() { super<A>.foo() super<B>.foo() } } ``` - **接口成员存在变量和常量**:接口中可以定义常量和抽象属性 [^3]。 ### 数据类、伴生类、枚举类 - **数据类**:使用 `data` 关键字定义数据类,数据类会自动生成 `equals()`、`hashCode()`、`toString()` 等方法。 ```kotlin data class User(val name: String, val age: Int) val user = User("John", 30) println(user) ``` - **伴生类**: - **定义伴生类**:在类中使用 `companion object` 定义伴生类。 - **@JvmStatic 注解**:用于在 Java 代码中直接调用伴生类的静态方法。 - **const 关键字**:用于定义伴生类中的常量 [^3]。 - **枚举类**: - **定义**: ```kotlin enum class Color { RED, GREEN, BLUE } ``` - **传参**: ```kotlin enum class Color(val rgb: Int) { RED(0xFF0000), GREEN(0x00FF00), BLUE(0x0000FF) } ``` - **继承与实现**:枚举类可以实现接口 [^3]。 ### 单例和对象表达式 - **单例模式的创建**:使用 `object` 关键字创建单例类,如: ```kotlin object Singleton { fun doSomething() { println("Doing something") } } Singleton.doSomething() ``` - **对象表达式**:用于创建匿名对象,如: ```kotlin val person = object { var name: String = "John" var age: Int = 30 } println("Name: ${person.name}, Age: ${person.age}") ``` ### 密封类和密封接口 - **密封类**:使用 `sealed` 关键字定义密封类,密封类的子类必须在同一文件中定义。 - **密封接口**:使用 `sealed` 关键字定义密封接口 [^3]。 ### 位运算 Kotlin 中没有专门的位运算符,针对 `int` 和 `long` 类型提供了中辍形式的方法,如 `var bit = (1 shl 2) and 0x1111` [^4]。 ### lambda 表达式 ```kotlin // 测试 fun main(args: Array<String>) { val sumLambda: (Int, Int) -> Int = { x, y -> x + y } println(sumLambda(1, 2)) // 输出 3 } ``` ### 定义常量与变量 使用 `val` 定义常量,使用 `var` 定义变量,如 `val constant = 10`,`var variable = 20` [^5]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值