= arrayOf(1,2,null,3,null,5,6,null)
59 |
60 | // 传统写法
61 | for (index in arrTest) {
62 | if (index == null){
63 | continue
64 | }
65 | println("index => $index")
66 | }
67 |
68 | // let写法
69 | for (index in arrTest) {
70 | index?.let { println("index => $it") }
71 | }
72 |
73 | }
74 |
75 | /**
76 | * 测试使用符号 ?. 链式调用方法
77 | */
78 | private fun testBuilder() {
79 | val builder1 : Test.Builder? = Test.Builder().setName("Lily")?.setSex("女")?.setAge(10)
80 | val builder2 : Test.Builder? = Test.Builder().setName("Tom")?.setSex(null)?.setAge(10)
81 | println(builder1.toString())
82 | println(builder2.toString())
83 |
84 | val testStr : String? = null
85 | val result = testStr?.length?.plus(5)?.minus(10)
86 | println(result)
87 | }
88 |
89 | /**
90 | * 当函数有返回值的情况下使用可空类型，其方法的返回值类型同样要加上?符号
91 | */
92 | private fun funNullMethod() : Int? {
93 | val str : String? = "123456"
94 | return str?.let { str.length }
95 | }
96 |
97 | /**
98 | * 判断可空类型的两种方式
99 | */
100 | private fun funNullCheck() {
101 |
102 | var str : String? = "123456"
103 | str = null
104 |
105 | // 1. if...else...判断
106 |
107 | if (str == null){
108 | println("变量str为空")
109 | }else{
110 | println("str.length => $str.length")
111 | }
112 |
113 | // 2. 使用符号`?.`判断 , 可以方便的调用变量的属性、方法等
114 | println(str?.length) // 当变量str为null时，会返回空(null)
115 |
116 | }
117 |
118 | private fun funNull() {
119 |
120 | // 定义一个不可为空的变量，用var修饰的变量可以被重新赋值，用val修饰的变量则不能，但是不能赋值为null
121 | var a : Int = 12
122 | val b : Int = 13
123 |
124 | a = 20
125 | // a = null 不能复制为null
126 | // b = 20 不能被重新赋值
127 |
128 | if(a == null){
129 | // 这样的判断毫无意义，因为变量a永远不可能null
130 | }
131 |
132 | /*
133 | 定义可空类型的变量,即变量可以被赋值为null
134 | 定义格式为：修饰符 变量名 ： 类型? = 值
135 | */
136 | val nullA : Int? = null
137 | val nullB : Int? = 13
138 |
139 | if(nullA == null){
140 | println("nullA = $nullA")
141 | }
142 | }
143 |
144 | class Test{
145 |
146 | class Builder{
147 | private var name : String? = "Tom"
148 | private var age : Int? = 0
149 | private var sex : String? = "男"
150 |
151 | fun setName(name : String) : Builder?{
152 | this.name = name
153 | return this
154 | }
155 |
156 | fun setAge(age : Int) : Builder?{
157 | this.age = age
158 | return this
159 | }
160 |
161 | fun setSex(sex: String?) : Builder?{
162 | this.sex = sex
163 | return this
164 | }
165 |
166 | override fun toString(): String {
167 | return "Builder(name=$name, age=$age, sex=$sex)"
168 | }
169 | }
170 | }
171 |
172 | fun test(){
173 | funNull()
174 | funNullCheck()
175 | println(funNullMethod())
176 | testBuilder()
177 | operatorLet()
178 | operatorEvils1()
179 | operatorEvils2()
180 | operatorEvils3()
181 | }
182 | }
183 |
184 |
185 |
--------------------------------------------------------------------------------
/src/main/java/com/kotlin/leran/function/SeniorFunctionDemo.kt:
--------------------------------------------------------------------------------
1 | package com.kotlin.leran.function
2 |
3 | /**
4 | * 描述 ： 高阶函数详解
5 | * author : Jetictors
6 | * time : 2018/4/7 22:25
7 | * version : v1.0.1
8 | */
9 |
10 |
11 | class SeniorFunctionDemo{
12 |
13 | /**
14 | * 测试T.let()函数，以及查看其和T.also()和`T.apply()`函数的区别
15 | */
16 | private fun testLet() {
17 | "kotlin".let {
18 | println("原字符串：$it") // kotlin
19 | it.reversed()
20 | }.let {
21 | println("反转字符串后的值：$it") // niltok
22 | it.plus("-java")
23 | }.let {
24 | println("新的字符串：$it") // niltok-java
25 | }
26 |
27 | "kotlin".also {
28 | println("原字符串：$it") // kotlin
29 | it.reversed()
30 | }.also {
31 | println("反转字符串后的值：$it") // kotlin
32 | it.plus("-java")
33 | }.also {
34 | println("新的字符串：$it") // kotlin
35 | }
36 |
37 | "kotlin".apply {
38 | println("原字符串：$this") // kotlin
39 | this.reversed()
40 | }.apply {
41 | println("反转字符串后的值：$this") // kotlin
42 | this.plus("-java")
43 | }.apply {
44 | println("新的字符串：$this") // kotlin
45 | }
46 | }
47 |
48 | /**
49 | * 测试T.also()函数，并说明和T.apply()的区别
50 | */
51 | private fun testAlso() {
52 |
53 | "kotlin".also {
54 | println("结果：${it.plus("-java")}")
55 | }.also {
56 | println("结果：${it.plus("-php")}")
57 | }
58 |
59 | "kotlin".apply {
60 | println("结果：${this.plus("-java")}")
61 | }.apply {
62 | println("结果：${this.plus("-php")}")
63 | }
64 |
65 | }
66 |
67 | /**
68 | * 测试T.takeUnless()函数
69 | */
70 | private fun testTakeUnless() {
71 |
72 | val str = "kotlin"
73 |
74 | val result = str.takeUnless {
75 | it.startsWith("ko")
76 | }
77 |
78 | println("result = $result")
79 | }
80 |
81 | /**
82 | * 测试T.takeIf()函数
83 | */
84 | private fun testTakeIf() {
85 |
86 | val str = "kotlin"
87 |
88 | val result = str.takeIf {
89 | it.startsWith("ko")
90 | }
91 |
92 | println("result = $result")
93 | }
94 |
95 | /**
96 | * 测试repeat()高阶函数
97 | */
98 | private fun testRepeat() {
99 | repeat(5){
100 | println("我是重复的第${it + 1}次，我的索引为：$it")
101 | }
102 | }
103 |
104 | /**
105 | * 测试自定义的高阶函数
106 | */
107 | private fun testDemo() {
108 | val result1 = resultByOpt(1,2){
109 | num1, num2 -> num1 + num2
110 | }
111 |
112 | val result2 = resultByOpt(3,4){
113 | num1, num2 -> num1 - num2
114 | }
115 |
116 | val result3 = resultByOpt(5,6){
117 | num1, num2 -> num1 * num2
118 | }
119 |
120 | val result4 = resultByOpt(6,3){
121 | num1, num2 -> num1 / num2
122 | }
123 |
124 | println("result1 = $result1")
125 | println("result2 = $result2")
126 | println("result3 = $result3")
127 | println("result4 = $result4")
128 | }
129 |
130 | private fun resultByOpt(num1 : Int , num2 : Int , result : (Int ,Int) -> Int) : Int{
131 | return result(num1,num2)
132 | }
133 |
134 | private fun testLock() {
135 | val testStr = "abc"
136 | val sum = testStr.sumBy { it.toInt() }
137 | println(sum)
138 |
139 | }
140 |
141 | /**
142 | * 测试with(参数){}函数
143 | */
144 | private fun testWith() {
145 | val str = "kotlin"
146 | with(str) {
147 | println( "length = ${this.length}" )
148 | println( "first = ${first()}")
149 | println( "last = ${last()}" )
150 | }
151 |
152 | val newStr : String? = "kotlin"
153 |
154 | with(newStr){
155 | println( "length = ${this?.length}" )
156 | println( "first = ${this?.first()}")
157 | println( "last = ${this?.last()}" )
158 | }
159 |
160 | newStr?.run {
161 | println( "length = $length" )
162 | println( "first = ${first()}")
163 | println( "last = ${last()}" )
164 | }
165 | }
166 |
167 | /**
168 | * 测试T.run{}函数
169 | */
170 | private fun testRun2() {
171 | val str = "kotlin"
172 | str.run {
173 | println( "length = ${this.length}" )
174 | println( "first = ${first()}")
175 | println( "last = ${last()}" )
176 | }
177 | }
178 |
179 | /**
180 | * 测试run{}函数
181 | */
182 | private fun testRun1() {
183 | val str = "kotlin"
184 |
185 | run{
186 | val str = "java"
187 | println("str = $str")
188 | }
189 |
190 | println("str = $str")
191 |
192 | val index = 3
193 | val num = run {
194 | when(index){
195 | 0 -> "kotlin"
196 | 1 -> "java"
197 | 2 -> "php"
198 | 3 -> "javaScript"
199 | else -> "none"
200 | }
201 | }.length
202 | println("num = $num")
203 |
204 | }
205 |
206 | /**
207 | * 测试TODO函数
208 | */
209 | private fun testTODO() {
210 | TODO("测试TODO函数，是否显示抛出错误")
211 | }
212 |
213 | fun test(){
214 | testLock()
215 | testDemo()
216 | testTODO()
217 | testRun1()
218 | testRun2()
219 | testWith()
220 | testAlso()
221 | testLet()
222 | testTakeIf()
223 | testTakeUnless()
224 | testRepeat()
225 | }
226 |
227 | }
228 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 | # KotlinLearn
3 |
4 | 这是一个关于`Kotlin`教程的项目，学好`Koltin`从这里开始，当你看完这个系列的所有文章时，我相信你是绝对有收获的。
5 |
6 |
7 |
8 | 
9 |
10 |
11 |
12 | ## 写这个系列教程的初衷
13 |
14 | 本人作为一个`Android`开发者，在`Kotlin`语言正式出现在人们面前的时候，或多或少的接触到了这门语言，并
15 | 自学了一部分，当`Google`宣布`Kotlin`成为`Android`开发的标准语言时，才有打算用心的去学习这门语言，并能用于实际的开
16 | 发当中。在我学习的过程中，学的越深入越被`Kotlin`的简洁以及良好的阅读性深深的折服。但是在官方的文档中，写
17 | 的实列不是很详细，有些代码甚至看不懂其实现，基础性的东西几乎不存在。如果你没有一定的编程经验我相信你也是看不懂的。
18 |
19 | 但是请你不要放弃对这门语言的学习，我也是一点一点学习过来的，你在学习过程中遇到的坑，可能我也遇到过。我非常欢迎各位
20 | 一起学习、一起探索。让我们共同进步。
21 |
22 | 所以，我会根据自身的编程经验去写完整个`Kotlin`系列文章。整个教程由浅入深，即使你没有编程经验你也能看懂，教程中会
23 | 介绍`Koltin`的特性，以及其和`Java`的差异性。让更多的朋友爱上这门语言。
24 |
25 | ## 开撸
26 | 话不多说，让我们忘记生活的烦恼、放下沉重的枷锁、沉浸在代码的世界中，放大音乐分贝，迈开脚步开始学习`Kotlin`大法吧。
27 |
28 | ## 学习架构
29 | 我把这个教程命名为：从无到有系列，这个系列目前还没写完，故而下面的链接有一些是没有实际内容的，我会在后面持续的补齐，这里只是实现了整个教程的大纲。
30 |
31 | 整个项目根据学习的难以程度以及学习路线我分为了五个模块。我会按照的学习架构去排序。大家可以按照这个顺序去学习...
32 |
33 | #### 引言
34 | - [1、 17 位谷歌 Android 开发专家是如何看待 Kotlin 的？](https://mp.weixin.qq.com/s/mWPJiefaNpK8EuoJYvhbhg)
35 | - [2、 用 Kotlin 开发 Android 项目是一种什么样的感受？（一）](https://www.jianshu.com/p/8a1fce6fa93a)
36 | - [3、 用 Kotlin 开发 Android 项目是一种什么样的感受？（二）](https://www.jianshu.com/p/b444aea1b038)
37 |
38 | #### 初级篇
39 | > 对于入门篇的内容不多，主要是讲解了`Kotlin`中的基础语法，涵盖了`开发环境搭建`、`变量`、`常量`、`注释`、`数据类型`、`控制语句`，`操作符重载`、`空安全`、`基本函数`、`字符串处理`等
40 |
41 | - [1、 开发环境搭建](https://juejin.im/post/5a37e2dbf265da43231b1504)
42 | - [2、 变量、常量、注释](https://juejin.im/post/5a39ef7af265da4311205967)
43 | - [3、 数据类型](https://juejin.im/post/5a36020b6fb9a0451543f5c8)
44 | - [4、 逻辑控制语句](https://juejin.im/post/5a369ccaf265da4325296247)
45 | - [5.1、 一元、二元操作符](https://juejin.im/post/5a4ce9865188257d6a7ef291)
46 | - [5.2、 比较、区间、未运算操作符（未完成）](#)
47 | - [6、 可空类型、空安全、类型转换](https://juejin.im/post/5a5b06f26fb9a01cb42c5206)
48 | - [7、 基础函数使用](https://juejin.im/post/5a6377425188257329148665)
49 | - [8、 字符串的常用操作总结](https://juejin.im/post/5b0ae06df265da0db64e3d63)
50 |
51 | #### 中级篇
52 | > `Kotlin`是一门`面向对象`的开发语言。既然是面向对象，则在中级篇主要讲解其`三大特性`，以及`类成员`、`数据类`、`抽象类`、`接口类`、`内部类`、`继承类`等关于`Kotlin`面向对象的方方面面的讲解
53 |
54 | - [1、 类的声明与使用](https://juejin.im/post/5a3297de6fb9a045055e295e)
55 | - [2、 属性与字段](https://juejin.im/post/5a6378266fb9a01ca10b00e4)
56 | - [3、 可见性修饰符](https://juejin.im/post/5a3293ec51882531926ebfe6)
57 | - [4、 继承类](https://juejin.im/post/5a6303fb51882573467d0fbc)
58 | - [5、 接口类、枚举类](https://juejin.im/post/5a34c551518825552b3f9c91)
59 | - [6、 数据类、密封类](https://juejin.im/post/5a37e4b45188253aea1f7219)
60 | - [7、 抽象类、内部类、嵌套类](https://juejin.im/post/5a48a0e8518825455f2fa070)
61 | - [8、 类型别名与属性名冲突解决](https://juejin.im/post/5c8cbd45f265da2dda6997d3)
62 | - [9、 解构声明（未完成）](#)
63 | - [10、伴生对象与对象声明（未完成）](#)
64 |
65 | #### 高级篇
66 | > 高级篇的内容要多一些，只要是对`Kotlin`中的高级用法以及一些独特的东西。涵盖了`lambda表达式`、`高阶函数`、`集合`、`泛型`、`扩展`、`委托`、`异常处理`、`注解`、`反射`、`协程`等
67 |
68 | - [1、 Lambda表达式](https://juejin.im/post/5ab9a5ccf265da239f076284)
69 | - [2、 高阶函数](https://juejin.im/post/5b198c675188257d7a49b3ec)
70 | - [3、 内联函数（未完成）](#)
71 | - [4.1、 集合的使用](https://juejin.im/post/5ab7a9c4f265da2377196038)
72 | - [4.2、 集合的常用操作符总结](https://juejin.im/post/5b1f7699f265da6e155d5965)
73 | - [5、 泛型（未完成）](#)
74 | - [6、 扩展（未完成）](#)
75 | - [7、异常处理（未完成）](#)
76 | - [8、 委托（未完成）](#)
77 | - [9、 注解（未完成）](#)
78 | - [10、 反射（未完成）](#)
79 | - [11、 协程（未完成）](https://github.com/Kotlin/kotlinx.coroutines)
80 |
81 | #### 进阶篇
82 | > 进阶篇主要讲解的是在实际开发项目中的注意事项及一些高级操作,例如`Kotlin`中的`设计模式`、`编码规范`等
83 |
84 | - [1、 约定俗成的编码规范（未完成）](#)
85 | - [2、 单列模式（未完成）](#)
86 | - [3、 工厂方法模式（未完成）](#)
87 | - [4、 抽象工厂模式（未完成）](#)
88 | - [5、 建造者模式（未完成）](#)
89 | - [6、 原型模式（未完成）](#)
90 | - [7、 适配器模式（未完成）](#)
91 | - [8、 桥接模式（未完成）](#)
92 | - [9、 组合模式（未完成）](#)
93 | - [10、 装饰模式（未完成）](#)
94 | - [11、 外观模式（未完成）](#)
95 | - [12、 享元模式（未完成）](#)
96 | - [13、 代理模式（未完成）](#)
97 | - [14、 职责链模式（未完成）](#)
98 | - [15、 命令模式（未完成）](#)
99 | - [16、 解释器模式（未完成）](#)
100 | - [17、 迭代器模式（未完成）](#)
101 | - [18、 中介者模式（未完成）](#)
102 | - [19、 备忘录模式（未完成）](#)
103 | - [20、 观察者模式（未完成）](#)
104 | - [21、 状态模式（未完成）](#)
105 | - [22、 策略模式（未完成）](#)
106 | - [23、 模版方法模式（未完成）](#)
107 | - [24、 访问者模式（未完成）](#)
108 |
109 | #### 实战篇
110 | > 实战篇主要向大家介绍使用`Kotlin`开发`Android`项目时，介绍一些常用和`Kotlin`一起开发的库，以及对他们的使用及讲解。
111 | 比如说`Anko`、`Dagger2`、`RxKotlin`、或者用`Kotlin`编写的一些自定义组件等等...
112 |
113 | - [1、 使用Anko,让你告别xml布局](https://github.com/Jetictors/anko_kotlin_gank_client)
114 | - [2、 Kotlin中使用Dagger2的坑](https://github.com/Jetictors/kotlin-java-dagger2)
115 | - [3、 RxKotlin总结（未完成）](#)
116 | - [4、 使用Koltin编写一个竖行显示的TextView（未完成）](#)
117 |
118 | ## 其他
119 |
120 | 在这里我意思整合了一些关于`Kotlin`的学习资源，以供大家学习。
121 |
122 | #### 官网
123 | - [Kotlin官网文档](https://kotlinlang.org/docs/reference/)
124 | - [kotlin中文官网文档](http://www.kotlincn.net/docs/reference/)
125 | - [Kotlin在线IDE](https://try.kotlinlang.org/)
126 | - [Kotlin On Github](https://github.com/JetBrains/kotlin)
127 |
128 | #### 视频教程
129 | - [Kotlin系列视频教程](https://github.com/enbandari/Kotlin-Tutorials)
130 |
131 | #### 书籍
132 | 关于书籍的分享，这里有着官网的中英文`PDF`文档，`Kotlin`极简教程、`Kotlin`程序开发入门经验等等书籍。这些我都分享在了我的`Kotlin`交流群里面。这里就不一一的分享了。
133 |
134 | #### 更多
135 | - [Kotlin相关经验文章](https://juejin.im/tag/Kotlin?utm_source=awesome_kotlin&utm_medium=jjzl)
136 |
137 | #### 开源项目
138 | - [GankClient-Kotlin](https://github.com/githubwing/GankClient-Kotlin) —— 用`Koltin`编写的`Gank`客户端
139 | - [PoiShuhui-Kotlin](https://github.com/wuapnjie/PoiShuhui-Kotlin) —— 用`Kotlin`写的简单漫画APP
140 | - [KotlinMvp](https://github.com/git-xuhao/KotlinMvp) —— 基于`Kotlin+MVP+Retrofit+RxJava+Glide`等架构实现短视频类APP练手项目，UI简约，详细注释
141 | - [Eyepetizer-in-Kotlin](https://github.com/LRH1993/Eyepetizer-in-Kotlin) —— 用`Kotlin`撸一款`Eyepetizer`
142 |
143 | ## 最后
144 | 我相信在你学完整个系列教程之后，一定是可以用`Kotlin`进行实际项目开发的。近期我也会用`Koltin`语言去编写我自己的`Android`项目，也会用`Kotlin`去实现后端用于我`APP`中的接口提供。
145 | 如果你在学习过程中遇到任何的问题，不管你是写`后端`、`Android`以及`前端`的开发者都可以联系我，或者对于`Android`开发很有兴趣。都可以在项目`Issuse`我，或者加入在下的`Koltin`交流群一起学习、研究。
146 |
147 |
148 |
欢迎各位大佬进群共同研究、探索
149 |
150 | QQ群号：497071402
151 |
152 |
153 | 
154 |
155 |
156 |
157 |
158 |
159 |
--------------------------------------------------------------------------------
/src/main/java/com/kotlin/leran/basis/OperatorStringDemo.kt:
--------------------------------------------------------------------------------
1 | package com.kotlin.leran.basis
2 |
3 | import java.util.regex.Pattern
4 |
5 | /**
6 | * 描述 ： 字符串的常用操作
7 | * author : Jetictors
8 | * time : 2018/5/28 0:52
9 | * version : v1.0.1
10 | */
11 |
12 | class OperatorStringDemo {
13 |
14 | /**
15 | * 字符串替换
16 | */
17 | private fun replaceStr() {
18 | val str = "Kotlin is a very good programming language"
19 |
20 | // oldChar： 要替换的字符，newChar: 替换的字符
21 | println("----------- 1、replace() ------------")
22 | println(str.replace('a','A',true))
23 |
24 | println("----------- 2、replace() ------------")
25 | // oldValue: 要替换的字符串， newValue: 替换的字符串
26 | println(str.replace("Kotlin","Java"))
27 |
28 | println("----------- 3、replace() ------------")
29 | /*
30 | 利用正则表达式替换
31 | regex: 规则
32 | replacement : 替换的字符
33 |
34 | */
35 | val str2 = "1234a kotlin 5678 3 is 4"
36 | println(str2.replace(Regex("[0-9]+"),"kotlin"))
37 |
38 | println("----------- 4、replace() ------------")
39 | /*
40 | 根据定义的正则规则去匹配源字符串，把满足规则的字符串通过`transform{}`高阶函数映射的新字符串替换。
41 | regex: 规则
42 | transform : 高阶函数
43 | */
44 | val newS = str2.replace(Regex("[0-9]")) { "abcd " }
45 | println(newS)
46 |
47 | // replaceFirst
48 | println("----------- replaceFirst() ------------")
49 | println(str.replaceFirst('a','A'))
50 | println(str.replaceFirst( "Kotlin","Java"))
51 |
52 |
53 | // replaceBefore
54 | println("----------- replaceBefore() ------------")
55 | println(str.replaceBefore('a',"AA"))
56 | println(str.replaceBefore("Kotlin","Java"))
57 |
58 | // replaceBeforeLast
59 | println("----------- replaceBeforeLast() ------------")
60 | println(str.replaceBeforeLast('a',"AA"))
61 | println(str.replaceBeforeLast("Kotlin","Java"))
62 |
63 | // replaceAfter
64 | println("----------- replaceAfter() ------------")
65 | println(str.replaceAfter('a',"AA"))
66 | println(str.replaceAfter("Kotlin","Java"))
67 |
68 | // replaceAfterLast
69 | println("----------- replaceAfterLast() ------------")
70 | println(str.replaceAfterLast('a',"AA"))
71 | println(str.replaceAfterLast("Kotlin","Java"))
72 | }
73 |
74 | /**
75 | * 字符串分割
76 | */
77 | private fun spiltStr() {
78 | val str1 = "Kotlin is a very good programming language"
79 |
80 | val list1 = str1.split(' ')
81 | for (str in list1){
82 | print("$str \t")
83 | }
84 |
85 | println()
86 |
87 | val list2 = str1.split(" ")
88 | for (str in list2){
89 | print("$str \t")
90 | }
91 |
92 | println()
93 |
94 | val str2 = "1 kotlin 2 java 3 Lua 4 JavaScript"
95 | val list3 = str2.split(Regex("[0-9]+"))
96 | for (str in list3){
97 | print("$str \t")
98 | }
99 |
100 | println()
101 |
102 | val list4 = str2.split(Pattern.compile("[0-9]+"))
103 | for (str in list4){
104 | print("$str \t")
105 | }
106 |
107 | println()
108 |
109 | val str3 = "a b c d e f g h 2+3+4+5"
110 | val list5 = str3.split(' ','+')
111 | for (str in list5){
112 | print("$str \t")
113 | }
114 | }
115 |
116 | /**
117 | * 字符串截取
118 | */
119 | private fun subStr() {
120 | val str = "Kotlin is a very good programming language"
121 |
122 | println(str.substring(10))
123 | println(str.substring(0,15))
124 | println(str.substring(IntRange(0,15)))
125 |
126 | println(str.subSequence(0,15))
127 | println(str.subSequence(IntRange(0,15)))
128 | }
129 |
130 | private fun optStr() {
131 |
132 | // 字符串链接
133 | val oldStr = "kotlin"
134 | println(oldStr.plus(" very good"))
135 | println(oldStr + " very good")
136 |
137 | // 字符串反转
138 | val str = "kotlin"
139 | println("字符串反转：${str.reversed()}")
140 |
141 | // 检测字符串的起始字符与结尾字符
142 | println(str.endsWith("lin"))
143 | println(str.endsWith('n'))
144 |
145 | println(str.startsWith('k'))
146 | println(str.startsWith("kot"))
147 | println(str.startsWith("lin",3))
148 | }
149 |
150 | /**
151 | * 字符串查找
152 | */
153 | private fun findStr(){
154 |
155 | val str = "kotlin very good"
156 |
157 | println(str.first())
158 | println(str.first { it == 't' })
159 | println(str.firstOrNull())
160 | println(str.firstOrNull{it == 't'})
161 | println(str.last())
162 | println(str.last { it == 'o' })
163 | println(str.lastOrNull())
164 | println(str.lastOrNull { it == 'o' })
165 |
166 | println(str.indexOfFirst { it == 'o' })
167 | println(str.indexOfLast { it == 'o' })
168 | println(str.indexOf('o',0))
169 | println(str.indexOf("very",0))
170 | println(str.lastIndexOf('o'))
171 | println(str.lastIndexOf("good"))
172 | }
173 |
174 | /**
175 | * 统计
176 | */
177 | private fun getStrLength(){
178 |
179 | val str = "kotlin very good"
180 |
181 | // 1. 直接用length属性获取
182 | println("str.length => ${str.length}")
183 |
184 | // 2. 用count()函数获取
185 | println("str.count() => ${str.count()}")
186 |
187 | // 3. 统计重复
188 | val count = str.count { it == 'o' }
189 | println("count : $count")
190 | }
191 |
192 |
193 | /**
194 | * 检测字符串是否为空，或空字符串，以及是否包含了空格
195 | */
196 | private fun checkNullStr(){
197 |
198 | val str : String? = "kotlin"
199 |
200 | println(str?.isEmpty())
201 | println(str?.isNotEmpty())
202 | println(str.isNullOrEmpty())
203 | println(str?.isBlank())
204 | println(str?.isNotBlank())
205 | println(str.isNullOrBlank())
206 |
207 | }
208 |
209 | fun test(){
210 | checkNullStr()
211 | getStrLength()
212 | optStr()
213 | findStr()
214 | subStr()
215 | spiltStr()
216 | replaceStr()
217 | }
218 |
219 | }
--------------------------------------------------------------------------------
/src/main/java/com/kotlin/leran/basis/OperatorDemo.kt:
--------------------------------------------------------------------------------
1 | package com.kotlin.leran.basis
2 |
3 | /**
4 | * 描述 ： 操作符重载详解
5 | * author : Jetictors
6 | * time : 2018/1/3 23:21
7 | * version : v1.0.1
8 | */
9 |
10 | class OperatorDemo {
11 |
12 | fun test(){
13 | unitaryOperator()
14 | unitaryCommonOperator()
15 | binaryOperator()
16 | compareOperator()
17 | testRangTo()
18 | testIn()
19 | testIs()
20 | }
21 |
22 | /**
23 | * 类型判断
24 | */
25 | private fun testIs() {
26 | val a = 0
27 | }
28 |
29 | /**
30 | * 包含操作符 in
31 | */
32 | private fun testIn() {
33 | val str = "kotlin"
34 | val result1 = "o" in str
35 | val result2 = str.contains("o")
36 | println("$result1 \t $result2")
37 | }
38 |
39 |
40 | /**
41 | * 区间操作符
42 | */
43 | private fun testRangTo() {
44 |
45 | /*
46 | 操作符为(..)，其有两个操作数，且都是整型
47 | */
48 | val a = 1
49 | val b = 5
50 |
51 | // 操作符实现
52 | val s = 3 in a .. b // true,因为3在区间[1,5]之内
53 | println("s = $s")
54 | for (index in a .. b){
55 | print("index = $index \t")
56 | }
57 |
58 | println()
59 |
60 | // 操作符重载方式实现
61 | val t = 3 in a.rangeTo(b)
62 | println("t = $t")
63 | for (index in a.rangeTo(b)){
64 | print("index = $index \t")
65 | }
66 | println()
67 | }
68 |
69 | /**
70 | * 比较运算符
71 | */
72 | private fun compareOperator() {
73 | /*
74 | > 、< 、>= 、<=
75 | */
76 | val a = 12
77 | val b = 5
78 |
79 | // 操作符实现
80 | println("a > b = ${a > b}")
81 | println("a < b = ${a < b}")
82 | println("a >= b = ${a >= b}")
83 | println("a <= b = ${a <= b}")
84 |
85 | // 操作符重载方式实现
86 | println("a.compareTo(b) > 0 = ${a.compareTo(b) > 0}")
87 | println("a.compareTo(b) < 0 = ${a.compareTo(b) < 0}")
88 | println("a.compareTo(b) >= 0 = ${a.compareTo(b) >= 0}")
89 | println("a.compareTo(b) <= 0 = ${a.compareTo(b) <= 0}")
90 | }
91 |
92 | /**
93 | * 二元操作
94 | */
95 | private fun binaryOperator() {
96 | basicBinaryOperator()
97 | commonBinaryOperator()
98 | seniorBinaryOperator()
99 | }
100 |
101 | /**
102 | * 对一个集合使用plus()和plusAssign()
103 | */
104 | private fun seniorBinaryOperator() {
105 | var arrA = arrayListOf("1","2","3","4")
106 | var arrB = arrayListOf("1","2","3","4")
107 |
108 | arrA.plusAssign(arrB)
109 |
110 | for (a in arrA){
111 | print("$a \t")
112 | }
113 | }
114 |
115 | /**
116 | * 复合的二元操作
117 | */
118 | private fun commonBinaryOperator() {
119 | var a = 10
120 | var b = 2
121 | var c = "Kotlin"
122 |
123 | // 主要演示字符串的+=
124 | c += a
125 | print("c = $c \t" )
126 |
127 | a += b
128 | print("a = $a \t")
129 |
130 | a = 10
131 | a -= b
132 | print("a = $a \t")
133 |
134 | a = 10
135 | a *= b
136 | print("a = $a \t")
137 |
138 | a = 10
139 | a /= b
140 | print("a = $a \t")
141 |
142 | a = 10
143 | a %= b
144 | println("a = $a \t")
145 |
146 | // 操作符重载方式实现
147 | a = 10
148 | c = "Kotlin"
149 | c = c.plus(a)
150 | print("c = $c \t")
151 |
152 | a = 10
153 | a = a.plus(b)
154 | print("a = $a \t")
155 |
156 | a = 10
157 | a = a.minus(b)
158 | print("a = $a \t")
159 |
160 | a = 10
161 | a = a.times(b)
162 | print("a = $a \t")
163 |
164 | a = 10
165 | a = a.div(b)
166 | print("a = $a \t")
167 |
168 | a = 10
169 | a = a.rem(b)
170 | println("a = $a \t")
171 | }
172 |
173 | /**
174 | * 简单的二元操作
175 | */
176 | private fun basicBinaryOperator(){
177 | val a = 10
178 | val b = 2
179 | val c = "2"
180 | val d = "Kotlin"
181 |
182 | // 操作符实现
183 | println("a + d = " + a + d)
184 | println("c + d = " + c + d)
185 | println("a + b = ${a + b} \t a - b = ${a - b} \t a * b = ${a * b} \t a / b = ${a / b} \t a % b = ${a % b}")
186 |
187 | // 操作符重载实现
188 | println("a + b = ${a.plus(b)} \t a - b = ${a.minus(b)} \t a * b = ${a.times(b)} \t a / b = ${a.div(b)} \t " +
189 | "a % b = ${a.rem(b)} \t a .. d = ${a.rangeTo(b)}")
190 | // println(a.plus(d)) 错误：因为第一个操作数`a`限制了其plus()方法的参数，
191 | // println(d.plus(a)) 正确：因为plus()方法的参数为超（Any）类型
192 | }
193 |
194 | /**
195 | * 一元操作
196 | */
197 | private fun unitaryOperator() {
198 |
199 | /*
200 | 简单的一元操作:有三种一元操作
201 | 1. `+` 表示正数的意思，其操作数为数值型
202 | 2. `-` 表示负数的意思，其操作数为数值型
203 | 3. `!` 表示取反的意思，其操作数为boolean类型
204 | */
205 |
206 | var a = 1
207 | var b = -2
208 | var c = true
209 | var d = false
210 |
211 | // 操作符实现
212 | println("+a = ${+a}\t -a = ${-a}\t !c = ${!c}")
213 | println("+b = ${+b}\t -b = ${-b}\t !d = ${!d}")
214 |
215 | // 操作符重载方式实现
216 | println("+a = ${a.unaryPlus()}\t -a = ${a.unaryMinus()}\t !c = ${c.not()}")
217 | println("+b = ${b.unaryPlus()}\t -b = ${b.unaryMinus()}\t !d = ${d.not()}")
218 | }
219 |
220 | /**
221 | * 复杂的一元元操作
222 | */
223 | private fun unitaryCommonOperator() {
224 | /*
225 | 复杂的一元操作:有4种一元操作
226 | 1. `a++` ：后缀自增
227 | 2. `a--` : 后缀自减
228 | 1. `++a` ：前缀自增
229 | 2. `--a` : 前缀自减
230 | */
231 | var a = 10
232 | var b = 10
233 | var c = 10
234 | var d = 10
235 |
236 | // Java实现
237 | println("a++ = ${a++} \t b-- = ${b--} \t ++c = ${++c} \t --d = ${--d}")
238 |
239 | a = 10
240 | b = 10
241 | c = 10
242 | d = 10
243 |
244 | // 操作符重载方式实现
245 | a.also { a.inc() }
246 | b.also { b.dec() }
247 | c.inc().also { c = it }
248 | d.dec().also { d = it }
249 | println("a = $a \t b = $b \t c = $c \t d = $d")
250 |
251 | }
252 |
253 | }
254 |
255 |
--------------------------------------------------------------------------------
/src/main/java/com/kotlin/leran/other/OperaCollectionDemo.kt:
--------------------------------------------------------------------------------
1 | package com.kotlin.leran.other
2 |
3 | /**
4 | * 描述 ： 处理集合的高级函数
5 | * author : Jetictors
6 | * time : 2018/4/1 22:59
7 | * version : v1.0.1
8 | */
9 |
10 | class OperaCollectionDemo{
11 |
12 |
13 | /**
14 | * 生产操作符
15 | */
16 | private fun optProduce() {
17 | val list1 = listOf(1,2,3,4)
18 | val list2 = listOf("kotlin","Android","Java","PHP","JavaScript")
19 |
20 | // plus() 和 `+`一样
21 | println(list1.plus(list2))
22 | println(list1 + list2)
23 |
24 | // zip
25 | println(list1.zip(list2))
26 | println(list1.zip(list2){ // 组成的新集合由元素少的原集合决定
27 | it1,it2-> it1.toString().plus("-").plus(it2)
28 | })
29 |
30 | // unzip
31 | val newList = listOf(Pair(1,"Kotlin"),Pair(2,"Android"),Pair(3,"Java"),Pair(4,"PHP"))
32 | println(newList.unzip())
33 |
34 | // partition
35 | println(list2.partition { it.startsWith("Ja") })
36 | }
37 |
38 | /**
39 | * 过滤操作符
40 | */
41 | private fun optFilter() {
42 |
43 | val list1 = listOf(-1,-3,1,3,5,6,7,2,4,10,9,8)
44 | val list2 = listOf(1,3,4,5,null,6,null,10)
45 | val list3 = listOf(1,1,5,2,2,6,3,3,7,4,4,8)
46 |
47 | println(" ------ filter -------")
48 | println(list1.filter { it > 1 })
49 | println(list1.filterIndexed { index, result ->
50 | index < 5 && result > 3
51 | })
52 | println(list1.filterNot { it > 1 })
53 | println(list2.filterNotNull())
54 |
55 | println(" ------ take -------")
56 | println(list1.take(5))
57 | println(list1.takeWhile { it < 5 })
58 | println(list1.takeLast(5))
59 | println(list1.takeLastWhile { it > 5 })
60 |
61 | println(" ------ drop -------")
62 | println(list1.drop(5))
63 | println(list1.dropWhile { it < 5 })
64 | println(list1.dropLast(5))
65 | println(list1.dropLastWhile { it > 5 })
66 |
67 | println(" ------ distinct -------")
68 | println(list3.distinct())
69 | println(list3.distinctBy { it + 2 })
70 |
71 | println(" ------ slice -------")
72 | println(list1.slice(listOf(1,3,5,7)))
73 | println(list1.slice(IntRange(1,5)))
74 |
75 | }
76 |
77 | /**
78 | * 映射操作符
79 | */
80 | private fun optMapped() {
81 | val list1 = listOf("kotlin","Android","Java","PHP","JavaScript")
82 |
83 | println(list1.map { "str-".plus(it) })
84 |
85 | println(list1.mapNotNull { "str-".plus(it) })
86 |
87 | println(list1.mapIndexed { index, str ->
88 | index.toString().plus("-").plus(str)
89 | })
90 |
91 | println(list1.mapIndexedNotNull { index, str ->
92 | index.toString().plus("-").plus(str)
93 | })
94 |
95 | println( list1.flatMap { listOf(it,"new-".plus(it)) })
96 |
97 | println(list1.groupBy { if (it.startsWith("Java")) "big" else "latter" })
98 |
99 | }
100 |
101 | /**
102 | * 顺序操作符
103 | */
104 | private fun optSort() {
105 | val list1 = listOf(-1,-3,1,3,5,6,7,2,4,10,9,8)
106 |
107 | // 反序
108 | println(list1.reversed())
109 |
110 | // 升序
111 | println(list1.sorted())
112 |
113 | // 根据条件升序，即把不满足条件的放在前面，满足条件的放在后面
114 | println(list1.sortedBy { it % 2 == 0})
115 |
116 | // 降序
117 | println(list1.sortedDescending())
118 |
119 | // 根据条件降序，和`sortedBy{}`相反
120 | println(list1.sortedByDescending { it % 2 == 0 })
121 |
122 | }
123 |
124 | /**
125 | * 统计操作符
126 | */
127 | private fun optCount() {
128 | val list1 = listOf(1,2,3,4,5)
129 |
130 | println(" ------ any -------")
131 | // 判断是不是一个集合，若是，则在判断集合是否为空，若为空则返回`false`,反之返回true,若不是集合，则返回`hasNext`
132 | println(list1.any())
133 | // 判断集合中是否有大于10的元素。若存在则返回true,反之返回false
134 | println(list1.any{it > 10})
135 |
136 | println(" ------ all -------")
137 | // 判断集合中是否所有的元素都大于2。若满足条件则返回true,反之返回false
138 | println(list1.all { it > 2 })
139 |
140 | println(" ------ none -------")
141 | // 判断是不是一个集合，若是，则在判断集合是否为空，若为空则返回`false`,反之返回true,若不是集合，则返回`hasNext`
142 | println(list1.none())
143 | // 判断集合中是否所有的元素都大于2。若满足条件则返回true,反之返回false
144 | println(list1.none{ it > 2})
145 |
146 | println(" ------ max -------")
147 | println(list1.max())
148 | println(list1.maxBy { it + 2 })
149 | // println(list1.maxWith(Comparator { num1, num2 -> num1 + num2 }))
150 |
151 | println(" ------ min -------")
152 | println(list1.min()) // 返回集合中最小的元素
153 | println(list1.minBy { it + 2 })
154 | // println(list1.minWith(Comparator { num1, num2 -> num1 + num2 }))
155 |
156 | println(" ------ sum -------")
157 | println(list1.sum())
158 | println(list1.sumBy { it + 2 })
159 | println(list1.sumByDouble { it.toDouble() })
160 |
161 | println(" ------ average -----")
162 | println(list1.average())
163 |
164 | println(" ------ reduce -------")
165 | println(list1.reduce { result, next -> result + next})
166 | println(list1.reduceIndexed { index, result, next ->
167 | index + result + next
168 | })
169 | println(list1.reduceRight { result, next -> result + next })
170 | println(list1.reduceRightIndexed {index, result, next ->
171 | index + result + next
172 | })
173 |
174 | println(" ------ fold -------")
175 | println(list1.fold(3){result, next -> result + next})
176 | println(list1.foldIndexed(3){index,result, next ->
177 | index + result + next
178 | })
179 | println(list1.foldRight(3){result, next -> result + next})
180 | println(list1.foldRightIndexed(3){index,result, next ->
181 | index + result + next
182 | })
183 | }
184 |
185 | /**
186 | * 测试元素操作符
187 | */
188 | private fun optValue() {
189 | val list = listOf("kotlin","Android","Java","PHP","Python","IOS")
190 |
191 | println(" ------ contains -------")
192 | println(list.contains("JS"))
193 |
194 | println(" ------ elementAt -------")
195 |
196 | println(list.elementAt(2))
197 | println(list.elementAtOrElse(10,{it}))
198 | println(list.elementAtOrNull(10))
199 |
200 | println(" ------ get -------")
201 | println(list[2])
202 | println(list.getOrElse(10,{it}))
203 | println(list.getOrNull(10))
204 |
205 | println(" ------ first -------")
206 | println(list.first())
207 | println(list.first{ it == "Android" })
208 | println(list.firstOrNull())
209 | println(list.firstOrNull { it == "Android" })
210 |
211 | println(" ------ last -------")
212 | println(list.last())
213 | println(list.last{ it == "Android" })
214 | println(list.lastOrNull())
215 | println(list.lastOrNull { it == "Android" })
216 |
217 | println(" ------ indexOf -------")
218 | println(list.indexOf("Android"))
219 | println(list.indexOfFirst { it == "Android" })
220 | println(list.indexOfLast { it == "Android" })
221 |
222 | println(" ------ single -------")
223 | val list2 = listOf("list")
224 | println(list2.single()) // 只有当集合只有一个元素时，才去用这个函数，不然都会抛出异常。
225 | println(list2.single { it == "list" }) //当集合中的元素满足条件时，才去用这个函数，不然都会抛出异常。若满足条件返回该元素
226 | println(list2.singleOrNull()) // 只有当集合只有一个元素时，才去用这个函数，不然都会返回null。
227 | println(list2.singleOrNull { it == "list" }) //当集合中的元素满足条件时，才去用这个函数，不然返回null。若满足条件返回该元素
228 |
229 | println(" ------ forEach -------")
230 | list.forEach { println(it) }
231 | list.forEachIndexed { index, it -> println("index : $index \t value = $it") }
232 |
233 | println(" ------ componentX -------")
234 | println(list.component1()) // 等价于`list[0] <=> list.get(0)`
235 | println(list.component2()) // 等价于`list[1] <=> list.get(1)`
236 | println(list.component3()) // 等价于`list[2] <=> list.get(2)`
237 | println(list.component4()) // 等价于`list[3] <=> list.get(3)`
238 | println(list.component5()) // 等价于`list[4] <=> list.get(4)`
239 | }
240 |
241 | /**
242 | * 获取列表或数组元素
243 | */
244 | private fun getElement() {
245 |
246 | val list = listOf("kotlin","Android","Java","PHP","Python","IOS")
247 | /*
248 | 1. 使用get(index)获取
249 | */
250 | val element1 = list[0]
251 |
252 | /*
253 | 2. 使用arr[index]获取
254 | */
255 | val element2 = list[0]
256 |
257 | /*
258 | 3. 使用arr.get
259 | */
260 | val element3 = list.component1()
261 |
262 | println("element1 = $element1 \t element2 = $element2 \t element3 = $element3")
263 |
264 | // val arr = listOf(1,2)
265 | // arr.component4()
266 | }
267 |
268 | /**
269 | * 数组转集合
270 | */
271 | private fun arrayToList() {
272 |
273 | val arr = arrayOf(1,3,5,7,9)
274 | val list = arr.toList()
275 | println("变量arr的类型为：${arr.javaClass}")
276 | println("变量list的类型为：${list.javaClass}")
277 | println(list[1])
278 | }
279 |
280 | /**
281 | * 集合转集合
282 | */
283 | private fun listToList(){
284 | val set = setOf(1)
285 | val list = set.toList()
286 |
287 | println("变量set的类型为：${set.javaClass}")
288 | println("变量list的类型为：${list.javaClass}")
289 | println(list[0])
290 | }
291 |
292 | /**
293 | * 集合转数组
294 | */
295 | private fun listToArray(){
296 | val list = listOf(1,2,3,4,5,6)
297 |
298 | val listArray = list.toIntArray()
299 |
300 | println("变量list的类型为：${list.javaClass}")
301 | println("变量listArray的类型为：${listArray.javaClass}")
302 | println(listArray[1])
303 | }
304 |
305 | fun test(){
306 | listToArray()
307 | arrayToList()
308 | listToList()
309 | getElement()
310 | optValue()
311 | optCount()
312 | optSort()
313 | optMapped()
314 | optFilter()
315 | optProduce()
316 | }
317 |
318 | }
319 |
320 |
--------------------------------------------------------------------------------
/src/main/java/com/kotlin/leran/basis/ControlStatementDemo.kt:
--------------------------------------------------------------------------------
1 | package com.kotlin.leran.basis
2 |
3 | /**
4 | * 描述 ： Kotlin语法之控制语句
5 | * author : Jetictors
6 | * time : 2017/9/23 11:35
7 | * version ：1.0.1
8 | */
9 | class ControlStatementDemo{
10 |
11 | /**
12 | * 流程控制之if语句
13 | */
14 | private fun ifExample(){
15 |
16 | /* 1. 传统写法 类似Java */
17 | var numA = 2
18 | if (numA == 2){
19 | println("numA == $numA => true")
20 | }else{
21 | println("numA == $numA => false")
22 | }
23 |
24 | /*
25 | 2. Kotlin之中的三元运算符
26 | 在Kotlin中其实是不存在三元运算符( condition ? then : else )这种操作的。
27 | 那是因为if语句的特性(if表达式会返回一个值)故而不需要三元运算符。
28 | */
29 |
30 | // 在Java中可以这么写，但是Kotlin中直接会报错。
31 | // var numB: Int = (numA > 2) ? 3 : 5
32 |
33 | // kotlin中直接用if..else替代。例：
34 | val numB: Int = if ( numA > 2 ) 3 else 5 // 当numA大于2时输出numB的值为5，反之为3
35 | println("numB = > $numB")
36 |
37 | /*
38 | 3. kotlin中if不仅可以作为表达式，也可以作为一个块结构，并且最后一句表达式为块的值
39 | */
40 | val numC: Int = if (numA > 2){
41 | numA++
42 | numA = 10
43 | println("numA > 2 => true")
44 | numA
45 | }else if (numA == 2){
46 | numA++
47 | numA = 20
48 | println("numA == 2 => true")
49 | numA
50 | }else{
51 | numA++
52 | numA = 30
53 | println("numA < 2 => true")
54 | numA
55 | }
56 |
57 | /*
58 | 根据上面的代码可以看出，每一个if分支里面都是一个代码块，并且返回了一个值。根据条件numC的值应该为20
59 | */
60 | println("numC => $numC")
61 |
62 | }
63 |
64 | /**
65 | * 流程控制之for语句
66 | */
67 | private fun forExample(){
68 |
69 | /*
70 | 1. kotlin废除了Java中的for(初始值;条件；增减步长)这个规则。
71 | 但是kotlin中对于for循环语句新增了其他的规则，来满足刚提到的规则。
72 | */
73 |
74 | /*
75 | 递增，并且步长为 1 循环5次
76 | 关键字：until
77 | 范围：until[n,m)
78 | */
79 | for (i in 0 until 5){
80 | print("i => $i \t")
81 | }
82 | println()
83 |
84 | /*
85 | 递减，并且步长为 1 循环5次
86 | 关键字：downTo
87 | 范围：downTo[n,m]
88 | */
89 | for (i in 15 downTo 11){
90 | print("i => $i \t")
91 | }
92 | println()
93 |
94 | /*
95 | for循环默认是递增，下面看另一种方式
96 | 即：for( i in n .. m),范围为[n,m]
97 | */
98 | print("使用 符号`..`的打印结果\n")
99 | for (i in 20 .. 25){
100 | print("i => $i \t")
101 | }
102 |
103 | println()
104 |
105 | print("使用until的打印结果\n")
106 | for (i in 20 until 25){
107 | print("i => $i \t")
108 | }
109 |
110 | println()
111 |
112 | /*
113 | 设置步长
114 | 关键字:step
115 | */
116 | for (i in 10 until 16 step 2){
117 | print("i => $i \t")
118 | }
119 | println()
120 |
121 | /*
122 | 2. 迭代
123 | for循环提供迭代器用来遍历任何东西
124 | for循环数组被编译为一个基于索引的循环，它不会创建一个迭代器对象
125 | */
126 | // 1. 遍历字符串 => 这点在数据类型中的字符串类型中讲过
127 | for (i in "abcdefg"){
128 | print("i => $i \t")
129 | }
130 | println()
131 |
132 |
133 | // 2. 遍历数组 => 这点在数据类型章节中的数组类型中讲过
134 | val arrayListOne = arrayOf(10,20,30,40,50)
135 | for (i in arrayListOne){
136 | print("i => $i \t")
137 | }
138 | println()
139 |
140 | /*
141 | 要遍历具有索引的数组或列表请使用下面两种方式
142 | */
143 | //3.使用数组的indices属性遍历。
144 | val arrayListTwo = arrayOf(1,3,5,7,9)
145 | for (i in arrayListTwo.indices){
146 | println("arrayListTwo[$i] => " + arrayListTwo[i])
147 | }
148 |
149 | // 4. 使用数组的withIndex()方法遍历
150 | for ((index,value) in arrayListTwo.withIndex()){
151 | println("index => $index \t value => $value")
152 | }
153 |
154 | /*
155 | 5. for迭代提供迭代器的任何内容
156 | 即：数组或列表有一个成员或扩展函数iterator()实现了Iterator接口，且该接口提供了next()与hasNext()两个成员或扩展函数
157 | 其一般和while循环一起使用
158 | */
159 | val arrayListThree = arrayOf(2,'a',3,false,9)
160 | val iterator: Iterator = arrayListThree.iterator()
161 |
162 | while (iterator.hasNext()){
163 | println(iterator.next())
164 | }
165 | }
166 |
167 | /**
168 | * 流程控制之when语句
169 | */
170 | private fun whenExample(){
171 | /*
172 | 在Kotlin中已经废除掉了Java中的switch语句。而新增了when(exp){}语句。
173 | when语句不仅可以替代掉switch语句，而且比switch语句更加强大
174 | */
175 |
176 | // 1. when语句实现switch语句功能
177 | when(5){
178 | 1 -> {
179 | println("1")
180 | }
181 | 2 -> println("2")
182 | 3 -> println("3")
183 | 5 -> {
184 | println("5")
185 | }
186 | else -> {
187 | println("0")
188 | }
189 | }
190 |
191 | // 2. 和逗号结合使用，相当于switch语句中的不使用break跳转语句
192 | when(1){
193 | 1 , 2 , 3 -> {
194 | println("1")
195 | }
196 | 5 -> {
197 | println("5")
198 | }
199 | else -> {
200 | println("0")
201 | }
202 | }
203 |
204 | /*
205 | 3. 条件可以使用任意表达式，不仅局限于常量
206 | */
207 | val num:Int = 5
208 | when(num > 5){
209 | true -> {
210 | println("num > 5")
211 | }
212 | false ->{
213 | println("num < 5")
214 | }
215 | else -> {
216 | println("num = 5")
217 | }
218 | }
219 |
220 | /*
221 | 4. 检查值是否存在于集合或数组中.
222 | 使用操作符：
223 | 在（in）
224 | 不在（!in）
225 | 限定:只适用于数值类型
226 | */
227 | val arrayList = arrayOf(1,2,3,4,5)
228 | when(1){
229 | in arrayList.toIntArray() -> {
230 | println("元素`1`存在于 arrayList数组中")
231 | }
232 | in 0 .. 10 -> println("1 属于于 0~10 中")
233 | !in 5 .. 10 -> println("1 不属于 5~10 中")
234 | else -> {
235 | println("都错了 哈哈！")
236 | }
237 | }
238 |
239 | /*
240 | 5. 检查值是否为指定类型的值
241 | 值得注意的是，kotlin智能转换可以访问类型的方法和属性
242 | 使用操作符：
243 | 是（is）
244 | 不是（!is）
245 | */
246 | when("abc"){
247 | is String -> println("abc是一个字符串")
248 | else -> {
249 | println("abc不是一个字符串")
250 | }
251 | }
252 |
253 | var a: Int = 2
254 | when(a){
255 | !is Int -> {
256 | println("$a 不是一个Int类型的值")
257 | }
258 | else -> {
259 | a = a.shl(2)
260 | println("a => $a")
261 | }
262 | }
263 |
264 | /*
265 | 6. 不使用表达式的when语句
266 | 则表示为最简单的布尔表达式
267 | */
268 | val array = arrayOfNulls(3)
269 | when{
270 | true -> {
271 | for (i in array){
272 | print(" $i \t")
273 | }
274 | println()
275 | }
276 | else -> {
277 |
278 | }
279 | }
280 |
281 | }
282 |
283 | /**
284 | * 流程控制之while语句
285 | */
286 | private fun whileExample(){
287 | /*
288 | Kotlin中的while循环同Java中的一样，其定义格式为：
289 | while(exp){ 其中exp为表达式
290 | ...
291 | }
292 | */
293 |
294 | var num = 5
295 | var count = 1
296 | while (num < 10){
297 | println("num => $num")
298 | println("循环了$count 次")
299 | count++
300 | num++
301 | }
302 |
303 | }
304 |
305 | /**
306 | * 流程控制之do..while语句
307 | */
308 | private fun doWhileExample(){
309 |
310 | /*
311 | Kotlin中的while循环同Java中的一样，其定义格式为：
312 | do{...}while(exp)
313 | */
314 | var num = 5
315 | var count = 1
316 | do {
317 | println("num => $num")
318 | println("循环了$count 次")
319 | count++
320 | num++
321 | }while (num < 10)
322 |
323 | // do{...}while(exp)与while(exp){...}最大的区别是do{...}while(exp)最少执行一次
324 |
325 | num = 5
326 | count = 1
327 | do {
328 | println("num => $num")
329 | println("循环了$count 次")
330 | count++
331 | num++
332 | }while (num < 5)
333 | }
334 |
335 | /**
336 | * 流程控制之控制语句
337 | * 1. return
338 | * 2. break
339 | * 3. continue
340 | */
341 | private fun controlExample(){
342 | /*
343 | 1. return语句,同Java中的return语句一样
344 | 默认情况下，从最近的封闭函数或匿名函数返回。
345 | */
346 | returnExample()
347 |
348 | /*
349 | 2. break语句，同Java中的break语句一样
350 | 终止最近的闭合循环。
351 | */
352 | breakExample()
353 |
354 | /*
355 | 3. continue语句,同Java中的continue语句一样
356 | 前进到最近的封闭循环的下一个步骤(迭代)。
357 | */
358 | continueExample()
359 | }
360 |
361 | private fun continueExample() {
362 | for (i in 1 until 10){
363 | if (i == 5){
364 | println("我跳过了第$i 次循环")
365 | continue
366 | }
367 | println("i => $i")
368 | }
369 | }
370 |
371 | private fun breakExample() {
372 | var count: Int = 1
373 | for (i in 1 until 10){
374 | if (i == 5){
375 | println("我在第$i 次退出了循环")
376 | break
377 | }
378 | count++
379 | }
380 | println("我循环了多少次：count => $count")
381 | }
382 |
383 | private fun returnExample(){
384 | val str: String = ""
385 | if (str.isBlank()){
386 | println("我退出了该方法")
387 | return
388 | }
389 | }
390 |
391 | fun test() {
392 | ifExample()
393 | forExample()
394 | whileExample()
395 | doWhileExample()
396 | whenExample()
397 | controlExample()
398 | }
399 |
400 | }
401 |
--------------------------------------------------------------------------------
/src/main/java/com/kotlin/leran/basis/DataTypeDemo.kt:
--------------------------------------------------------------------------------
1 | package com.kotlin.leran.basis
2 |
3 | /**
4 | * 描述 ： Kotlin语法之数据类型详解
5 | * author : Jetictors
6 | * time : 2017/9/2 22:01
7 | * version : 1.0.1
8 | */
9 |
10 | class DataTypeDemo{
11 |
12 | /**
13 | * 数字类型
14 | * 1. Byte : 8位
15 | * 2. Short : 16位
16 | * 3. Int : 32位
17 | * 4. Long : 64位
18 | * 5. Float : 32位
19 | * 6. Double : 64位
20 | */
21 | private fun numberType(){
22 | val a: Byte = 2
23 | val b: Short = 2
24 | val c: Int = 2
25 | val d: Long = 2L //长整型由大写字母L标记
26 | val e: Float = 2.0f //单精度浮点型由小写字母f或大写字符F标记
27 | val f: Double = 2.0
28 | val g = 0x0F //十六进制数
29 | val h = 0b00001011 //二进制数
30 | val k = 123 //十进制数
31 | //ps: kotlin是不支持八进制数的
32 |
33 | println(" a => $a \n b => $b \n c => $c \n d => $d \n e => $e \n f => $f \n g => $g \n h => $h \n k => $k" +
34 | " \n 切记：kotlin是不支持八进制数")
35 |
36 | /*
37 | 数字类型字面常量的下划线
38 | 作用：分割数字进行分组
39 | */
40 | val oneMillion = 1_000_000
41 | val creditCardNumber = 1234_5678_9012_3456L
42 | val socialSecurityNumber = 999_99_9999L
43 | val hexBytes = 0xFF_EC_DE_5E
44 | val bytes = 0b11010010_01101001_10010100_10010010
45 |
46 | println("oneMillion => $oneMillion")
47 | println("creditCardNumber => $creditCardNumber")
48 | println("socialSecurityNumber => $socialSecurityNumber")
49 | println("hexBytes => $hexBytes")
50 | println("bytes => $bytes")
51 |
52 | /*
53 | 装箱
54 | */
55 | val numValue: Int = 127
56 | //装箱的过程
57 | val numValueBox : Int? = numValue
58 | println("装箱后： numValueBox => $numValueBox")
59 |
60 | /*
61 | 比较两个数字
62 | */
63 | var result: Boolean
64 | result = numValue == numValueBox
65 | println("numValue == numValueBox => $result") // => true,其值是相等的
66 |
67 |
68 | result = numValue === numValueBox
69 | println("numValue === numValueBox => $result") // => false,其地址是不一样的
70 |
71 |
72 | /*
73 | 显示转换
74 | 较小的类型不会被隐式转换为更大的类型，故而系统提供了显示转换
75 | */
76 | val numA: Int = 97
77 | println(numA.toByte())
78 | println(numA.toShort())
79 | println(numA.toInt())
80 | println(numA.toFloat())
81 | println(numA.toDouble())
82 | println(numA.toLong())
83 | println(numA.toChar())
84 | println(numA.toString())
85 |
86 | /*
87 | 隐式转换
88 | 类型是从上下文推断出来的
89 | 而算术运算则被重载为适当的转换
90 | */
91 | // 30L + 12 -> Long + Int => Long
92 | val num = 30L + 12
93 | print(num)
94 |
95 | /*
96 | 位运算符
97 | 支持序列如下：shl、shr、ushr、and、or、xor
98 | */
99 | val operaNum: Int = 4
100 |
101 | val shlOperaNum = operaNum shl(2)
102 | val shrOperaNum = operaNum shr(2)
103 | val ushrOperaNum = operaNum ushr(2)
104 | val andOperaNum = operaNum and(2)
105 | val orOperaNum = operaNum or(2)
106 | val xorOperaNum = operaNum xor(2)
107 | val invOperaNum = operaNum.inv()
108 |
109 | println("shlOperaNum => $shlOperaNum \n " +
110 | "shrOperaNum => $shrOperaNum \n " +
111 | "ushrOperaNum => $ushrOperaNum \n " +
112 | "andOperaNum => $andOperaNum \n " +
113 | "orOperaNum => $orOperaNum \n " +
114 | "xorOperaNum => $xorOperaNum \n " +
115 | "invOperaNum => $invOperaNum")
116 |
117 | }
118 |
119 | /**
120 | * 字符型
121 | */
122 | private fun charType(){
123 | //字符由Char类型表示，它不能直接同视为数字，不过可以显示转换
124 | val char1: Char = 'a'
125 | //char1 = 1 //=> 这句代码会直接出错
126 | println("char1 => $char1")
127 |
128 | /*
129 | 字符显示转换
130 | */
131 | val val1 = char1.toByte()
132 | val val2 = char1.toInt()
133 | val val3 = char1.toString()
134 | val val4 = char1.toFloat()
135 | val val5 = char1.toShort()
136 | println("val1 => $val1 \n val2 => $val2 \n val3 => $val3 \n val4 => $val4 \n val5 => $val5")
137 |
138 | /*
139 | 当字符变量为英文字母时，大小写的转换
140 | */
141 | val charA: Char = 'a'
142 | val charB: Char = 'B'
143 | val charNum: Char = '1'
144 | var result: Char
145 |
146 | // 转换为大写
147 | result = charA.toUpperCase()
148 | println("result => $result")
149 |
150 | // 转换为小写
151 | result = charB.toLowerCase()
152 | println("result => $result")
153 |
154 | //当字符变量不为英文字母时，转换无效
155 | result = charNum.toLowerCase()
156 | println("result => $result")
157 |
158 | /*
159 | 转义字符
160 | 同Java一样，使用某些特殊的字符时，要使用转义。
161 | 需转义的字符如下：
162 | \t => 表示制表符
163 | \n => 表示换行符
164 | \b => 表示退格键（键盘上的Back建）
165 | \r => 表示键盘上的`Enter`键
166 | \\ => 表示反斜杠
167 | \' => 表示单引号
168 | \" => 表示双引号
169 | \$ => 表示美元符号，如果不转义在kotlin中就表示变量的引用了
170 | 其他的任何字符请使用Unicode转义序列语法。例：'\uFF00'
171 | */
172 | println("\n 换行符")
173 | println("\t 制表符")
174 | println(" \b 退格键")
175 | println("\r Enter键同样换行")
176 | println('\\')
177 | println('\'')
178 | println('\"')
179 | println('\$')
180 | println('\uFF01')
181 |
182 | }
183 |
184 | /**
185 | * Boolean型
186 | */
187 | private fun booleanType(){
188 | /*
189 | 定义：
190 | */
191 | val isNum: Boolean = false
192 | println("isNum => $isNum")
193 |
194 | /*
195 | 操作运算符
196 | ' || ' => 逻辑或（或者）
197 | ' && ' => 逻辑与（并且）
198 | ' ! ' => 逻辑非（取反）
199 | */
200 | val a: Boolean = false
201 | val b: Boolean = true
202 | var result: Boolean
203 |
204 | /* 逻辑或操作 */
205 | if (a || b){
206 | result = a || b
207 | println("a || b => $result")
208 | }
209 |
210 | /* 逻辑与操作 */
211 | if (a && b){
212 | result = a && b
213 | println("a && b => $result")
214 | }
215 |
216 | /* 逻辑非操作 */
217 | result = !a
218 | println("!a => $result")
219 |
220 | result = !b
221 | println("!b => $result")
222 |
223 | }
224 |
225 | /**
226 | * 数组类型
227 | */
228 | private fun arrayType(){
229 | /*
230 | kotlin中数组由Array表示，可以去看看源码实现，里面就几个方法
231 | 创建数组的3个函数
232 | */
233 |
234 | // 1. arrayOf() => 参数是一个可变参数的泛型对象
235 | val arr1 = arrayOf(1,2,3,4,5) //等价于[1,2,3,4,5]
236 | for (v in arr1){
237 | print(v)
238 | print("\t")
239 | }
240 |
241 | println()
242 |
243 | val arr2 = arrayOf("0","2","3",'a',32.3f)
244 | for (v in arr2){
245 | print(v)
246 | print("\t")
247 | }
248 |
249 | println()
250 |
251 | // 2. arrayOfNulls() =>用于创建一个指定数据类型且可以为空元素的给定元素个数的数组
252 | val arr3 = arrayOfNulls(3)
253 |
254 | //如若不予数组赋值则arr3[0]、arr3[1]、arr3[2]皆为null
255 | for(v in arr3){
256 | print(v)
257 | print("\t")
258 | }
259 |
260 | println()
261 |
262 | //为数组arr3赋值
263 | arr3[0] = 10
264 | arr3[1] = 20
265 | arr3[2] = 30
266 |
267 | for(v in arr3){
268 | print(v)
269 | print("\t")
270 | }
271 |
272 | println()
273 |
274 | /*
275 | 3. 使用一个工厂函数，它使用数组大小和返回给定其索引的每个数组元素的初始值的函数
276 | Array() => 第一个参数表示数组元素的个数，第二个参数则为使用其元素下标组成的表达式
277 | */
278 | val arr4 = Array(5) { index -> (index * 2).toString() }
279 | for (v in arr4){
280 | print(v)
281 | print("\t")
282 | }
283 |
284 | println()
285 |
286 | /*
287 | 在kotlin中数组类型与Java不同的是，kotlin中的数组是不变的，这样可以防止可能的运行时故障
288 | 类型投影：这一点在泛型章节中会详细的介绍。这里不多做累述
289 | */
290 |
291 | /*
292 | Kotlin还有专门的类来表示原始类型的数组，没有装箱开销.
293 | ByteArray
294 | ShortArray
295 | IntArray
296 | LongArray
297 | BooleanArray
298 | CharArray
299 | FloatArray
300 | DoubleArray
301 | */
302 | val intArr: IntArray = intArrayOf(1,2,3,4,5)
303 | for (number in intArr){
304 | print(number)
305 | print("\t")
306 | }
307 |
308 | println()
309 |
310 | val charArr: CharArray = charArrayOf('a','1','b','c','3','d')
311 | for (char in charArr){
312 | print(char)
313 | print("\t")
314 | }
315 |
316 | println()
317 |
318 | val longArr: LongArray = longArrayOf(12L,1254L,123L,111L)
319 | for (long in longArr){
320 | print(long)
321 | print("\t")
322 | }
323 | }
324 |
325 | /**
326 | * 字符串类型
327 | */
328 | private fun stringType(){
329 | // 1. 字符串由String类型表示。并且其是不可变的。字符串的元素可以通过索引操作的字符：s[i]来访问。可以使用for循环迭代字符串：
330 | val str: String = "kotlin"
331 | println("str => $str")
332 |
333 | //迭代
334 | for (s in str){
335 | print(s)
336 | print("\t")
337 | }
338 | print("\n")
339 |
340 | /*
341 | 2. 字符串字面量，在kotlin中有两种类型：
342 | - 包含转义字符的字符串 转义包括（'\t','\n'等）
343 | - 包含任意字符的字符串 由三重引号包括（""" .... """）
344 | */
345 | var str1: String = "hello\t\tkotlin"
346 | println(str1)
347 | str1 = "hello kotlin"
348 | println(str1)
349 |
350 | val str2 = """ fun main(args: Array){
351 | println("我是三重引号引用的字符串，我可以包含任意字符")
352 | } """
353 | println(str2)
354 |
355 | //可以使用trimMargin()函数删除前导空格 默认使用符号('|')作边距前缀，当然也可以使用其他字符。例：('>'，'<'等)
356 | val str3: String = """
357 | > I`m like Kotlin .
358 | > I`m like Java .
359 | > I`m like Android .
360 | > I`m like React-Native.
361 | """.trimMargin(">")
362 | println(str3)
363 |
364 |
365 | /*
366 | 字符串模板
367 | 使用字符串模板的符号为（'$'）.
368 | 在$符号后面加上变量名或大括号中的表达式
369 | */
370 | val text1: String = "我来了！"
371 | val text2: String = "$text1 kotlin"
372 | val text3: String = "$text2 ${text1.length} 哈哈！！！！"
373 | println(text1)
374 | println(text2)
375 | println(text3)
376 | }
377 |
378 | fun test(){
379 | numberType()
380 | booleanType()
381 | charType()
382 | arrayType()
383 | stringType()
384 | }
385 |
386 | }
--------------------------------------------------------------------------------