most from reference
一些常用操作
创建单例类 object 数据类data class
List、Map、Array的简单操作
Lazy延迟加载属性
空类型?
空类型表达式?.、?:、?.let{}
try catch finally语句块
无参函数表示一个值
条件判断语句 if else 及 when else
with语句块
IO流操作并使用lambda表达式
函数声明时直接内联一个其它方法，相当于其方法实现 inline
类Java的void类型：Unit
package com.jackie.basic
import java.io.File
import java.nio.file.Files
import java.nio.file.Paths
/**
* Created by Jackie on 2017/7/28.
* Idioms
* A collection of random and frequently used idioms in Kotlin.
* If you have a favorite idiom, contribute it by sending a pull request.
*/
class Idioms {
}
/**
*Create DTOs(POJOs/POCOs)
* Provides a Customer class with the following functionality:
* getters (and setters in case of vars) for all properties
* equals()
* hashCode()
* toString()
* copy()
* component1(), component2(), …, for all properties (see Data classes)
*/
data class Customer(val name: String, val email: String) //数据类的属性必须用val(不可变)或者var(可变)来修饰 属性无法修改
data class User(var name: String = "", val email: String = "") //为属性添加默认值 之后创建对象时，就可以不输或少输构造方法参数
//Creating a singleton
object Resource {
val name = "Name"
}
fun main(args: Array<String>) {
var customer = Customer("Jackie", "717702148@qq.com")
// customer.name = "Jack" //var couldn't be modified
var list1 = listOf(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
//Filtering a list
var positives = list1.filter { x -> x > 0 }
//Or alternatively, even shorter:
// val positives = list1.filter { it > 0 }
println(positives)
//Traversing a map/list of pairs
var map1 = HashMap<Int, String>()
map1[0] = "Good"; map1[1] = "Good"; map1[2] = "Study"
map1[3] = "Day"; map1[4] = "Day"; map1[5] = "Up"
for ((key, value) in map1) {
println("$key -> $value")
}
//key, value can be called anything.
//Using ranges
for (i in 1..100) {
} // closed range: includes 100
for (i in 1 until 100) {
} // half-open range: does not include 100
for (x in 2..10 step 2) {
}
// for (x in 10 downTo 1) {
// if (x in 5..8) {
//// print(x + " ") //x是Int 编译报错 同 var result = 5 + " "
//// print(" " + x) //编译通过
// print(x.toString() + " ")
// }
// }
//上面的简写
(10 downTo 1)
.filter { it in 5..8 } //it是固定命名，表示Int
.forEach { print(it.toString() + " ") }
println()
//Read-only list
val list2 = listOf("a", "b", "c")
for (list in list2) {
println(list)
}
//按index打印
for ((i, e) in list2.withIndex()) {
println("$i $e")
}
//Read-only map
val map2 = mapOf(0 to "Good", 1 to "Good", 2 to "Study", 3 to "Day", 4 to "Day", 5 to "Up")
//Accessing a map
println(map2[0])
for (key in map2.values) {
print(key + " ")
}
println()
//Lazy property
fun lazy() {
val p: String by lazy {
println("in this")
var a = "aa" //do something
"aaa" //最后必须给lazy属性赋值 之前可做些其它事
}
println("lazy value p = $p")
}
lazy()
//Extension Functions
fun String.convertToUpperCase(): String { //为String 添加扩展函数，把字符串转为大写字母
return this.toUpperCase() //任何字符串都可以调用这个扩展函数，this指接收者对象(Receiver Object)(也就是调用扩展函数时, 在"."号之前指定的对象实例).
}
print("Convert this to uppercase".convertToUpperCase())
// fun Activity.toast(message: CharSequence, duration: Int = Toast.LENGTH_SHORT) {
//为Activity 添加扩展函数
// Toast.makeText(this, message, duration)
.show()
// }
println()
//If not null shorthand
val files1 = File("Test").listFiles()
println(files1?.size) //可以为null
//If not null and else shorthand
//使用Elvis操作符来给定一个在是null的情况下的替代值
val files2 = File("Test").listFiles()
println(files2?.size ?: "empty")
//Executing a statement if null
val data = mapOf("email" to null)
// val email = data["email"] ?: throw IllegalStateException("Email is missing!")
//Execute if not null
data?.let {
// execute this block if not null
println("data is not null")
}
//Map nullable value if not null
// val mapped = data?.let { transformData(it) } ?: defaultValueIfDataIsNull
fun transform1(color: String): Int {
return when (color) {
"Red" -> 0
"Green" -> 1
"Blue" -> 2
else -> throw IllegalArgumentException("Invalid color param value")
}
}
//'try/catch' expression
fun test() {
val result = try {
// count()
} catch (e: ArithmeticException) {
throw IllegalStateException(e)
}
// Working with result
}
//'if' expression
fun foo(param: Int) {
val result = if (param == 1) {
"one"
} else if (param == 2) {
"two"
} else {
"three"
}
}
//Builder-style usage of methods that return Unit
fun arrayOfMinusOnes(size: Int): IntArray {
return IntArray(size).apply { fill(10) } //生成一个size长度的int数组，每个索引都填充成10
}
print(arrayOfMinusOnes(5).filter { it > 5 }.forEach { println(it) })
//Single-expression functions
fun theAnswer1() = 42
//This is equivalent to
fun theAnswer2(): Int {
return 42
}
//This can be effectively combined with other idioms, leading to shorter code. E.g. with the when-expression:
fun transform2(color: String): Int = when (color) {
"Red" -> 0
"Green" -> 1
"Blue" -> 2
else -> throw IllegalArgumentException("Invalid color param value")
}
//Calling multiple methods on an object instance ('with')
fun withObject(obj: Idioms) {
//使用with(object) ，在block中 可直接调用 对象实例的 fun, 不需要obj.前缀
with(obj) {
foo(2)
}
}
//Java 7's try with resources
// val stream = Files.newInputStream(Paths.get("/some/file.txt"))
// stream.buffered().reader().use { reader ->
// println(reader.readText())
// }
//Convenient form for a generic function that requires the generic type information
// public final class Gson {
// ...
// public <T> T fromJson(JsonElement json, Class<T> classOfT) throws JsonSyntaxException {
// ...
// private fun <T: Any> fromJson(str: String, clazz: Class<T>) {
/*private*/ fun <T> fromJson(str: String, clazz: Class<T>): T? {
return null
}
/*
inline 内联一个方法， 前面为fun定义，且使用了泛型，后面直接 = 内联的方法
*/
// inline fun <reified T: Any> Gson.fromJson(json: JsonElement): T = this.fromJson(json, T::class.java)
//Consuming a nullable Boolean
// val b: Boolean = false
var b: Boolean? = false
if (b == true) { //Boolean?的比较，不能省略 ==
// 'b' is true
} else {
// 'b' is false or null
}
}