[TOC]
## 区间介绍
区间又叫Range,在数学里,区间通常是指一类实数集合,分为开区间、闭区间、半开半闭区间。
* 开区间指的是区间边界的两个值不包括在内,比如(a,b);
* 闭区间指的是区间边界的两个值包括在内,[a,b] ;
* 半开半闭区间指的是开区间一边的边界值不包括在内,闭区间一边的边界值包括在内,如下面的[a,b)、(a,b]
* [a,b)被称作左闭右开区间,(a,b]被称作左开右闭区间。
Kotlin里面,对区间的表示提供了更加方便的支持。
在Kotlin里面,区间表示相关的类有IntRange、LongRange、CharRange,相关的接口有ClosedRange。这三个类都实现了ClosedRange接口,参考截图:
![](https://box.kancloud.cn/176c6868de5cf91f0b896933846bdeed_547x281.jpg)
## 区间表示
### kotlin闭区间和左闭右开的表示
区间虽然分为开区间、闭区间、左开右闭区间、左闭右开。但是**Kotlin里面只支持“闭区间”和和“左闭右开”区间的表示**。**因为其实任何区间都可以转换为“闭区间”表示和“左闭右开”表示**:
| **区间** | **案例** | **闭区间表示** | **左闭右开表示** |
| ------ | ------ | --------- | ---------- |
| 开区间 | (1,10) | [2,9] | [2,10) |
| 闭区间 | [1,10] | [1,10] | [1,11) |
| 左开右闭 | (1,10] | [2,10] | [2,11) |
| 左闭右开 | [1,10) | [1,9] | [1,11) |
Kotlin怎么**支持闭区间表示呢?**(可以通过下面的区间表示案例来了解这四种方法的用途)
* 一、可以**通过IntRange、LongRange、CharRange三个类的构造方法直接构造**,
IntRange、LongRange、CharRange三个类的构造方法如下:
```
IntRange(start: Int, endInclusive: Int)
LongRange(start: Long, endInclusive: Long)
CharRange(start: Char, endInclusive: Char)
```
* 二、也可以**通过rangeTo方法生成**,rangeTo的方法定义如下:
![](http://upload-images.jianshu.io/upload_images/7368752-70c5e3148924ca9a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
>[info]PS:从下面从idea工具截图中,我们可以看出rangeTo存在于多个包中,多个kt文件中
![](https://box.kancloud.cn/e4859854f10580d58bb7889348ccbeee_836x614.jpg)
当然,**rangeTo方法可以被“..操作符”替代**,后面我们讲了运算符重载你就会理解,现在可以先记住,下面两种形式是等价的:
```
val range1 = start.rangeTo(end)
val range2 =start..end
```
>[info] 注意:上述代码中的start和end是对应的生成的不同区间的不同类型,比如生成IntRange则`
val range1 = 2.rangeTo(9)`和`val range2 =2..9`
**Kotlin怎么支持闭区间表示呢?**
通过拓展方法[until](https://www.w3cschool.cn/doc_kotlin/kotlin-api-latest-jvm-stdlib-kotlin-ranges-index.html?lang=en)参考截图:
出自包[kotlin.ranges](https://www.w3cschool.cn/doc_kotlin/kotlin-api-latest-jvm-stdlib-kotlin-ranges-index.html?lang=en)中的`_Ranges.kt`文件
![](https://i.loli.net/2019/04/19/5cb8c0f2b0595.jpg)
通过截图,我们看到了很多的拓展方法,我们摘取其中一个方法的具体定义给大家看看:
~~~
public infix fun Int.until(to: Byte): IntRange {
return this .. (to.toInt() - 1).toInt()
}
~~~
### **区间表示案例**
* 一、kotlin表示“开区间(1,10)”可以有如下4种方式,参考代码:
~~~
fun main(args: Array<String>) {
//开区间(1,10)的四种表示方法
val range11=IntRange(2,9)
val range12=2.rangeTo(9)
val range13=2..9
val range14=2 until 10
println(range11.toList())
println(range12.toList())
println(range13.toList())
println(range14.toList())
}
~~~
运行结果
```
[2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7, 8, 9]
Process finished with exit code 0
```
* 二、kotlin表示“闭区间[1,10]”可以有如下方式,参考代码:
~~~
fun main(args: Array<String>) {
// 闭区间[1,10]的四种表示方法
val range21=IntRange(1,10)
val range22=1.rangeTo(10)
val range23=1..10
val range24=1 until 11
println(range21.toList())
println(range22.toList())
println(range23.toList())
println(range24.toList())
}
~~~
运行结果
```
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Process finished with exit code 0
```
* 三、kotlin表示“左闭右开[1,10)”可以有如下方式,参考代码:
~~~
fun main(args: Array<String>) {
//左闭右开区间[1,10)的四种表示方法
val range31=IntRange(1,9)
val range32=1.rangeTo(9)
val range33=1..9
val range34=1 until 10
println(range31.toList())
println(range32.toList())
println(range33.toList())
println(range34.toList())
}
~~~
运行结果
```
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Process finished with exit code 0
```
* 四、kotlin表示“左开右闭(1,10]”可以有如下方式,参考代码:
~~~
fun main(args: Array<String>) {
//左开右闭区间(1,10]的四种表示方法
val range41=IntRange(2,10)
val range42=2.rangeTo(10)
val range43=2..10
val range44=2 until 11
println(range41.toList())
println(range42.toList())
println(range43.toList())
}
~~~
运行结果
```
[2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 3, 4, 5, 6, 7, 8, 9, 10]
Process finished with exit code 0
```
### 区间遍历
前面我们学习了如何定义区间,那**如何遍历区间中的元素呢**?
由于Range已经实现了Iterator接口,所以可以通过for循环遍历区间。
区间在for循环的时候,可以普通的for循环,还可以循环的时候调用step方法或者withIndex方法,参考代码:
~~~
/**
* 区间遍历
*/
fun main(args: Array<String>) {
val charRange='a'..'d'
println("---------普通for循环-------------")
for(c in charRange){
println(c)
}
println("---------for循环 step-------------")
for (c in charRange step 2){
println(c)
}
println("---------for循环 withIndex-------------")
for (withIndex in charRange.withIndex()){
println("${withIndex.index} -> ${withIndex.value}")
}
println("---------for循环解析析构-------------")
for ((index,value) in charRange.withIndex()){
println("${index}->${value}")
}
}
~~~
运行结果
```
---------普通for循环-------------
a
b
c
d
---------for循环 step-------------
a
c
---------for循环 withIndex-------------
0 -> a
1 -> b
2 -> c
3 -> d
---------for循环解析析构-------------
0->a
1->b
2->c
3->d
Process finished with exit code 0
```
除此之外,想要循环,我们还可以调用高阶函数,我们后面才学高阶函数,这里大家感受感受,后面再回过头来看看,代码如下:
~~~
fun main(args: Array<String>) {
val charRange = 'a'..'d'
println("----------forEach-----------")
charRange.forEach() {
println(it)
}
println("---------forEachIndexed---------")
charRange.forEachIndexed { index, c ->
println("$index->$c")
}
}
~~~
运行结果
```
----------forEach-----------
a
b
c
d
---------forEachIndexed---------
0->a
1->b
2->c
3->d
Process finished with exit code 0
```
### 区间常见方法和属性
前面我们通过for循环遍历区间元素,但是我们想要获取区间第一个元素、最后一个元素的时候,kotlin为区间都有first、start和last属性。
![](https://i.loli.net/2019/04/19/5cb8cd5a54d49.jpg)
想要**判断区间是否包含某一个元素的时候,可以使用contains**,参考代码:
~~~
fun main(args: Array<String>) {
val charRange = 'a'..'d'
val first = charRange.first
val last = charRange.last
val start = charRange.start
println("第一个元素:$first")
println("第一个元素:$start")
println("最后一个元素:$last")
println("是否包含元素a:${charRange.contains('a')}")
}
~~~
运行结果
```
第一个元素:a
第一个元素:a
最后一个元素:d
是否包含元素a:true
Process finished with exit code 0
```
到现在为止,我们还不会高阶函数,后续章节会详细介绍高阶函数。我们先知道,区间也可以像数组和集合一样,可以使用大量的高阶函数进行操作,参考IDEA提示截图:
![](https://i.loli.net/2019/04/19/5cb967c47012a.png)
- 前言
- Kotlin简介
- IntelliJ IDEA技巧总结
- idea设置类注释和方法注释模板
- 像Android Studion一样创建工程
- Gradle
- Gradle入门
- Gradle进阶
- 使用Gradle创建一个Kotlin工程
- 环境搭建
- Androidstudio平台搭建
- Eclipse的Kotlin环境配置
- 使用IntelliJ IDEA
- Kotlin学习路线
- Kotlin官方中文版文档教程
- 概述
- kotlin用于服务器端开发
- kotlin用于Android开发
- kotlin用于JavaScript开发
- kotlin用于原生开发
- Kotlin 用于数据科学
- 协程
- 多平台
- 新特性
- 1.1的新特性
- 1.2的新特性
- 1.3的新特性
- 开始
- 基本语法
- 习惯用法
- 编码规范
- 基础
- 基本类型
- 包与导入
- 控制流
- 返回与跳转
- 类与对象
- 类与继承
- 属性与字段
- 接口
- 可见性修饰符
- 扩展
- 数据类
- 密封类
- 泛型
- 嵌套类
- 枚举类
- 对象
- 类型别名
- 内嵌类
- 委托
- 委托属性
- 函数与Lambda表达式
- 函数
- Lambda表达式
- 内联函数
- 集合
- 集合概述
- 构造集合
- 迭代器
- 区间与数列
- 序列
- 操作概述
- 转换
- 过滤
- 加减操作符
- 分组
- 取集合的一部分
- 取单个元素
- 排序
- 聚合操作
- 集合写操作
- List相关操作
- Set相关操作
- Map相关操作
- 多平台程序设计
- 平台相关声明
- 以Gradle创建
- 更多语言结构
- 解构声明
- 类型检测与转换
- This表达式
- 相等性
- 操作符重载
- 空安全
- 异常
- 注解
- 反射
- 作用域函数
- 类型安全的构造器
- Opt-in Requirements
- 核心库
- 标准库
- kotlin.test
- 参考
- 关键字与操作符
- 语法
- 编码风格约定
- Java互操作
- Kotlin中调用Java
- Java中调用Kotlin
- JavaScript
- 动态类型
- kotlin中调用JavaScript
- JavaScript中调用kotlin
- JavaScript模块
- JavaScript反射
- JavaScript DCE
- 原生
- 并发
- 不可变性
- kotlin库
- 平台库
- 与C语言互操作
- 与Object-C及Swift互操作
- CocoaPods集成
- Gradle插件
- 调试
- FAQ
- 协程
- 协程指南
- 基础
- 取消与超时
- 组合挂起函数
- 协程上下文与调度器
- 异步流
- 通道
- 异常处理与监督
- 共享的可变状态与并发
- Select表达式(实验性)
- 工具
- 编写kotlin代码文档
- 使用Kapt
- 使用Gradle
- 使用Maven
- 使用Ant
- Kotlin与OSGI
- 编译器插件
- 编码规范
- 演进
- kotlin语言演进
- 不同组件的稳定性
- kotlin1.3的兼容性指南
- 常见问题
- FAQ
- 与Java比较
- 与Scala比较(官方已删除)
- Google开发者官网简介
- Kotlin and Android
- Get Started with Kotlin on Android
- Kotlin on Android FAQ
- Android KTX
- Resources to Learn Kotlin
- Kotlin样品
- Kotlin零基础到进阶
- 第一阶段兴趣入门
- kotlin简介和学习方法
- 数据类型和类型系统
- 入门
- 分类
- val和var
- 二进制基础
- 基础
- 基本语法
- 包
- 示例
- 编码规范
- 代码注释
- 异常
- 根类型“Any”
- Any? 可空类型
- 可空性的实现原理
- kotlin.Unit类型
- kotlin.Nothing类型
- 基本数据类型
- 数值类型
- 布尔类型
- 字符型
- 位运算符
- 变量和常量
- 语法和运算符
- 关键字
- 硬关键字
- 软关键字
- 修饰符关键字
- 特殊标识符
- 操作符和特殊符号
- 算术运算符
- 赋值运算符
- 比较运算符
- 逻辑运算符
- this关键字
- super关键字
- 操作符重载
- 一元操作符
- 二元操作符
- 字符串
- 字符串介绍和属性
- 字符串常见方法操作
- 字符串模板
- 数组
- 数组介绍创建及遍历
- 数组常见方法和属性
- 数组变化以及下标越界问题
- 原生数组类型
- 区间
- 正向区间
- 逆向区间
- 步长
- 类型检测与类型转换
- is、!is、as、as-运算符
- 空安全
- 可空类型变量
- 安全调用符
- 非空断言
- Elvis操作符
- 可空性深入
- 可空性和Java
- 函数
- 函数式编程概述
- OOP和FOP
- 函数式编程基本特性
- 组合与范畴
- 在Kotlin中使用函数式编程
- 函数入门
- 函数作用域
- 函数加强
- 命名参数
- 默认参数
- 可变参数
- 表达式函数体
- 顶层、嵌套、中缀函数
- 尾递归函数优化
- 函数重载
- 控制流
- if表达式
- when表达式
- for循环
- while循环
- 循环中的 Break 与 continue
- return返回
- 标签处返回
- 集合
- list集合
- list集合介绍和操作
- list常见方法和属性
- list集合变化和下标越界
- set集合
- set集合介绍和常见操作
- set集合常见方法和属性
- set集合变换和下标越界
- map集合
- map集合介绍和常见操作
- map集合常见方法和属性
- map集合变换
- 集合的函数式API
- map函数
- filter函数
- “ all ”“ any ”“ count ”和“ find ”:对集合应用判断式
- 别样的求和方式:sumBy、sum、fold、reduce
- 根据人的性别进行分组:groupBy
- 扁平化——处理嵌套集合:flatMap、flatten
- 惰性集合操作:序列
- 区间、数组、集合之间转换
- 面向对象
- 面向对象-封装
- 类的创建及属性方法访问
- 类属性和字段
- 构造器
- 嵌套类(内部类)
- 枚举类
- 枚举类遍历&枚举常量常用属性
- 数据类
- 密封类
- 印章类(密封类)
- 面向对象-继承
- 类的继承
- 面向对象-多态
- 抽象类
- 接口
- 接口和抽象类的区别
- 面向对象-深入
- 扩展
- 扩展:为别的类添加方法、属性
- Android中的扩展应用
- 优化Snackbar
- 用扩展函数封装Utils
- 解决烦人的findViewById
- 扩展不是万能的
- 调度方式对扩展函数的影响
- 被滥用的扩展函数
- 委托
- 委托类
- 委托属性
- Kotlin5大内置委托
- Kotlin-Object关键字
- 单例模式
- 匿名类对象
- 伴生对象
- 作用域函数
- let函数
- run函数
- with函数
- apply函数
- also函数
- 标准库函数
- takeIf 与 takeUnless
- 第二阶段重点深入
- Lambda编程
- Lambda成员引用高阶函数
- 高阶函数
- 内联函数
- 泛型
- 泛型的分类
- 泛型约束
- 子类和子类型
- 协变与逆变
- 泛型擦除与实化类型
- 泛型类型参数
- 泛型的背后:类型擦除
- Java为什么无法声明一个泛型数组
- 向后兼容的罪
- 类型擦除的矛盾
- 使用内联函数获取泛型
- 打破泛型不变
- 一个支持协变的List
- 一个支持逆变的Comparator
- 协变和逆变
- 第三阶段难点突破
- 注解和反射
- 声明并应用注解
- DSL
- 协程
- 协程简介
- 协程的基本操作
- 协程取消
- 管道
- 慕课霍丙乾协程笔记
- Kotlin与Java互操作
- 在Kotlin中调用Java
- 在Java中调用Kotlin
- Kotlin与Java中的操作对比
- 第四阶段专题练习
- 朱凯Kotlin知识点总结
- Kotlin 基础
- Kotlin 的变量、函数和类型
- Kotlin 里那些「不是那么写的」
- Kotlin 里那些「更方便的」
- Kotlin 进阶
- Kotlin 的泛型
- Kotlin 的高阶函数、匿名函数和 Lambda 表达式
- Kotlin协程
- 初识
- 进阶
- 深入
- Kotlin 扩展
- 会写「18.dp」只是个入门——Kotlin 的扩展函数和扩展属性(Extension Functions / Properties)
- Kotlin实战-开发Android