kotlin定义方法和调用
kotlin入门最容易教程一（最全，最详细）
Kotlin与Java的异同（一）
Kotlin学习（一）：Kotlin基础知识
一.Kotlin之基础语法
Kotlin零基础入门到精通（精选）
手把手教使用kotlin+Gradle+springboot进行后端开发，并通过docker部署到linux。
springboot+kotlin+gradle+jooq的学习笔记
如何把Kotlin代码转成java代码，如何把java代码转成kotlin代码
kotlin与java的区别
Kotlin系列之let、with、run、apply、also函数的使用
Gradle入门及SpringBoot项目构建
Kotlin细节十五：作用域函数与 this it 关键字
Kotlin系列一：基础知识快速入门
Kotlin 基础专栏
Kotlin 基础语法
Kotlin基本知识：类-继承-接口…ST
Kotlin快速入门（五）继承、接口、多态
Java过渡Kotlin05：继承和接口
kotlin继承与多态
（二十）Kotlin简单易学 基础语法-抽象类
kotlin 抽象类（Abstract）和接口（Interface）
Kotlin 中级篇（七）:抽象类（abstract）、内部类（嵌套类）
Kotlin 与 Java 相互调用
初步了解JOOQ并实现简单 - - - CRUD（一）
JOOQ用法和实例
Kotlin集合详解
Kotlin 中的集合的方法
Kotlin笔记18–集合的函数式API–map函数
class Test2 {
fun sayHi1(name: String) {
println("Hi,$name")
}
fun sayHi(name: String) = println("Hi,$name")
}
val sum1 = { a: Int, b: Int -> a + b }
fun main() {
val t = Test2()
t.sayHi("zhangsan")
Test2().sayHi1("lisi")
println(sum1(2, 3))
print(sum1.invoke(2, 3))
}
package com.inkrich.admin.api.controller.v1
import java.util.*
object test {
@JvmStatic
fun main(args: Array<String>) {
println(System.currentTimeMillis())
val arr = intArrayOf(2, 3, 4)
println("arr = ${arr}")
val list: MutableList<Int> = ArrayList<Int>()
list.add(11)
list.add(22)
println("list = ${list}")
for (i in 0..4) {
println("i = $i")
}
val list1 = arrayListOf("10", "11", "111")
val map: MutableMap<String?, String?> = HashMap<String?, String?>()
map["1"] = "zhangsan"
val i = Random().nextInt(10)
println("i = $i")
val languages = arrayListOf("java")
languages.add("kotlin")
languages.add("php")
println("languages = ${languages}")
}
}
class Test6 {
fun getScore(name: String) = when (name) {
"TOM" -> 86
"JIM" -> 77
"Jack" -> 95
"Lily" -> 100
else -> 0
}
fun checkNumber(num: Number) {
when (num) {
is Int -> println("number is Int")
is Double -> println("number is Double")
else -> println("number not support")
}
}
}
fun main() {
println(Test6().getScore("JIM"))
println(getScore("L"))
val c = Test6()
println(c.checkNumber(14))
val range = 1..5
val range1 = 0 until 6
for (i in range){
println("i = $i")
}
for (i in range1){
println("i = ${i}")
}
}
private fun doSomething(i:Int ,s:String):String{
return "resultCode";
}
fun main() {
val flag = doSomething(5, "abc")
println(flag)
}
//resultCode
class Test12 {
}
fun doSomething1(i: Int, s: String): String {
return "$s $i";
}
fun main() {
val flag = doSomething1(5, "abc")
println(flag)
}
//abc 5
class Test13 {
fun doSomething2(i: Int, s: String): String {
return "$s $i";
}
}
fun main() {
val flag = Test13().doSomething2(5, "abc")
println(flag)
}
//abc 5
private fun doSomething2(a:Int=2,s:String="null"):String{
return "$a $s";
}
fun main() {
//没有传任何参数
val result = doSomething2()
println(result)
}
//2 null
kotlin项目调用java方法
NoClassDefFoundError exception when calling Java code from Kotlin
将java文件放到java文件夹里，不要放到kotlin文件夹里！！！！
java文件
import java.util.Arrays;
//Java
public class Data {
String is;
public String getIs() {
return is;
}
public void setIs(String is) {
this.is = is;
}
public void in() {
System.out.println("call java method in");
}
public void multiParams(int... params) {
System.out.println(Arrays.toString(params));
}
}
kotlin文件
// kotlin
fun main() {
// 1. java 中的方法或变量 是kotlin 的关键字时，使用反引号 `` 对关键字进行转义
val demo = Data()
// 调用 java 的 is 属性，is 是 kotlin 的关键字，使用反引号转义
demo.`is` = "call java field"
println(demo.`is`) // call java field
// 调用 java 的 in 方法，in 是 kotlin 的关键字，使用反引号转义
demo.`in`() // call java method in
}
调用
kotlin的map函数对集合中所有的元素进行统一的操作
这里说的 map 函数和集合 Map 是两回事，不要混淆！
集合的函数式 API ，常用的就是 map 函数，这里罗列一些功能。
import java.util.*
fun main() {
val list = listOf("Apple", "Banana", "Cherry", "Durian", "Orange", "Pear", "Watermelon")
val newList1 = list.map { it.toUpperCase() }
val newList2 = list.map { it.toUpperCase(Locale.ROOT) }
println("list = ${list}")
println("newList1 = ${newList1}")
println("newList2 = ${newList2}")
val numbers1 = listOf(1, -2, 3, -4, 5, -6)
numbers1.forEach { print("$it ") }
//输出 ：1 -2 3 -4 5 -6
println("")
val doubled = numbers1.map { x -> x * 2 }
doubled.forEach { print("$it ") }
//输出 ：2 -4 6 -8 10 -12
println("")
val tripled = numbers1.map { it * 3 }
tripled.forEach { print("$it ") }
//输出 3 -6 9 -12 15 -18
val numbers = listOf(1, -2, 3, -4, 5, -6)
numbers.forEach{ print("$it ")}
//输出 ：1 -2 3 -4 5 -6
println("")
val positives = numbers.filter { x -> x > 0 }
positives.forEach{ print("$it ")}
//输出 ：1 3 5
println("")
val negatives = numbers.filter { it < 0 }
negatives.forEach{ print("$it ")}
//输出 ：-2 -4 -6
}
kotlin函数类型，lambda表达式
这个和C语言的函数指针是非常像似的，但java是移除了这些特性的。
我们看下面的代码，第一次看这个代码可能非常的奇怪，看着像lambda表达式，又不完全是，其实这里的关键就是理解()->String的含义。这个语法是lambda表达式，但这里的真正含义是匿名内部类类型，并且这个匿名内部类返回String类型。顺理成章的，我们定义的变量result的类型也就变成了String类型。注意是一个类型声明，而不是lambda表达式实体，lambda表达式的实体是{}里面的内容。
var result:()->String={
val animal="dog"
"This is $animal"
}
看下和lambda表达式的对比：
下面是java的lambda表达式.一个非常明显的区别就是kotlin的匿名内部类没有return，而且在里面也是不可以写return的，这是因为他默认返回类型是表达式的最后一行。为了实现这个功能，就必须显示的声明类型，因为可能返回一个类对象。
()->{
val animal="dog"
return "This is $animal"
}
当然也是可以带参数的。在()里面声明参数类型，在{}开头可以写具体名字。写法还是非常飘逸的。
val result2:(String,Int)->String={
name,age->
val animal="dog"
"This is $animal , name is $name , age is $age"
}
println(result2("tom",5))
还有一种类型推断的写法，如下，参数我们还是要指定类型的，但返回值可以推断出来。感觉这种写法更简洁一点，前面的写法更标准一些。
val result4 = { name: String, age: Int ->
val animal = "dog"
"This is $animal , name is $name , age is $age"
}
var result1:()->String={
val animal="dog"
"This is $animal"
}
val result2: (String, Int) -> String = { name, age ->
val animal = "dog"
"This is $animal , name is $name , age is $age"
}
val result4 = { name: String, age: Int ->
val animal = "dog"
"This is $animal , name is $name , age is $age"
}
fun main() {
println(result1())
println(result2("tom", 5))
println(result4("jack", 6))
}
//This is dog
//This is dog , name is tom , age is 5
//This is dog , name is jack , age is 6
it关键字
接着上小节，如果参数只有一个的时候，我们可以不写具体的参数名字，kotlin默认为我们提供了一个it关键字，可以直接使用这个关键字当参数变量名称。
val result3:(String)->String={
val animal="dog"
"This is a $animal , name is $it."
}
println(result3("tom"))
//This is a dog , name is tom.
函数做为函数参数
下面这个函数的功能是显示学生信息，包括学生的姓名和身份证，第二个参数是一个函数类型，没错可以将一个函数做为参数传进来。这个函数可以合成学生的身份证，身份证由邮政编码，生日，编号构成。
private fun showStudentInfo(name: String, getId: (Int, Int, Int) -> String): String {
//必须用大括号
return "$name's id is ${getId(300027, 20001212, 1001)}"
}
fun main() {
var getId = { code: Int, birth: Int, num: Int ->
"$code$birth$num"
}
println(showStudentInfo("Tom", getId))
//Tom's id is 300027200012121001
}
其实这个写法非常的奇怪。声明一个函数然后又去调用，那干嘛不直接写一个函数呢？其实，上面的写法是不合理的，一般不会这么写，问题就出在var getId这个变量上，我们写了这个变量来引用函数类型，这是没有必要的，因为我们用函数类型的目的就是为了写匿名函数，取名字完全是多此一举。可以简化写成下面的样子。
println(showStudentInfo("Tom", { code, birth, num ->
"$code$birth$num"
}))
这样看起来就是非常简洁了。而且，kotlin有规定，如果只有一个函数类型，或者函数类型是最后一个，（）可以省略。
函数类型是最后一个的情况：
println(showStudentInfo("Tom") { code, birth, num ->
"$code$birth$num"
})
只有一个函数类型做参数的时候
println(showStudentInfo { code, birth, num ->
"$code$birth$num"
})
总结
private fun showStudentInfo(name: String, getId: (Int, Int, Int) -> String): String {
//必须用大括号
return "$name's id is ${getId(300027, 20001212, 1001)}"
}
private fun showStudentInfo1( getId: (Int, Int, Int) -> String): String {
//必须用大括号
return "Jack's id is ${getId(300027, 20001212, 1001)}"
}
fun main() {
println(showStudentInfo("Tom", { code, birth, num ->
"$code$birth$num"
}))
//Tom's id is 300027200012121001
println(showStudentInfo("Tom") { code, birth, num ->
"$code$birth$num"
})
println(showStudentInfo1 { code, birth, num ->
"$code$birth$num"
})
}
Tom's id is 300027200012121001
Tom's id is 300027200012121001
Jack's id is 300027200012121001
这种写法一定要掌握，因为这个写法在kotlin里面是非常常见的。
这种写法一定要掌握，因为这个写法在kotlin里面是非常常见的。
这种写法一定要掌握，因为这个写法在kotlin里面是非常常见的。
内联函数
内联函数的主要用途就是为匿名函数提高性能。在调用下面的有函数类型做为参数的方法时，会使用到匿名内部类。第二个参数要求我们传入匿名内部类，对于编译器来说，匿名内部类的创建和普通类是一样的，但既然是匿名的，效率应该要更高写，如果也是和普通类一样创建，效率就比较低了。内联函数就是为了解决这个性能问题，那么是怎么解决的呢？答案是通过宏替换，如果你学过C语言，你就知道C语言的宏替换，内联函数也是一样的，通过宏替换，我们直接把匿名内部类的代码直接复制到调用的函数里面，这样就不需要创建类了，不需要创建类当然性能就提高了。
使用方法就是直接添加一个inline关键字就可以了。
private inline fun showStudentInfo(name: String, getId: (Int,Int,Int) -> String): String {
return xxx
}
函数引用
在调用含有函数类型的方法时，不光可以传入匿名内部类，也可以传通常的方法，这时候就需要用到函数引用。
例如下面的代码，foo方法的参数列表和showStudentInfo里面的getId函数类型的参数列表是一样的，这个时候可以把foo直接传给showStudentInfo。使用方法就是在::加普通函数名称。
private fun showStudentInfo(name: String, getId: (Int, Int, Int) -> String): String {
//必须用大括号
return "$name's id is ${getId(300027, 20001212, 1001)}"
}
private fun foo(a: Int, b: Int, c: Int): String {
return "$a$b$c"
}
fun main() {
println(showStudentInfo("Tom", ::foo))
}
id is 300027200012121001
函数类型做为返回类型
简单来说，就是一个函数返回另一个函数。什么？这有什么意义？如果有多个函数进行嵌套调用，那么就会形成函数之间的层层包含关系。这样的好处就是子函数可以共享父函数的变量，这种写法在脚本语言中是非常常见的，例如JavaScript。这样做的原因是脚本语言存在一个很大的问题，就是即使在不同的文件里面定义相同的变量名也会报错。因为脚本语言并没有像java这样有package和class的概念。kotlin也可以做为脚本语言。我们只能举个简单的例子来说明一下她的形式，理解的比较深还是需要大量的实践的。
看下面的代码，返回值是一个函数类型，传入一个String返回String。
private fun foo(a:Int):(String)->String{
return {
"$it"
}
}
在main函数中执行，返回函数类型的变量bar,可以调用，传入"abc"返回"abc"
var bar = foo(1)
println(bar.invoke("abc"))
输出：
abc
集合
【Kotlin備忘録】コレクション関数 map, filter + おまけ
[Kotlin]Map / MutableMapの特徴と使い方
fun main() {
var files1 = mutableListOf<String?>()
var files2: List<String>? = null
println("files1 = ${files1}")//files1 = []
println("files2 = ${files2}")//files2 = null
}
例子1
fun main() {
val fruits = listOf("Strawberry", "Grape", "Orange")
// fruits の各要素に文字列を追加したListを作成
val greatFruits = fruits.map {
"Great $it!" // <- 各要素は"it"として取得できる
}
println(fruits)
println(greatFruits)
}
结果1
[Strawberry, Grape, Orange]
[Great Strawberry!, Great Grape!, Great Orange!]
例子2
fun main() {
val pricesByFruit = mapOf("Strawberry" to 4.5, "Grape" to 5.1, "Orange" to 3.0)
// 既存のMapのキーと値を入れ替えたMapを作成する
val fruitByPrice = pricesByFruit.map {
// pricesByFruitの各要素の値を利用したPairを作成し、Listの1要素として取得
it.value to it.key
}.toMap() // <- そのままだとListが戻り値になるため、toMap()でMapに変更する
println(pricesByFruit)
println(fruitByPrice)
}
结果2
{Strawberry=4.5, Grape=5.1, Orange=3.0}
{4.5=Strawberry, 5.1=Grape, 3.0=Orange}
Filter
コレクションの各要素について、結果に合致するListを取得します。
fun main() {
val fruits = listOf("Strawberry", "Grape", "Orange")
val gFruits = fruits.filter {
// 要素をすべて小文字にし、大文字小文字関係なく"g"が入っているかをチェック
it.toLowerCase().contains("g") // <- 各要素は"it"として取得できる
}
println(fruits)
println(gFruits)
}
[Strawberry, Grape, Orange]
[Grape, Orange]