WongKyunban
WongKyunban

Java与Kotlin在语法上的差异

1、源文件后缀名

Java：.java
Kotlin:.kt

2、继承

Java：
父类：class Base{}
子类：class SubClass extends Base
Kotlin：
父类：open class Base(b:Int)
子类：class SubClass(b:Int) : Base(b)
注：Kotlin的父类必须是open的，否则它默认是final的。final的类不能被继承。

3、变量

Java：

 <PropertyType> <propertyName>[= <property_initializer>];

int param1 = 100;
int param2

Kotlin：

var <propertyName>[: <PropertyType>] [= <property_initializer>]
      [<getter>]
      [<setter>]

**Kotlin:**
var param1 : Int = 100
var param2
var param2 : Int
var param2 : Int
var 我 : Int = 9999

变量默认有set和get两个参数,它们表示设置和获取。即：

var param1
set
get

同时它们还有set(value)和get()和get(value)。可以根据需要实现它们：

var param1 = 5
    set//默认
    get//默认

var param2 = 7
    set(value){
        field = value*2
    }
    get() = field + 4

var param3 = 7
    set(value){
        field = value*2
    }
    get() {
       return field +3
    }


fun main(args: Array<String>){
    println(param1)
    println(param2)
    param2 = 10
    println(param2)
    println(param3)
    param3 = 3
    println(param3)

}

变量在定义时都要被初始化，否则就要将变量声明为可空类型，如：

var str: String?   //可空类型就是在类型后面加个问号

4、常量

Java：

final int param = 100;

Kotlin:

val <propertyName>[: <PropertyType>] [= <property_initializer>]
      [<getter>]

val param = 100
val param : Int = 100
val 我 : Int = 9999 //你没看错，Kotlin的常量名不再局限于英文字母、下画线和数字了。

val是常量,所以只有get方法

val param1 = 5
    get//默认

val param2 = 7
    get() = field + 4
fun main(args: Array<String>){
    println(param1)
    println(param2)
}

5、语法定义

Java：

int getParam(){
	return 8;
}

Kotlin:

fun getParam(): Int{
    return 8
}

6、字符模板

Java：
没有字符模板
Kotlin：

fun templateString(str: String): String{
    return "This is a $str"
}
fun main(args: Array<String>){
    println(templateString("Tom"))
}

7、数据类型

Java：
一、基本数据类型：

类型 位宽度
byte 8
short 16
int 32
long 64
float 32
double 64
char 16
boolean 8

二、引用数据类型：
类，接口，数组

Kotlin：
一、基本数据类型：

类型 位宽度
Byte 8
Short 16
Int 32
Long 64
Float 32
Double 64
Char 16
Boolean 8

二、引用数据类型：
可空类型（Null）、对象类型（Object）、数组类型（Array）
三、其他（Java中没有的）：
Tuple元组类型，分为二元组（Pair）和三元组（Triple），可以把不同类型的数据组合在一起。

    val (status,msg) = Pair(404,"Not found")
    println("$status:$msg")

    val (server,language,database) = Triple("Nginx","Kotlin","MySql")
    println("Server:$server,Development Language:$language,DB:$database")

8、数据类型的检查

Java：
instanceof

    Object str = "Hello world";
    boolean flag = a instanceof String;

Kotlin：
is

	var str = "Hello world"
    var flag: Boolean = str is String

9、安全操作符：?.

Java：
没有这一类操作符
Kotlin：

var str: String? = null  // 可空类型，可以同值null
var len = str?.length   // 如果str不为空，就返回str的长度，否则返回null

10、Elvis操作符?:

Java：
没有这一类的操作符
Kotlin：

var str: String? = null  // 可空类型，可以同值null
var len = str?.length?:-1  // 如果str不为空，就返回str的长度，否则返回某个非空值，如这里的-1

11、!!操作符

Java：
没有这一类的操作符
Kotlin：

var str: String? = null  // 可空类型，可以同值null
    val len = str!!.length  // 直接抛出空值异常

抛出异常：

 Exception in thread "main" kotlin.KotlinNullPointerException
	at hello.MyMainKt.main(MyMain.kt:16)

11、数据类型的转换

Java：
基本数据类型转换
1、类型转换主要发生在赋值、方法调用、算术运算 三种情况下发生。
　　a、赋值和方法调用转换规则：从低位类型到高位类型自动转换；从高位类型到低位类型需要强制类型转换：
　　（1）布尔型和其它基本数据类型之间不能相互转换；
　　（2）byte型可以转换为short、int、、long、float和double；
　　（3）short可转换为int、long、float和double；
　　（4）char可转换为int、long、float和double；
　　（5）int可转换为long、float和double；
　　（6）long可转换为float和double；
　　（7）float可转换为double；
　　b、算术运算中的类型转换：先转换为高位数据类型，再参加运算，结果也是最高位的数据类型；byte short char运算会转换为Int；
（1）如操作数之一为double，则另一个操作数先被转化为double，再参与算术运算。
（2）如两操作数均不为double，当操作数之一为float，则另一操作数先被转换为float，再参与运算。
（3）如两操作数均不为double或float，当操作数之一为long，则另一操作数先被转换为long，再参与算术运算。
（4）如两操作数均不为double、float或long，则两操作数先被转换为int，再参与运算。
特殊：
1）如采用+=、*=等缩略形式的运算符，系统会自动强制将运算结果转换为目标变量的类型。
2) 当运算符为自动递增运算符（++）或自动递减运算符（–）时，如果操作数为byte，short或char类型不发生改变；
　引用类型转换原则
　1、基本类型与对应包装类可自动转换，这是自动装箱和折箱的原理；

        Integer c1 = new Integer(1);
        Integer c2 = 2;
        int cc = new Integer(3);

2、两个引用类型间转换：
　　　　（1）子类能直接转换为父类 或 接口类型；
　　　　（2）父类转换为子类要强制类型转换；且在运行时若实际不是对应的对象，会抛出ClassCastException运行时异常；

Kotlin：
智能转换，不需要任何操作符进行操作，编辑器会自动跟踪不可变值的is来进行检查，并且在需要时会自动插入进行安全转换(as?)。

不安全转换，var a: String = b as String，如：

    var str: String = "2"
    var a: Int = str as Int  //直接抛异常
    println(a)

安全转换，var a: String? = b as? String,如：

    var str: String = "2"
    var a: Int? = str as? Int
    println(a)

显式转换，国为不能将较小的数据类型隐式转换为较大的类型，所以每个数字都支持进行类型转换。

    var a: Int = 10
    var aByte = a.toByte()
    var aShort = a.toShort()
    var aInt = a.toInt()
    var aLong = a.toLong()
    println(aByte)
    println(aShort)
    println(aInt)
    println(aLong)

隐式转换，在运算的过程中进行转换，如val a = 2L + 3

12、恒等（＝＝＝）、非恒等（!＝＝）

kotlin中的===为恒等运算符(===)来检查参数与调用equals的对象是否相同。恒等运算符与Java中的==运算符是完全相同的: 检查两个参数是否是同一个对象的引用（如果是基本数据类型，检查他们是否是相同的值）. 注意 === 运算符不能被重载.

13、逻辑运算符

Java Kotlin
&& &&或and
|| ||或 or
! ！
xor（异或）

14、位运算符

Java：

下表列出了位运算符的基本运算,假设整数变量A的值为60和变量B的值为13：

操作符 描述 例子
＆ 如果相对应位都是1，则结果为1，否则为0 （A＆B），得到12，即0000 1100
| 如果相对应位都是0，则结果为0，否则为1 （A | B）得到61，即 0011 1101
^ 如果相对应位值相同，则结果为0，否则为1 （A ^ B）得到49，即 0011 0001
〜 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 （〜A）得到-61，即1100 0011
<< 按位左移运算符。左操作数按位左移右操作数指定的位数。 A << 2得到240，即 1111 0000
>> 按位右移运算符。左操作数按位右移右操作数指定的位数。 A >> 2得到15即 1111
>>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 A>>>2得到15即0000 1111

Kotlin
Kotlin中没有位运算符。它抛弃了类C风格的位运算符，只是定义了几个函数：

Java位运算符 Kotlin中缀 Kotlin函数 描述
a&b a and b a.and(b) 按位与
a|b a or b a.or(b) 按位与
a^b a xor b a.xor(b) 按位异或
~a 无 a.inv() 按位取非
a< a shl b a.shl(b) 左移b位
a>>b a shr b a.shr(b) 右移b位
a>>>b a ushr b a.ushr(b) 无符号右移b位

15、数组生成

Java：

    int data1[] = new int[3];
    int data2[] = new int[]{1,2,3};

Kotlin：
Kotlin要使用函数的方法来创建数组

    val b = Array(3){i -> 2 * i }
    println(b[1])
    var a = arrayOf(1,2,3,4)
    a[3] = 100
    println(a[3])
    println(a[2])
    val c: IntArray = intArrayOf(1,3,4,5)
    println(c[3])

16、条件语句switch、when

Java：
switch语句

        int flag = 1;
        switch (flag) {
            case 1:
                System.out.println("登录成功！");
                break;
            case 2:
                System.out.println("登录失败");
                break;

            default: {
                System.out.println("未知错误400");

            }
        }

Kotlin：
when语句,

 var flag: Int = 1
    when(flag){
        1->{
            println("登录成功")
        }
        2->{
            println("登录失败")
        }
        in 3..10->{
            println("未知错误1")
        }
        else->{
            println("未知错误400")
        }
    }

可以用when语句来取代if语句哦，下面的when语句和if语句是等价的

    var name: String = "Tom"
    if(name == "Tom"){
        println("用户名正确")
    }else{
        println("用户名错误")

    }
    when{
        name == "Tom" ->{
            println("用户名正确")
        }
        else->{
            println("用户名错误")

        }
    }

17、for循环

Java：

	int num[] = {1,2,3,4,5};
    for (int a:num) {
       System.out.println(a);
    }

	for (int a = 0; a<3; a++) {
       System.out.println("重要事情说三遍");
    }

Kotlin：

    var num: IntArray = intArrayOf(1,2,3,4,5)
    for (a in num){
        println(a)
    }

   for (a in 0..2){
        println("重要事情说三遍")
    }

还可以像下面的代码那样哦

    var num: Array<String> = arrayOf("a","b","c","d")
    for ((index,value) in num.withIndex()){
        println("index:$index,value:$value")
    }

与Java不同，Kotlin集合分为可变集合和不可变集合两种

18、集合之List，有序且可重复的集合
Java：


        List<String> stringList = new ArrayList<>();
        stringList.add("C");
        stringList.add("D");
        stringList.add("E");
        // 修改操作
        stringList.size();// 统计集合中元素的个数
        stringList.isEmpty();// 判断集合是否为空
        stringList.contains("2"); // 判断集合中是否存在某个函数
        stringList.iterator(); // 返回集合中的迭代器
        // 批量操作
        List<String> tempList = new ArrayList<>();
        tempList.add("A");
        tempList.add("B");
        stringList.containsAll(tempList); // 判断集合中是否包含某个集合
        // 搜索操作
        stringList.indexOf("2");// 返回元素首次出现的位置
        stringList.lastIndexOf("2");// 返回元素最后一次出现的位置
        // 迭代器
        Iterator<String> iterator = stringList.iterator();// 返回集合的迭代器
        Iterator<String> iterator1 = stringList.listIterator(2);// 从指定位置返回集合的迭代器
        List subList =  stringList.subList(0,2); // 返回列表中指定区间的集合

        //修改操作
        stringList.add("Hello world"); // 向集合添加元素
        stringList.set(2,"Good morning"); // 用特定的元素替换指定位置的元素
        stringList.add(1,"Good evening"); // 在指定位置添加元素
        stringList.remove(0); // 移除指定索引的元素
        stringList.remove("Hello world"); //移除指定的元素
        List<String> tmp = new ArrayList<>();
        tmp.add("Hi");
        tmp.add("Bye");
        stringList.addAll(tmp); // 向集合中添加一个集合
        stringList.removeAll(tmp); // 移除集合中一个集合
        stringList.retainAll(tmp); // 判断集合中是否包含某个集合
        stringList.clear(); //清空元素

Kotlin：
Kotlin并没有创建List集合的函数，要调用标准库中的listOf()和mutableListOf()方法来创建。

（1）不可变List：

 var stringList: List<String> = listOf("C","D","E")

    // 修改操作
    var elementsCount: Int = stringList.size// 统计集合中元素的个数
    var emptyOrNot: Boolean = stringList.isEmpty()// 判断集合是否为空
    var existsOrNot:Boolean = stringList.contains("2") // 判断集合中是否存在某个函数
    stringList.iterator(); // 返回集合中的迭代器
    // 批量操作
    var tempList: List<String> = listOf("A","B")
    var containOrNot: Boolean = stringList.containsAll(tempList)// 判断集合中是否包含某个集合
    // 搜索操作
    var index: Int = stringList.indexOf("2")// 返回元素首次出现的位置
    var lastIndex: Int = stringList.lastIndexOf("2")// 返回元素最后一次出现的位置
    // 迭代器
    var iterator: Iterator<String> = stringList.iterator()// 返回集合的迭代器
    var iterator1: Iterator<String> = stringList.listIterator(2)// 从指定位置返回集合的迭代器
    var subList: List<String> =  stringList.subList(0,2) // 返回列表中指定区间的集合

可变List：就是多了修改操作

var mutableStringList: MutableList<String> = mutableListOf("C","D","E")

   // 修改操作
   var elementsCount: Int = mutableStringList.size// 统计集合中元素的个数
   var emptyOrNot: Boolean = mutableStringList.isEmpty()// 判断集合是否为空
   var existsOrNot:Boolean = mutableStringList.contains("2") // 判断集合中是否存在某个函数
   mutableStringList.iterator(); // 返回集合中的迭代器
   // 批量操作
   var tempList: List<String> = listOf("A","B")
   var containOrNot: Boolean = mutableStringList.containsAll(tempList)// 判断集合中是否包含某个集合
   // 搜索操作
   var index: Int = mutableStringList.indexOf("2")// 返回元素首次出现的位置
   var lastIndex: Int = mutableStringList.lastIndexOf("2")// 返回元素最后一次出现的位置
   // 迭代器
   var iterator: Iterator<String> = mutableStringList.iterator()// 返回集合的迭代器
   var iterator1: Iterator<String> = mutableStringList.listIterator(2)// 从指定位置返回集合的迭代器
   var subList: List<String> =  mutableStringList.subList(0,2) // 返回列表中指定区间的集合

   //修改操作
   mutableStringList.add("Hello world") // 向集合添加元素
   mutableStringList[2] = "Good morning" // 用特定的元素替换指定位置的元素
   mutableStringList.set(2,"Good morning") // 用特定的元素替换指定位置的元素

   mutableStringList.add(1,"Good evening") // 在指定位置添加元素
   mutableStringList.removeAt(0) // 移除指定索引的元素
   mutableStringList.remove("Hello world") //移除指定的元素
   var tmp: MutableList<String> = mutableListOf("Hi","Bye")
   mutableStringList.addAll(tmp)// 向集合中添加一个集合
   mutableStringList.removeAll(tmp) // 移除集合中一个集合
   mutableStringList.retainAll(tmp)// 判断集合中是否包含某个集合
   var copyList: List<String> = mutableStringList.toList() // 复制list中的内容，返回一个不可变的List
   mutableStringList.clear() //清空元素

19、集合之Set

不可重复，且无序。
Java：

Set<String> stringSet = new HashSet<>();
        stringSet.add("C");
        stringSet.add("D");
        stringSet.add("E");
        // 修改操作
        stringSet.size();// 统计集合中元素的个数
        boolean emptyOrNot = stringSet.isEmpty();// 判断集合是否为空
        boolean containOrNot = stringSet.contains("2"); // 判断集合中是否存在某个函数
        // 批量操作
        List<String> tempList = new ArrayList<>();
        tempList.add("A");
        tempList.add("B");
        boolean containsAllOrNot = stringSet.containsAll(tempList); // 判断集合中是否包含某个集合
        // 迭代器
        Iterator<String> iterator = stringSet.iterator(); // 返回集合中的迭代器
        //修改操作
        stringSet.add("Hello world"); // 向集合添加元素
        stringSet.remove(0); // 移除指定索引的元素
        stringSet.remove("Hello world"); //移除指定的元素
        Set<String> tmp = new HashSet<>();
        tmp.add("Hi");
        tmp.add("Bye");
        stringSet.addAll(tmp); // 向集合中添加一个集合
        stringSet.removeAll(tmp); // 移除集合中一个集合
        stringSet.retainAll(tmp); // 判断集合中是否包含某个集合
        stringSet.clear(); //清空元素

Kotlin：
Kotlin没有提供专门的语法用来创建Set集合，可以使用标准库中的setOf()和mutableSetOf()方法。
不可变Set：

可变Set：

    var stringSet: Set<String> = setOf("C","D","E")

    // 修改操作
    var elementsCount: Int = stringSet.size// 统计集合中元素的个数
    var emptyOrNot: Boolean = stringSet.isEmpty()// 判断集合是否为空
    var existsOrNot:Boolean = stringSet.contains("2") // 判断集合中是否存在某个函数
    // 批量操作
    var tempSet: Set<String> = setOf("A","B")
    var containOrNot: Boolean = stringSet.containsAll(tempSet)// 判断集合中是否包含某个集合
    // 搜索操作
    var index: Int = stringSet.indexOf("2")// 返回元素首次出现的位置
    var lastIndex: Int = stringSet.lastIndexOf("2")// 返回元素最后一次出现的位置
    // 迭代器
    var iterator: Iterator<String> = stringSet.iterator()// 返回集合的迭代器

可变Set：

    var mutableStringSet: MutableSet<String> = mutableSetOf("C","D","E")

    // 修改操作
    var elementsCount: Int = mutableStringSet.size// 统计集合中元素的个数
    var emptyOrNot: Boolean = mutableStringSet.isEmpty()// 判断集合是否为空
    var existsOrNot:Boolean = mutableStringSet.contains("2") // 判断集合中是否存在某个函数
    // 批量操作
    var tempSet: Set<String> = setOf("A","B")
    var containOrNot: Boolean = mutableStringSet.containsAll(tempSet)// 判断集合中是否包含某个集合
    // 搜索操作
    var index: Int = mutableStringSet.indexOf("2")// 返回元素首次出现的位置
    var lastIndex: Int = mutableStringSet.lastIndexOf("2")// 返回元素最后一次出现的位置
    // 迭代器
    var mutableIterator: MutableIterator<String> = mutableStringSet.iterator()// 返回集合的迭代器
    //修改操作
    mutableStringSet.add("Hello world") // 向集合添加元素
    mutableStringSet.remove("Hello world") //移除指定的元素
    var tmp: MutableSet<String> = mutableSetOf("Hi","Bye")
    mutableStringSet.addAll(tmp) // 向集合中添加一个集合
    mutableStringSet.removeAll(tmp) // 移除集合中一个集合
    mutableStringSet.retainAll(tmp) // 判断集合中是否包含某个集合
    var copySet: Set<String> = mutableStringSet.toSet() // 复制Set中的内容，返回一个不可变的Set
    mutableStringSet.clear() //清空元素

20、集合之Map

Java：

        Map<String, String> map = new HashMap<String, String>();

        // 插入元素
        map.put("key1", "value1");
        // 获取元素
        String value = map.get("key1");
        // 移除元素
        map.remove("key1");
        // 清空map
        map.clear();
        // Map 遍历
        // 初始化数据
        Map<String, String> map1 = new HashMap<String, String>();
        map1.put("key1", "value1");
        map1.put("key2", "value2");
        // 增强for循环遍历
        // 使用keySet()遍历
        for (String key : map1.keySet()) {
            System.out.println(key + " ：" + map1.get(key));
        }
        // 其实业界更提倡使用entrySet

        for (Map.Entry<String,String> entry : map1.entrySet()) {
            System.out.println(entry.getKey() + " ：" + entry.getValue());
        }

        // 迭代器遍历
        // 使用keySet()遍历
        Iterator<String> iterator = map1.keySet().iterator();
        while (iterator.hasNext()){
            String key = iterator.next();
            System.out.println(key + "　：" + map1.get(key));
        }

        // 使用entrySet()遍历
        Iterator<Map.Entry<String,String>> iterator1 = map1.entrySet().iterator();
        while (iterator1.hasNext()) {
            Map.Entry<String, String> entry = iterator1.next();
            System.out.println(entry.getKey() + "　：" + entry.getValue());
        }

        // Map 排序：HashMap、Hashtable、LinkedHashMap排序
        Map<String, String> map2 = new HashMap<String, String>();
        map2.put("b", "b");
        map2.put("a", "c");
        map2.put("c", "a");
        // 通过ArrayList构造函数把map.entrySet()转换成list
        List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(map2.entrySet());
        // 通过比较器实现比较排序
        list.sort(new Comparator<Map.Entry<String, String>>() {
            @Override
            public int compare(Map.Entry<String, String> mapping1, Map.Entry<String, String> mapping2) {
                return mapping1.getKey().compareTo(mapping2.getKey());
            }
        });


        for (Map.Entry<String, String> mapping : list) {
            System.out.println(mapping.getKey() + " ：" + mapping.getValue());
        }


        // TreeMap排序,TreeMap默认按key进行升序排序，如果想改变默认的顺序，可以使用比较器
        Map<String,String> map3 = new TreeMap<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                // 降序排序
                return o2.compareTo(o1);
            }
        });
        map3.put("2", "b");
        map3.put("1", "c");
        map3.put("3", "a");
        for (Map.Entry<String,String> entry : map3.entrySet()) {
            System.out.println(entry.getKey() + " ：" + entry.getValue());
        }
        // 按value排序
        TreeMap<String,String> map4 = new TreeMap<>();
        map4.put("5", "1");
        map4.put("7", "3");
        map4.put("6", "2");
        List<Map.Entry<String,String>> list1 = new ArrayList<>(map4.entrySet());
        list1.sort(new Comparator<Map.Entry<String, String>>() {
            @Override
            public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
                return o1.getValue().compareTo(o2.getValue());
            }
        });
        for (Map.Entry<String,String> entry : map4.entrySet()) {
            System.out.println(entry.getKey() + " ：" + entry.getValue());
        }

Kotlin：
Kotlin没有提供专门的语法用来创建Map集合，可以使用标准库中的mapOf()和mutableMapOf()方法来创建。

不可变Map：

    var map: Map<String, String> = hashMapOf("key1" to "value1")

    // 插入元素

    // 获取元素
    val value: String? = map.get("key1")

    // Map 遍历
    // 初始化数据
    var map1: Map<String, String> = hashMapOf("key1" to "value1","key2" to "value2")
    // 增强for循环遍历
    // 使用keySet()遍历

    for (key in map1.keys) {
        System.out.println(key + " ：" + map1.get(key));
    }
    // 其实业界更提倡使用entrySet

    for ( entry in map1.entries) {
        System.out.println(entry.key + " ：" + entry.value);
    }

    // 迭代器遍历
    // 使用keySet()遍历
    var iterator:Iterator<String> = map1.keys.iterator();
    while (iterator.hasNext()){
        var key: String = iterator.next();
        System.out.println(key + "　：" + map1.get(key));
    }

    // 使用entrySet()遍历
    var iterator1: Iterator<Map.Entry<String,String>>  = map1.entries.iterator();
    while (iterator1.hasNext()) {
        var entry: Map.Entry<String, String> = iterator1.next();
        System.out.println(entry.key + "　：" + entry.value);
    }

    // Map 排序：HashMap、Hashtable、LinkedHashMap排序
    var map2: Map<String, String> = hashMapOf("b" to "b","a" to "c","c" to "a")

    // 通过ArrayList构造函数把map.entrySet()转换成list
    var list: List<Map.Entry<String, String>> = map2.entries.toList();
    // 通过比较器实现比较排序
    list.sortedWith(Comparator { o1, o2 ->  o1.key.compareTo(o2.key)})

    for (mapping in list) {
        System.out.println(mapping.key + " ：" + mapping.value);
    }


    // TreeMap排序,TreeMap默认按key进行升序排序，如果想改变默认的顺序，可以使用比较器
    var map3: TreeMap<String,String> = TreeMap<String,String>()

    map3["2"] = "b"
    map3["1"] = "c"
    map3["3"] = "a"

    map3.toSortedMap(Comparator { o1 , o2 -> o2.compareTo(o1) })


    for ( entry in map3.entries) {
        System.out.println(entry.key + " ：" + entry.value)
    }
    // 按value排序
    var map4: TreeMap<String,String> = TreeMap<String,String>()
    map4["5"] = "1"
    map4["7"] = "3"
    map4["6"] = "2"
    
    for((key,value) in map4.entries){
        println("key:$key###value:$value")
    }
    var list1: List<Map.Entry<String,String>> = map4.entries.toList()
    list1.sortedWith(Comparator { o1, o2 -> o1.value.compareTo(o2.value) })

    for (entry in map4.entries) {
        System.out.println(entry.key + " ：" + entry.value)
    }

可变map：就是比不可变map多了一些删除、清空功能

    var map5: MutableMap<Int,String> = mutableMapOf<Int,String>(1 to "A",3 to "C",2 to "B") 

   // 移除元素
   map5.remove(0)
   // 清空map
   map5.clear()

21、集合操作符

Java8：
Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。
这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

(1)java的总数操作

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // any是否有满足条件的元素
        boolean flag = list.stream().anyMatch(a -> a > 5);

        System.out.println(flag);
        boolean flag1 = list.stream().anyMatch(new Predicate<Integer>(){

            @Override
            public boolean test(Integer integer) {
                return integer > 5;
            }
        });

        System.out.println(flag1);


        // all是否所有元素都满足条件
        boolean all = list.stream().allMatch(a -> a >5);
        System.out.println(all);


        // none 是否所有元素都不满足条件
        boolean none = list.stream().noneMatch( a -> a > 5);
        System.out.println(none);

        // count 满足条件的元素的个数
        long count = list.stream().count();  //list.size()
        System.out.println(count);


        // reduce 从第一个元素从到最后一个元素进行累计
       Optional.ofNullable(list.stream().reduce((a, b) -> a + b)).ifPresent(value ->
       {
           if(value.isPresent()){
               System.out.println(value.get());
           }
       });

       Optional<Integer> sum = list.stream().reduce(new BinaryOperator<Integer>() {
           @Override
           public Integer apply(Integer integer, Integer integer2) {
               return integer + integer2;
           }
       });

       if(sum.isPresent()) {
           System.out.println(sum.get());

       }

       Optional<Integer> sum1 = Optional.of(list.stream().reduce(10,(a,b)-> a+b));
       if(sum1.isPresent()){
           System.out.println(sum1.get());
       }

        Optional<Integer> sum2 = Optional.of(list.stream().reduce(10, new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) {
                return integer + integer2;
            }
        }));
        if(sum2.isPresent()){
            System.out.println(sum2.get());
        }

        // fold 以一个初始值开始从第一个元素从到最后一个元素进行累计
        // java 没有

        //forEach 循环遍历元素，对于forEach本身需要使用it关键字对每个元素进行相关操作
        list.stream().forEach(a -> {
            if( a == 5){
            System.out.println("I love You!");

        }
        });
        list.stream().forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                if( integer == 5){
                    System.out.println("I love You!");

                }
            }
        });


        //主要的区别在并行流的处理上
        //输出的顺序不一定（效率更高）
        Stream.of("AAA", "BBB", "CCC").parallel().forEach(s -> System.out.println("Output:" + s));
        //输出的顺序与元素的顺序严格一致
        Stream.of("AAA", "BBB", "CCC").parallel().forEachOrdered(s -> System.out.println("Output:" + s));




        // max 查询最大的元素

        Optional<Integer> max1 = list.stream().max((a,b) -> a.compareTo(b));
        if(max1.isPresent()){
            System.out.println(max1.get());
        }

        System.out.println(list.stream().max(Integer::compare).get());


        // min 查询最小的元素
        Optional<Integer> min1 = list.stream().min((a,b) -> a.compareTo(b));
        if(min1.isPresent()){
            System.out.println(min1.get());
        }

        System.out.println(list.stream().min(Integer::compare).get());

（2）过滤操作

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);


        // filter 过滤所有满足条件的元素

        Stream<Integer> listStream = list.stream().filter(a -> a > 5 );
        // 将Stream转化为List
        Collection<Integer> listInteger = listStream.collect(Collectors.toList());
        System.out.println(listInteger);

        Stream<Integer> listStream1 = list.stream().filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 5;
            }
        });

        // 将Stream转化为List
        Collection<Integer> listInteger1 = listStream1.collect(Collectors.toList());
        System.out.println(listInteger1);


        // filterNot 过滤掉所有不满足条件的元素
        // Java 没有特别这个功能，需要通过filter实现

        // filter 过滤所有满足条件的元素

        Stream<Integer> listStream2 = list.stream().filter(a -> a <= 5 );
        // 将Stream转化为List
        Collection<Integer> listInteger2 = listStream2.collect(Collectors.toList());
        System.out.println(listInteger2);

        Stream<Integer> listStream3 = list.stream().filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer <= 5;
            }
        });
        // 将Stream转化为List
        Collection<Integer> listInteger3 = listStream3.collect(Collectors.toList());
        System.out.println(listInteger3);


        // filterNotNull 过滤掉null
        // Java 没有特别提供这个功能，需要通过filter实现
    
        // take 返回从第一个元素开始的n个元素
        // Java 没有特别提供这个功能,需要通过其他方式实现

        // takeLast 返回从最后一个元素开始的n个元素
        // Java 没有特别提供这个功能,需要通过其他方式实现


        // takeWhile 返回从第一个元素开始符合给定函数条件的元素
        // Java 没有特别提供这个功能,需要通过其他方式实现
        
        // drop 返回去掉前n个元素的列表
        // Java 没有特别提供这个功能,需要通过其他方式实现



        // dropLastWhile 返回从最后一项起，去掉满足条件的元素，直到不满足条件的一项为止
        // Java 没有特别提供这个功能,需要通过其他方式实现

        // slice 过滤掉非指定下标对应的元素，即保留指定下标对应的元素
        // Java 没有特别提供这个功能,需要通过其他方式实现

（3）Java8映射操作

        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

        // map对集合中的元素通过 某方法转换后，将结果保存到一个集合中

        // 将Stream转化为List
        Stream<Integer> listStream1 = list.stream().map(a -> a + 1);
        Collection<Integer> listInteger1 = listStream1.collect(Collectors.toList());
        System.out.println(listInteger1);


        Stream<Integer> listStream2 = list.stream().map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) {
                return integer + 1;
            }
        });
        Collection<Integer> listInteger2 = listStream2.collect(Collectors.toList());

        System.out.println(listInteger2);

        // mapIndexed 除了可以得到转换后的集合，还可以得到索引（下标）
        // java没有提供这一个，需要通过其他方式实现

        // Java中的flatMap与Kotlin是不一样的。
        // map只是一维1对1的映射
        // 而flatmap可以将一个2维的集合映射成一个一维,相当于他映射的深度比map深了一层
        // Java 8 中我们可以通过 `::` 关键字来访问类的构造方法，对象方法，静态方法
        String[] words = new String[]{"Hello","World"};
        List<String[]> a = Arrays.stream(words).map(word -> word.split("")).distinct().collect(Collectors.toList());
        a.forEach(System.out::println);

        // 对流扁平化处理
        List<String> aa = Arrays.stream(words).map(word -> word.split("")).flatMap(Arrays::stream).distinct().collect(Collectors.toList());
        aa.forEach(System.out::print);
        
        // groupBy将集合中的元素按照某个条件进行分组，返回map
        // java没有提供这一个，需要通过其他方式实现

（4）顺序操作符

        List<Integer> list = Arrays.asList(1, 5, 9, 7, 26, 74, 32, 47, 41, 42, 6);
        // reversed以相反顺序排列
        Collections.reverse(list); // 倒序排列
        System.out.println(list);


        //sorted自然排序（升序）

        System.out.println(list.stream().sorted().collect(Collectors.toList()));
        System.out.println(list.stream().sorted((o1,o2) -> o1 - o2).collect(Collectors.toList()));
        System.out.println(list.stream().sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        }).collect(Collectors.toList()));


        // sortedBy根据方法处理结果进行自然（升序）排列
        // java中没有对应的方法,可通过sorted方法来实现

        // sortedDescending降序排列

        System.out.println(list.stream().sorted((o1,o2) -> o2 - o1).collect(Collectors.toList()));
        System.out.println(list.stream().sorted(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        }).collect(Collectors.toList()));


        // sortedByDescending根据方法处理结果进行降序排列
        // java中没有对应的方法,可通过sorted方法来实现

（5）生产操作符
在Java中没有对应的，需要通过其他方式来实现。
（6）元素操作符

 List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

        // contains 判断集合是否包含有指定的元素，如果有则返回true，否则返回false
        System.out.println(list.contains(0));
        System.out.println(list.contains(5));

        // elementAt 查找下标对应的元素,java可以用get来代替
        System.out.println(list.get(0));
        // elementAtOrElse  查找下标对应的元素，如果下标越界，则返回指定的默认值
        // java没有对应的方法

        // elementAtOrNull 查找下标对应的元素，如果下标越界，则返回null
        // java没有对应的方法

        // first 返回符合条件的第一个元素，如果没有则抛出异常
        // java没有对应的方法


        // firstOrNull 返回符合条件的第一个元素，如果没有则返回null
        // java没有对应的方法

        // indexOf 返回指定元素对应的下标，没有则返回－1
        System.out.println(list.indexOf(8));

        // indexOfFirst 返回第一个符合条件的元素的下标，没有则返回－1
        // java没有对应的方法

        // indexOfLast 返回最后一个元素的下标，没有则返回－1
        // java没有对应的方法


        // last 返回符合条件的最后一个元素，没有则抛出异常
        // java没有对应的方法


        // lastIndexOf 返回符合条件的最后一个元素的下标，没有则返回－1
        System.out.println(list.lastIndexOf(5));
        // lastOrNull 返回符合条件的最后一个元素，没有则返回null
        // java没有对应的方法

        // single  返回符合条件的元素，没有或超过一个都会报异常
        // java没有对应的方法

        // singleOrNull 返回符合条件的元素，没有或超过一个则返回null
        // java没有对应的方法

Kotlin：
（1）总数操作符


fun main(){
   val list = listOf(1,2,3,4,5,6,7,8,9,10)
    // any是否有满足条件的元素
    println(list.any { it > 5}) // it是默认的传入参数
    println(list.any{ i: Int -> i > 5 })
    println(list.any { a -> a > 5 })
    println(list.any(fun(a: Int): Boolean{
        return a > 5
    }))
    println("any#"+list.any()) // 集合是否不为空


    // all是否所有元素都满足条件
    println(list.all { it > 5 })
    println(list.all { a: Int -> a > 5 })
    println(list.all { a -> a > 5 })
    print("####")
    println(list.all(fun(a: Int): Boolean{
        return a > 5
    }))


    // none 是否所有元素都不满足条件
    println(list.none { it > 5 })
    println(list.none { a: Int -> a > 5 })
    println(list.none { a -> a > 5 })
    println(list.none(fun(a: Int): Boolean{
        return a > 5
    }))
    println("none#"+list.none()) // 集合是否为空

    // count 满足条件的元素的个数
    println(list.count { it > 5 })
    println(list.count { a: Int -> a > 5 })
    println(list.count { a -> a > 5 })
    println(list.count(fun(a: Int): Boolean{
        return a > 5
    }))
    println("count##"+list.count()) // 集合元素的个数

    // reduce 从第一个元素从到最后一个元素进行累计
    println(list.reduce { total, next -> total + next  })
    println(list.reduce(Int::plus))
    println("%%%%")
    println(list.reduce(fun(total: Int, next: Int): Int{
        return total + next
    }))


    // reduceRight 从最后一个元素从到第一个元素进行累计
    println(list.reduceRight { total, next -> total + next  })
    println(list.reduceRight(Int::plus))
    println(list.reduceRight(fun(total: Int, next: Int): Int{
        return total + next
    }))

    // fold 以一个初始值开始从第一个元素从到最后一个元素进行累计
    println(list.fold(10){ total,next -> total + next})
    println(list.fold(20,{ tatol,next -> tatol + next })) // 一般都不样写，一般都写成上面那样，把lamda放在括号外面
    println(list.fold(2,fun(total: Int, next: Int): Int{
        return total + next
    }))

    // foldRight 以一个初始值开始从最后一个元素从到第一个元素进行累计
    println(list.foldRight(1){ total, next -> total + next })
    println(list.foldRight(2,fun(total: Int, next: Int): Int{
        return total + next
    }))
    //forEach 循环遍历元素，对于forEach本身需要使用it关键字对每个元素进行相关操作
    list.forEach {
        if( it == 5 ){
            println("I love You!")
        }
    }

    list.forEach(fun(value: Int){
        if(value == 10) {
        println("I am very good!")
        }
    })

    // forEachIndexed 循环遍历元素，同时得到元素索引
    list.forEachIndexed{ i,s ->
        print(i)
        print("#")
        println(s)
    }
    list.forEachIndexed(fun(index: Int, s: Int){
        println("#$index#$s")
    })

    // max 查询最大的元素，如果没有就返回null
    println(list.max())

    // maxBy 获取处理后返回结果最大值 对应的那个元素的初始值，没有则返回null
    println(list.maxBy { it * it })
    println(list.maxBy(fun(i: Int):Int{
        return i*i
    }))

    // min 查询最小的元素，如果没有就返回null
    println(list.min())

    // minBy 获取处理后返回结果最小值对应的那个元素的初始值，没有则返回null
    println(list.minBy { it * it })
    println(list.minBy(fun(i: Int):Int{
        return i*i
    }))

    // sumBy 获取处理后返回结果值的总和
    println(list.sumBy { it * it })
    println(list.sumBy(fun(i: Int):Int{
        return i*i
    }))

    // dropWhile返回从第一项起，去掉满足条件的元素，直到不满足条件的一项为止
    println(list.dropWhile { it < 5 })
    println(list.dropWhile(fun(i :Int):Boolean{
        return i < 5
    }))

}

（2）过滤操作符

   val list = listOf(1,2,3,4,5,6,7,8,9,10)

    // filter 过滤所有满足条件的元素

    println(list.filter { it > 5 })
    println(list.filter { a: Int -> a > 5 })
    println(list.filter{ a -> a > 5 })
    println(list.filter(fun( a: Int): Boolean{
        return a > 5
    }))

    // filterNot 过滤掉所有不满足条件的元素
    println("###")
    println(list.filterNot { it > 5 })
    println(list.filterNot { a: Int -> a > 5 })
    println(list.filterNot { a -> a > 5 })
    println(list.filterNot(fun( a: Int): Boolean{
        return a > 5
    }))

    // filterNotNull 过滤掉null
    println(list.filterNotNull())


    // take 返回从第一个元素开始的n个元素
    println(list.take(5))

    // takeLast 返回从最后一个元素开始的n个元素
    println(list.takeLast(5))

    // takeWhile 返回从第一个元素开始符合给定函数条件的元素
    println("###")
    println(list.takeWhile { it < 5 })
    println(list.takeWhile { a: Int -> a < 5 })
    println(list.takeWhile { a -> a < 5 })
    println(list.takeWhile(fun( a: Int): Boolean{
        return a < 5
    }))

    // drop 返回去掉前n个元素的列表
    println("###")
    println(list.drop(5))


    // dropLastWhile 返回从最后一项起，去掉满足条件的元素，直到不满足条件的一项为止

    println("###")
    println(list.dropLastWhile { it > 5 })
    println(list.dropLastWhile { a: Int -> a > 5 })
    println(list.dropLastWhile { a -> a > 5 })
    println(list.dropLastWhile(fun( a: Int): Boolean{
        return a > 5
    }))
    // slice 过滤掉非指定下标对应的元素，即保留指定下标对应的元素
    println(list.slice(0..9))
    println(list.slice(0..4))
    println(list.slice(listOf(0,2,4,6,8)))

（3）映射操作符

   val list = listOf(1,2,3,4,5,6,7,8,9,10)

    // map对集合中的元素通过 某方法转换后，将结果保存到一个集合中
    println(list.map { it + 1 })
    println(list.map { a: Int -> a + 1 })
    println(list.map { a -> a + 1 })
    println(list.map(fun(a: Int): Int{
        return a + 2
    }))
    // mapIndexed 除了可以得到转换后的集合，还可以得到索引（下标）
    println(list.mapIndexed { index, i ->  index * i  })
    println(list.mapIndexed(fun(index: Int,i: Int): Int{
        return index * i
    }))
    // mapNotNull在执行方法转换前过滤掉值为null的元素
    println(list.mapNotNull { it + 1 })
    println(list.mapNotNull { a: Int -> a + 1 })
    println(list.mapNotNull { a -> a + 1 })
    println(list.mapNotNull(fun(a: Int): Int{
        return a + 2
    }))
    // flatMap合并两个集合，可以在合并时做些其他小操作

    val list2 = listOf(11,12,13,14,15,16,17,18,19,20)
    println(listOf(list,list2).flatten())
    println(listOf(list,list2).flatMap { it.map {  "No.$it" } })
    println(listOf(list,list2).flatMap(fun(a: List<Int>): Iterable<String>{
        return a.map { "NNO.$it" }.asIterable()
    }))

    // groupBy将集合中的元素按照某个条件进行分组，返回map
    println(list.groupBy { if( it > 5) "Big" else "small" })
    println(list.groupBy{ a -> if(a > 5) "Big" else "small"})
    println(list.groupBy{ a: Int -> if(a > 5) "Big" else "small"})
    println(list.groupBy(fun(a: Int): String{
        return if(a > 5) "Bmig" else "small"
    }))

（4）顺序操作符

    var list = listOf(1, 5, 9, 7, 26, 74, 32, 47, 41, 42, 6)
    // reversed以相反顺序排列
    println(list.reversed())
    //sorted自然排序（升序）
    println(list.sorted())
    // sortedBy根据方法处理结果进行自然（升序）排列
    println(list.sortedBy{ it % 2 })
    println(list.sortedBy { a -> a % 2 })
    println(list.sortedBy { a: Int -> a % 2 })
    println(list.sortedBy(fun(a: Int): Int{
        return a % 2
    }))

    // sortedDescending降序排列
    println(list.sortedDescending())


    // sortedByDescending根据方法处理结果进行降序排列
    println(list.sortedByDescending { -it })
    println(list.sortedByDescending { a -> -a })
    println(list.sortedByDescending { a: Int -> -a })
    println(list.sortedByDescending(fun(a: Int): Int{
        return -a
    }))

（5）生产操作符
主要用于把两个集合按照相同的下标合成一个新的集合，这个集合的大小由最小的集合决定。

    // zip 将两个集合按照下标组合成一个个Pair放到集合中返回
    var list1 = listOf(2,3,4,5,6,7)
    var list2 = listOf(8,9,0)
    println(list1.zip(list2))  // [(2, 8), (3, 9), (4, 0)]
    println("$$$")
    println(list1.zip(list2,fun(a: Int,b: Int): Int{
        return a + b
    })) //[10, 12, 4]
    println(list1.zip(list2){ t1,t2 -> t1 + t2   }) // //[10, 12, 4]
    var list3 = listOf(Pair(1,5), Pair(2,7),Pair(4,3))
    println(list3.zip(listOf(3,6))) // [((1, 5), 3), ((2, 7), 6)]

    // partition 根据判断条件是否成立，拆分成两个Pair
    println(list1.partition(fun(a: Int): Boolean{
        return a % 2 == 0
    }))  // ([2, 4, 6], [3, 5, 7])

    println(list2.partition{ it % 2 == 0})  // ([8, 0], [9])


    // plus 合并两个List集合，可以用“＋”代替plus
    println(list1.plus(list2))
    println(list1 + list2)

    // unzip 将包含多个Pair4的List集合转换成含List集合的Pair
    println(list3.unzip())

（6）元素操作符

    var list = listOf(1,2,3,4,5,6,7,8,9,10)

    // contains 判断集合是否包含有指定的元素，如果有则返回true，否则返回false
    println(list.contains(0))
    println(list.contains(5))
    // elementAt 查找下标对应的元素，如果下标越界，则抛出异常
    println(list.elementAt(0))
    // elementAtOrElse  查找下标对应的元素，如果下标越界，则返回指定的默认值
    println(list.elementAtOrElse(11,{ 8 }))
    println(list.elementAtOrElse(11){ 8 })
    println(list.elementAtOrElse(11,fun(a: Int): Int{
        println("over boundary index:$a")
        return 8
    }))

    // elementAtOrNull 查找下标对应的元素，如果下标越界，则返回null
    println(list.elementAtOrNull(11))
    println(list.elementAtOrNull(9))

    // first 返回符合条件的第一个元素，如果没有则抛出异常
    println(list.first())

    println(list.first { it % 2 == 0 }) // 返回第一个符合条件的元素
    println(list.first {a -> a % 2 == 0 })
    println(list.first {a: Int -> a % 2 == 0 })
    println(list.first(fun(a: Int): Boolean{
        return a % 2 == 0
    }))

    // firstOrNull 返回符合条件的第一个元素，如果没有则返回null

    println(list.firstOrNull())

    println(list.firstOrNull { it % 4 == 0 }) // 返回第一个符合条件的元素
    println(list.firstOrNull {a -> a % 4 == 0 })
    println(list.firstOrNull {a: Int -> a % 4 == 0 })
    println(list.firstOrNull(fun(a: Int): Boolean{
        return a % 4 == 0
    }))

    // indexOf 返回指定元素对应的下标，没有则返回－1

    println(list.indexOf(8))
    // indexOfFirst 返回第一个符合条件的元素的下标，没有则返回－1
    println(list.indexOfFirst { it % 5 == 0 }) // 返回第一个符合条件的元素
    println(list.indexOfFirst {a -> a % 5 == 0 })
    println(list.indexOfFirst {a: Int -> a % 5 == 0 })
    println(list.indexOfFirst(fun(a: Int): Boolean{
        return a % 5 == 0
    }))

    // indexOfLast 返回最后一个符合条件的元素的下标，没有则返回－1
    println(list.indexOfLast { it % 5 == 0 }) // 返回第一个符合条件的元素
    println(list.indexOfLast {a -> a % 5 == 0 })
    println(list.indexOfLast {a: Int -> a % 5 == 0 })
    println(list.indexOfLast(fun(a: Int): Boolean{
        return a % 5 == 0
    }))


    // last 返回符合条件的最后一个元素，没有则抛出异常
    println(list.last())
    println(list.last { it % 5 == 0 }) // 返回第一个符合条件的元素
    println(list.last {a -> a % 5 == 0 })
    println(list.last {a: Int -> a % 5 == 0 })
    println(list.last(fun(a: Int): Boolean{
        return a % 5 == 0
    }))



    // lastIndexOf 返回符合条件的最后一个元素的下标，没有则返回－1
    println(list.lastIndexOf(7))

    // lastOrNull 返回符合条件的最后一个元素，没有则返回null
    println(list.lastOrNull())
    println(list.lastOrNull { it % 9 == 0 }) // 返回第一个符合条件的元素
    println(list.lastOrNull {a -> a % 9 == 0 })
    println(list.lastOrNull {a: Int -> a % 9 == 0 })
    println(list.lastOrNull(fun(a: Int): Boolean{
        return a % 9 == 0
    }))

    // single  返回符合条件的元素，没有或超过一个都会报异常
    // println(list.single())  //list 只能有一个元素，否则会报异常
    var singleList = listOf(8)
    println(singleList.single())
    println(list.single { it % 9 == 0 }) // 返回第一个符合条件的元素
    println(list.single {a -> a % 9 == 0 })
    println(list.single {a: Int -> a % 9 == 0 })
    println(list.single(fun(a: Int): Boolean{
        return a % 9 == 0
    }))

    // singleOrNull 返回符合条件的元素，没有或超过一个则返回null
    println(list.singleOrNull())
    println(list.singleOrNull { it % 9 == 0 }) // 返回第一个符合条件的元素
    println(list.singleOrNull {a -> a % 9 == 0 })
    println(list.singleOrNull {a: Int -> a % 9 == 0 })
    println(list.singleOrNull(fun(a: Int): Boolean{
        return a % 9 == 0
    }))

21、函数定义

Java：

修饰符 返回值类型 方法名([类型 参数]){
    ...
    方法体
    ...
    return 返回值;
}

java的方法必须写在类里：

class Demo{
    public int add(int a,int b){
        return a+b;
    }
}

Kotlin：


fun 函数名([参数:类型]):返回值类型{
    ...
    函数体
    ...
    [return 返回值]
}

如：

fun add(a: Int,b: Int): Int{
    return a + b
}

在Kotlin中无论有多个函数，其中必须要有一个名为main的函数，它是函数的执行入口：

fun main(args: Array<String>) {

    var sum = add(5,6)
    println(sum)
}

fun add(a: Int,b: Int): Int{
    return a + b
}

表达式作为函数体，返回类型自动推断

fun add(a: Int, b: Int): Int = a + b
// 或，不特别指出返回值类型
fun add(a: Int, b: Int) = a + b

参数带默认值的函数

fun main(args: Array<String>) {
    println(add(100))
    println(add(100,c = 200))
}
fun add(a: Int, b: Int = 100): Int{
    return a + b
}

fun add(a: Int, b: Int = 100, c: Int): Int{
    return a + b + c
}

22、可变长参数函数

Java：
在Java中可变参数必须是函数参数的列表的最后一个参数，如：


public class Main {

    public static void main(String[] args) {

        new Demo().showNum("hello world",1,3,4,5,6,75,6);
    }
}

class Demo{
    public void showNum(String name,int ...ts){
     System.out.println(name);
        for (int temp:ts) {
            System.out.println(temp);
        }
    }
}

Kotlin：
在Kotlin中可变参数不必是函数参数列表中的最后一个参数，使用vararg关键字声明可变参数，如：
注意调用方式。

fun main(args: Array<String>) {

    showNum(1,3,4,5,6,75,6,name = "hello world")
}

fun showNum(vararg ts: Int,name: String){
    println(name)
    ts.forEach { println(it) }
}

23、尾递归函数

函数的递归调用，是指在函数体内直接或间接地调用函数本身。但是在Kotlin中，尾递归函数需要使用tailrec修饰符进行标识，并且只有满足所需要格式才可调用其本身。
Java：

public class Main {

    public static void main(String[] args) {

        System.out.println(new Demo().fac(4));
    }
}

class Demo{
   public double fac(int n){
       double t = 1.0;
       if(n == 0 || n == 1){
           t = 1.0;
       }else {
           t = n * fac(n-1);
       }
       return t;
   }
}

Kotlin：

fun main(args: Array<String>) {

    println(fac(4))
}

tailrec fun fac(n: Int): Double{
    var t: Double = 1.0
    if(n == 0 || n == 1){
        t = 1.0
    }else{
        t = n * fac(n -1)
    }
    return t
}

23、高阶函数

将函数用作参数或返回值的函数称为高阶函数。
Java：
java 8引入了函数式编程。函数式编程重点在函数，函数变成了Java世界里的一等公民，函数和其他值一样，可以到处被定义，可以作为参数传入另一个函数，也可以作为函数的返回值，返回给调用者。

public class Main {

    public static void main(String[] args) {

        Lock lock = new ReentrantLock();
        int temp = new Demo().lock(lock,new Function<Integer, Integer>(){

            @Override
            public Integer apply(Integer integer) {
                return 800;
            }
        },800);
        System.out.println(temp);


    }
}

class Demo{
    public  <T,R> R lock(Lock lock, Function<T,R> body,T t){
        lock.lock(); // 锁上
        try {
            return body.apply(t);
        }
        finally {
            lock.unlock(); // 开锁
        }
    }
}

再看一个java8的高阶函数的例子：


public class Main {

    public static void main(String[] args) {

        MyFunction cube = x -> x * x * x;
        System.out.println(new Demo().sum(cube,3));


    }
}

interface MyFunction {
    int action(int a);
}

class Demo{

    public int sum(MyFunction func,int x){
        return func.action(x);
    }
   
}

@FunctionalInterface是Java 8为函数式接口引入的一个新的注解。表明该接口是函数式接口，它只包含唯一一个抽象方法。任何可以接受一个函数式接口实例的地方，都可以用lambda表达式。
**所以可以使用lambda表达式的前提是接口里只有一个抽象方法，如上例。**所以函数式接口都可以用lamda表达式来代替。加了这个注释，你就不会糊涂写多一个抽象方法。以下这些都是比较常用的函数式接口，JDK8提供的：
java.lang.Runnable,
java.awt.event.ActionListener,
java.util.Comparator,
java.util.concurrent.Callable
java.util.function包下的接口，如Consumer、Predicate、Supplier等

Kotlin：

fun main(args: Array<String>) {

    var lock = ReentrantLock() // 获取进入锁
    var temp = lock(lock,fun(): Int{
        return 800
    })
    println(temp)

}



fun <T> lock(lock: Lock,body: () -> T): T{
    lock.lock() // 锁上
    try {
        return body()
    }
    finally {
        lock.unlock() // 开锁
    }
}

24、Lambda表达式

Lambda表达式源于lambda演算。Lambda演算包括一条变换规则（变量替换）和一条函数定义方式。任何一个可计算函数都能用这种形式来表达和求值。Lambda演算强调的是变换规则的运用，而非实现它们的具体机器。Lambda表达式是定义匿名函数的简单形式，Lambda表达式避免了在抽象类和接口中编写明确的函数声明，进而避免了类的实现部分。Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

Java：
语法
java8的lambda 表达式的语法格式如下：

(parameters) -> expression
或
(parameters) ->{ statements; }

示例代码：

public class Main {

    public static void main(String[] args) {

        MyFunction myFunction1 = ((x, y) -> x + y);  // 参数类型可以省略
        System.out.println(myFunction1.sum(5,6));

        MyFunction myFunction2 = (x, y) -> x + y;
        System.out.println(myFunction2.sum(5,7));

        MyFunction myFunction3 = (x, y) -> { return x + y; };  
        System.out.println(myFunction3.sum(5,8));


        MyFunction myFunction4 = (int x, int y) -> x + y;
        System.out.println(myFunction4.sum(5,9));

        MyFunction myFunction5 = ((int x, int y) -> x + y);
        System.out.println(myFunction5.sum(5,10));

        MyFunction myFunction6 = (int x, int y) -> { return x + y; };
        System.out.println(myFunction6.sum(5,11));


        MyFunction2 myFunction21 = () -> System.out.println("Hello");
        myFunction21.hello();

        
        MyFunction3 myFunction31 = (String s) -> System.out.println(s);
        myFunction31.say("Hello world");

        MyFunction3 myFunction33 = s -> System.out.println(s);  //单个参数的，可以不用括号括起来
        myFunction33.say("Hello world 33");

        MyFunction3 myFunction32 = (String s) -> { System.out.println(s); };
        myFunction32.say("Hello world");
    }
}

interface MyFunction {
    int sum(int x, int y);
}
interface MyFunction2{
    void hello();
}
interface MyFunction3{
    void say(String str);
}

Kotlin：
Kotlin中的Lambda表达式总是写在大括号内，在完整的语法形式中，将参数声明放在括号内，并有可选的类型标注，函数体位于“->“符号之后。
在Kotlin中，如果一个函数的最后一个参数是函数，并且传递一个Lambda表达式作为相应的参数，那么可以在括号外指定Lambda表达式中的值：ints.filter { it > 0 }。
如果推断出该Lambda表达式的返回类型不是Unit，那么该Lambda表达式中的最后一个。


fun main(args: Array<String>) {
    // 一般常用的定义形式
    var sum = { x: Int, y: Int -> x + y }
    // 把所有的可选标注都留下，如代码如下
    var sum1: (Int, Int) -> Int = { x, y -> x + y }

    println(sum(5,5))
    println(sum1(10,10))
}

可以使用返回语句返回Lambda表达式的显式带有数据类型的值或者不显示数据类型的值，如下代码都是等价的：


fun main(args: Array<String>) {
    var list = listOf(3,5,6,7)
    println(list.filter { var flag: Boolean = it > 0; flag })
    println(list.filter { var flag = it > 0; flag })
    println(list.filter { var flag = it > 0; return@filter flag })
}

25、匿名函数

Java：
就是Java8的Lambda表达式

public class Main {

    public static void main(String[] args) {

        MyFunction myFunction1 = ((x, y) -> x + y);
        System.out.println(myFunction1.sum(5,6));

        MyFunction myFunction2 = (x, y) -> x + y;
        System.out.println(myFunction2.sum(5,7));

        MyFunction myFunction3 = (x, y) -> { return x + y; };  // 如果方法体要加{}，且有返回值，则要使用return语句，其实省去更方便。
        System.out.println(myFunction3.sum(5,8));


        MyFunction myFunction4 = (int x, int y) -> x + y;
        System.out.println(myFunction4.sum(5,9));

        MyFunction myFunction5 = ((int x, int y) -> x + y);
        System.out.println(myFunction5.sum(5,10));

        MyFunction myFunction6 = (int x, int y) -> { return x + y; };
        System.out.println(myFunction6.sum(5,11));


        MyFunction2 myFunction21 = () -> System.out.println("Hello");
        myFunction21.hello();


        MyFunction3 myFunction31 = (String s) -> System.out.println(s);
        myFunction31.say("Hello world");

        MyFunction3 myFunction33 = s -> System.out.println(s);
        myFunction33.say("Hello world 33");

        MyFunction3 myFunction32 = (String s) -> { System.out.println(s); };
        myFunction32.say("Hello world");
    }
}

interface MyFunction {
    int sum(int x, int y);
}
interface MyFunction2{
    void hello();
}
interface MyFunction3{
    void say(String str);
}

Kotlin：
匿名函数看起来很象一个常规函数的声音有，除其名称活力

fun main(args: Array<String>) {

    println(sum1(8,5))
    println(sum2(8,5))
    println(sum3(8,5))


}

var sum1 = fun(x: Int, y: Int): Int = x + y // 不要加花括号{}
var sum2 = fun(x: Int, y: Int) = x + y // 不要加花括号{} 
var sum3 = fun(x: Int, y: Int): Int { return x + y }  //在函数体中需要一个return

匿名函数的参数总是在括号内传递的，允许将函数留在括号外传递仅适用于Lambda表达式。不带标签的return语句总是在使用fun关键字声明的函数中返回。意味着Lambda表达式中的return将从包含它的函数返回，而匿名函数中的return将从匿名函数自身返回。

26、内联函数

调用某个函数或方法是将程序执行顺序转移到内存中存放该函数的地址，该函数执行完后，再返回执行该函数前面的代码。这种转移操作要求在转去前要保护现场并记忆执行的地址，转回后要恢复现场，并按原来保存的地址继续执行。这就是所谓的压栈和出栈。因此函数调用会有一定时间和空间的开销，如果频繁地调用的话，这个时间和空间的开销会很大。解决性能消耗问题需要引入内联函数，在编译程序时，编译器将程序中出现的内联函数调用表达式用它的函数体中的代码直接进行替换，提供给主函数运行，因此会增加目标程序的代码量，在时间开销上，没有函数调用时大，它是以目标代码的增加为代价来换取时间的。
Java：
Java中定义内联函数的方法就是使用final修饰。

public final void a(){
    statement
}

注：final关键字只是告诉编译器，在编译的时候考虑性能的提升，可以将final函数视为内联函数。但最后编译器会怎么处理，编译器会分析将final函数处理为内联和不处理为内联的性能，然后再做决定。程序员只有建议权而没有决定权。

Kotlin：
在Kotlin中使用inline修饰符标识内联函数。使用内联函数既会影响函数本身，也会影响传递给它的Lambda表达式，这两者都会被内联到调用处。


fun main(args: Array<String>) {


    var lock = ReentrantLock()
    println(lock<Int>(lock){ 88 })

}

inline fun <T> lock(lock: Lock, body: () -> T): T{
    lock.lock()
    try {
        return body()
    }
    finally {
        lock.unlock()
    }
}

27、类

Java：

class MyClass{} // 简单的类

Kotlin：
Kotlin通过class关键字来声明类，类由构造函数和初始化模块、函数、属性、嵌套类和内部类、对象声明5部分组成。

class MyClass{} // 简单的类
class MyAnotherClass   // 仅有类的骨架，而没有什么功能实现

28、类的成员属性

Java：
java的访问修饰符：public、protected、private，也可以缺省（即不带访问修饰符）。

修饰符 可见性
public 所有可见
protected 在子类可见、同一包中的类可见、本类内可见
private 类内部可见
default(缺省) 同一包中的类可见、本类内可见

java没有存储类型修饰符。
定义成员变量：

关键词  数据类型 成员变量名 = 默认值

private String name = "Tome";

Kotlin：
类的变量称为成员变量，必须在使用前声明，要声明数据类型、访问属性、存储方式。
访问修饰符：public、protected、private、internal，也可以缺省（即不带访问修饰符）
存储类型修饰符：open、override、const。

修饰符 可见性
public（默认） 所有可见
protected 在子类可见
private 类内部可见
internal 模块可见

被open修饰的成员变量，表示该成员变量可以被继承，否则不能被继承。
被const修饰的成员变量称为常成员变量。
在kotlin中，类中的方法也是final类型，是不能被重写的，也需在方法前面加上open关键字后才可以；子类要重写父类中open修饰的方法，需在子类的方法前面加override关键字。

定义成员变量：

关键词  成员变量名[数据类型] = 默认值

private var name: String = "Tome"

访问方法：
对象名.成员变量

29、成员方法

Java：
访问修饰符：public、protected、private、也可以缺省（即不带访问修饰符）
存储类型修饰符：没有

   public int sum(int x, int y){
      return x + y;
     }

Kotlin：
函数与成员方法的唯一区别就是函数实现的是某个苳的功能，而成员方法实现的是类的行为，是类的一部分。
访问修饰符：public、protected、private、internal，也可以缺省（即不带访问修饰符）
存储类型修饰符：open、override。
定义成员方法：

fun 方法名 (属性列表) {  方法体  }

如果一个类中的成员方法没有加任何修饰符，那么该方法就是final类型的，这种方法默认不允许被子类继承的。如果允许被子类继承，那么需要在该类的方法前加open修饰符。
demo：


    fun sum(x: Int, y: Int): Int{
        return x + y
    }

注意：所有没有加存储类型修饰符的class、成员变量、成员方法默认都是final的不能被继承的，如果class要被继承，首先应该用open修饰，如：

open class MyClass{}

然后，允许被继承的成员变量、成员方法都要用open修饰。

30、构造函数

Java：

class Student {
    private String username = "";
    private String hobby = "";

    public Student() {
    }

    public Student(String username, String hobby) {
        this.username = username;
        this.hobby = hobby;
    }
}

Kotlin：
当我们定义一个类时，如果没有为其显式提供Primary Constructor，Kotlin编译器会默认为其生成一个无参主构造函数，这点和Java是一样的。
Kotlin的构造函数分为主构造器（primary constructor）和次级构造器（secondary constructor），次级构造器可以有多个：

class 类名 constructor(形参1, 形参2, 形参3){}


class Student constructor(username: String, hobby: String){
     var username: String = ""
     var hobby: String = ""

    init{
        this.username = username
        this.hobby = hobby
    }
}

关键字constructor：在Java中，构造方法名须和类名相同；而在Kotlin中，是通过constructor关键字来标明的，且对于Primary Constructor而言，它的位置是在类的首部（class header）而不是在类体中（class body）。
关键字init：init{}它被称作是初始化代码块（Initializer Block），它是为Primary Constructor服务的，由于Primary Constructor是放置在类的首部，是不能包含任何初始化执行语句的，这是语法规定的，那么这个时候就有了init的用武之地，我们可以把初始化执行语句放置在此处，为属性进行赋值。

当constructor关键字有注解或可见性修饰符作用于它时，constructor关键字是不可以省略，如：

 class Student private constructor(username: String, hobby: String){
     var username: String = ""
     var hobby: String = ""

    init{
        this.username = username
        this.hobby = hobby
    }
     constructor(name: String): this(name,"tennis"){
         println("我是次构造函数")
     }
}

当constructor关键字没有注解和可见性修饰符作用于它时，constructor关键字可以省略,那么上面的代码就变成:

class Student (username: String, hobby: String){
     var username: String = ""
     var hobby: String = ""

    init{
        this.username = username
        this.hobby = hobby
    }
}

初始化执行语句不是必须放置在init块中的，我们可以在定义属性时直接将主构造器中的形参赋值给它。

class Student constructor(username: String, hobby: String){
     var username: String = username
     var hobby: String = hobby
}
或
class Student (username: String, hobby: String){
     var username: String = username
     var hobby: String = hobby
}

这种在主构造器中声明形参，然后在属性定义进行赋值，还可以进一步简化：我们可以直接在Primary Constructor中定义类的属性：

 class Student constructor(public var username: String, public var hobby: String){}
 或
 class Student (public var username: String, public var hobby: String){}

如果类不包含其他操作函数，那么连花括号也可以省略:

 class Student constructor(public var username: String, public var hobby: String)
  或
 class Student (public var username: String, public var hobby: String)

和主构造函数相比，很明显的一点，次级构造函数是定义在类体中。次级构造函数可以有多个，而主构造函数只会有一个。
我们可以使用this关键字来调用自己的其他构造函数，它的语法形式，次级构造器: this(参数列表)
可以使用super关键字来调用父类构造器，它的语法形式，次级构造器: super(参数列表)。：

class Student constructor(username: String, hobby: String){
     var username: String = ""
     var hobby: String = ""

    init{
        this.username = username
        this.hobby = hobby
    }
     constructor(name: String): this(name,"tennis"){
         println("我是次构造函数")
     }
}
或
class Student (username: String, hobby: String){
     var username: String = ""
     var hobby: String = ""

    init{
        this.username = username
        this.hobby = hobby
    }
     constructor(name: String): this(name,"tennis"){
         println("我是次构造函数")
     }
}

31、继承

Java：
只支持单继承

// 父类
class Base{
    public Base(){}
    public Base(String name){}
}
// 子类
class SonClass1 extends Base {
    public SonClass1(){
        super();
    }
    public SonClass1(String name){
        super(name);
    }
}

Kotlin：
只支持单继承
在Kotlin中每一个类都有一个共同的父类Any，没有显示声明父类的话Any就是它的默认父类。Any中只有 equals()、hashCode()和toString():

public open class Any {

    public open operator fun equals(other: Any?): Boolean

    public open fun hashCode(): Int

    public open fun toString(): String
}

继承一个父类使用冒号来表示，如果子类有主构造函数，父类则必须使用主构造函数初始化：


// 父类
open class Base(name: String){

    constructor(name: String, age: Int): this(name)
    constructor(name: String, age: Int, sex: String):this(name)

    ...
}

class SonClass1(name: String): Base(name){...}
class SonClass2(name: String, age: Int, hobby: String): Base(name){...}

如果子类没有主构造函数，子类的次构造函数都必须绑定父类的构造函数（主次都行）。可以绑定同一个，也可以不同：

// 父类
open class Base(name: String) {

    constructor(name: String, age: Int) : this(name)
    constructor(name: String, age: Int, sex: String) : this(name)


}
// 子类
class SonClass1 : Base {

    constructor(name: String) : super(name) {}
    constructor(name: String, age: Int) : super(name, age) {}
    constructor(name: String, age: Int, sex: String) : super(name) {}
}

如果父类没有定义构造方法时，我们要初始化它的默认主构造方法：

// 父类
open class Base{}
// 如果子类有定义构造函数，则在构造函数绑定父类的默认构造函数
class SonClass1: Base {

    constructor(name: String) : super() {}
    constructor(name: String, age: Int) : super() {}
    constructor(name: String, age: Int, sex: String) : super() {}
}

// 如果子类没有定义构造函数，则在类头绑定父类的默认构造函数
class SonClass2: Base() {}

32、覆盖方法、属性、规则

Java：
覆盖方法：

// 父类
class Base{
    public void method(){}
}

// 子类
class Example extends Base{
    @Override
    public void method() {
        super.method();
    }
}

覆盖属性：
java只是在子类重新定义属性。

// 父类
class Base{
    public boolean attr = false;
}

// 子类
class Example extends Base{
   public boolean attr = true;
}

覆盖规则

// 接口
interface BaseInterface {
    public void method();

    default public void method1() {
        System.out.println("BaseInterface::method1:hello");
    }

    static public void method2() {
        System.out.println("BaseInterface::method2:hello");
    }

}

// 父类
class Base {
    public void method() {
        System.out.println("Base::Hello");
    }
}

// 子类
class Example extends Base implements BaseInterface {

    @Override
    public void method() {
        this.method1();
        BaseInterface.method2();
        super.method();
    }

}

Kotlin：
Kotlin中，只有被open 标注的成员才可以被覆盖，且覆盖后的成员必须用 override 标注。否则编译将失败。

override标注的成员也可以被覆盖，如果不想再被覆盖的话使用 final 修饰：

final  override var a = ..

覆盖方法：

// 父类
open class Base{
    open fun method(){}
}

// 子类
class Example: Base(){
    override fun method() {
        super.method()
    }
}

覆盖属性：

覆盖属性与覆盖方法类似。可以用 val 修饰的属性覆盖 var 修饰的属性，但是不可以用 var 修饰的属性去覆盖 val 。因为一个 val 属性本质上声明了一个 getter 方法，而将其覆盖为 var 只是在子类中额外声明一个 setter 方法。

//父类
open class Base {
   open var attr: Boolean = false
}   

//子类
class Example : Base() {
    override var attr: Boolean = true
}

也可以在主构造函数中去覆盖属性

// 子类
class Example(override var attr: Boolean): Base(){}

覆盖规则：
子类继承父类并实现了接口时，如果有相同的函数时我们可以使用super< ? >指定要调用的父类或接口的函数


// 接口
interface BaseInterface{
    public fun method(){
        println("BaseInterface::method:hello")
    }
    public fun method1()
}
// 父类
open class Base{
    open fun method(){
        println("Base::Hello")
    }
}

// 子类
class Example: Base(),BaseInterface{
    override fun method1() {
        println("BaseInterface::method1:Hello")
    }

    override fun method() {
        super<BaseInterface>.method()
        super<Base>.method()
    }
}

33、内部类与嵌套类

Java：

public class Main {

    public static void main(String[] args) {

        OutterClass.NestedClass nestedclass = new OutterClass.NestedClass();
        nestedclass.method();
        OutterClass outterClass = new OutterClass();
        outterClass.method();

    }
}


class OutterClass {
    static class NestedClass { // 静态内部类，不仅可以在内部使用，还可以在外部使用
        public void method() {
            System.out.println("NestedClass::Method:Hello");
        }
    }

    class InnerClass {  // 内部类只能在内部使用
        public void  method(){
            System.out.println("InnerClass::Method:Hello");
        }

    }

    public void method() {
        InnerClass innerClass = new InnerClass();
        innerClass.method();
    }

}

Kotlin：


fun main(args: Array<String>) {

    var nestedclass = OutterClass.NestedClass()
    var outterClass = OutterClass()
    outterClass.method()
}

class OutterClass{
    class NestedClass{ // 嵌套类，不仅可以在内部使用，还可以在外部使用，类似于Java的静态内部类
        fun method(){
            println("NestedClass::Method:Hello")        }
    }


    inner class InnerClass{  // 内部类只能在内部使用
        fun method() = println("InnerClass::Method:Hello")
    }

    fun method(){
        var innerClass = InnerClass()
        innerClass.method()
    }

}

34、匿名内部类

Java：
所谓的匿名内部类就是一个没有显式的名字的内部类，匿名内部类会隐式的继承一个类或者实现一个接口，或者说，匿名内部类是一个继承了该类或者实现了该接口的子类匿名对象。

public class Main {

    public static void main(String[] args) {

        Example example = new Example();
        example.testInterface(new BaseInterface() { // 利用接口产生匿名类
            @Override
            public void method() {
                System.out.println("Test Test Test Interface");
            }
        });

        example.testInterface(()-> System.out.println("Test Test Test Lambda")); // 使用Lambda表达式产生匿名类

        example.testAbstractClass(new Base() { // 利用抽象类来创建匿名类
            @Override
            public void method() {
                System.out.println("Test Test Test abstract class");

            }
        });


    }
}

interface BaseInterface{
    public void method();
}

abstract class Base{
    abstract public void method();
}

class Example{
    public void testInterface(BaseInterface baseInterface){ // 利用接口产生匿名类
        baseInterface.method();
    }
    public void testAbstractClass(Base base){  // 利用抽象类来创建匿名类
        base.method();
    }
}

Kotlin：


fun main(args: Array<String>) {
    val example = Example()
    example.testInterface(object : BaseInterface { // 利用接口产生匿名类
        override fun method() {
            println("Test Test Test Interface")
        }
    })


    example.testAbstractClass(object : Base(){ // 利用抽象类产生匿名类
        override fun method() {
            println("test test abstract class ")
        }

    })


    example.test { println("I am just fun ") }


}

interface BaseInterface {
    fun method()
}

abstract class Base {
    abstract fun method()
}

class Example {
    fun testInterface(baseInterface: BaseInterface): Unit { // 利用接口产生匿名类
        baseInterface.method()
    }

    fun testAbstractClass(base: Base) {  // 利用抽象类来创建匿名类
        base.method()
    }

    fun test(body: ()->Unit){
        body()
    }
}

35、数据类

Java：
在java中的数据类其实就是一般说的实体类、Bean类：

class MyData{
    private int id;
    private String name;
    private String dec;

    public String getDec() {
        return dec;
    }

    public void setDec(String dec) {
        this.dec = dec;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

Kotlin：
Kotlin 可以创建一个只包含数据的类，关键字为 data，格式如下：

data class 类名(属性列表)

一般数据类中不应该有方法，所以将变量放在属性列表中，把大括号去掉，如：

data class MyData(var id: Int = 0, var name: String? = null, var dec: String? = null)

运行实例如下：

fun main(args: Array<String>) {

    val myData = MyData(10,"Tom","an engineer")
    println("${myData.name} is ${myData.dec}")

}

36、枚举类

Java：
Java中的枚举类用enum代替class声明,每一个枚举值对应一个类的实例


public class Main {

    public static void main(String[] args) {

        System.out.println(ServerState.BAD_GATEWAY);
        System.out.println(ServerState.BAD_GATEWAY.getCode());
        System.out.println(ServerState.BAD_GATEWAY.getMsg());
        System.out.println(ServerState1.BAD_GATEWAY);
    }
}

enum ServerState{
    ERROR_SERVER(500, "服务器异常"),
    BAD_GATEWAY(502, "服务器异常"),
    NOT_SERVER(404, "页面不存在"),
    TOKEN_INVALID(40101, "登录状态失效"),
    ERROR_PROXY_FIDDLER(502, "fiddler代理失败");   // 必须提供相应的构造函数，才能构造这种类型的枚举

    private int code;
    private String msg;

    ServerState(int code,String msg){  // 构造函数默认是private的
        this.code = code;
        this.msg = msg;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

enum ServerState1{
    ERROR_SERVER,
    BAD_GATEWAY,
    NOT_SERVER,
    TOKEN_INVALID,
    ERROR_PROXY_FIDDLER;

    // 有默认的构造方法 private ServerState1(){}
}

Kotlin：

枚举类最基本的用法是实现一个类型安全的枚举。
枚举常量用逗号分隔,每个枚举常量都是一个对象。


fun main(args: Array<String>) {


    println(ServerState.BAD_GATEWAY)
    println(ServerState.BAD_GATEWAY.code)
    println(ServerState.BAD_GATEWAY.msg)
    println(ServerState1.BAD_GATEWAY)

    println(ServerState.valueOf("ERROR_SERVER"))
    val serverStates = ServerState.values()
    println("####")
    for (serverState in serverStates) {
        println(serverState)
    }
}

// 必须提供相应的构造函数，才能构造这种类型的枚举
enum class ServerState private constructor(var code: Int, var msg: String?)// 构造函数默认是private的
{
    ERROR_SERVER(500, "服务器异常"),
    BAD_GATEWAY(502, "服务器异常"),
    NOT_SERVER(404, "页面不存在"),
    TOKEN_INVALID(40101, "登录状态失效"),
    ERROR_PROXY_FIDDLER(502, "fiddler代理失败")
}

internal enum class ServerState1 {
    ERROR_SERVER,
    BAD_GATEWAY,
    NOT_SERVER,
    TOKEN_INVALID,
    ERROR_PROXY_FIDDLER

    // 有默认的构造方法 private ServerState1(){}
}

37、密封类

Java：
Java里没有这个概念。
Kotlin：
密封类需要使用sealed关键字修饰，并且被sealed关键字修饰的类，它的子类必须要以嵌套类的形式在父类中全部声明。
sealed 不能修饰 interface ,abstract class(会报 warning,但是不会出现编译错误)

fun main(args: Array<String>) {

    var sonClass1 = SealedClass.SonClass1()
    println(check(sonClass1))
}

sealed class SealedClass {
    class SonClass1 : SealedClass() {}

    class SonClass2 : SealedClass() {}

    class SonClass3 : SealedClass() {}
}


fun check(sealedClass: SealedClass): Int =
    when (sealedClass) {
        is SealedClass.SonClass1 -> 1
        is SealedClass.SonClass2 -> 2
        is SealedClass.SonClass3 -> 3
    }

再来看多一个密封类的实例：

sealed class Expr // 密封类

data class Const(val number: Double) : Expr() // 密封类的子类
data class Sum(val e1: Expr, val e2: Expr) : Expr() // 密封类的子类
object NotANumber : Expr() // 密封类的子类

fun eval(expr: Expr): Double = when(expr){
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
}

fun main(args: Array<String>) {

    val constVar = Const(888.0)
    println(eval(constVar))
    val sumVar = Sum(Const(10.0), Const(10.0))
    println(eval(sumVar))

}

38、对象表达式

Java：
没有
Kotlin：
通过object来声明。

interface BaseInterface {
    public fun method()
}

abstract class Base {
    public abstract fun method()
}

fun invokeMe(inter: BaseInterface) {
    inter.method()
}

fun invokeA(base: Base){
    base.method()
}

fun main(args: Array<String>) {
    // 对象表达式
    invokeMe(object : BaseInterface { // 通过对象表达式实现一个匿名内部类的对象用于方法的参数中
        override fun method() {
            println("BaseInterface::Hello Object")
        }

    })
    // 对象表达式
    invokeA(object :Base(){  // 通过对象表达式实现一个匿名内部类的对象用于方法的参数中
        override fun method() {
            println("Base::Hello Object")

        }

    })

}

如果仅需要一个对象来包住某些东西如变量和一些方法的话，可以这样做：


fun main(args: Array<String>) {

    // 对象表达式
    var myObject = object {
        var name: String = "wongkyunban"
        var height: Int = 180
        fun sayHi(){
            println("Hello,everyone,I am $name")
        }
    }
    println(myObject.name)
    println(myObject.sayHi())
  }

对象可以继承于某个基类，或者实现其他接口:

// 如果对于将要创建的类实例，与类模板有一些细小的差别，又不想继承这个类，在子类里重写有差别的部分，可以通过对象表达式来完成。如

public open class A(x: Int){
    public open var x: Int = x
    public open var name: String = "AAA"
    fun hi(){
        println("hi,$name,$x")
    }

}

interface AA{

    fun speak(str: String){
        println(str)
    }

    fun haha(){
        println("haha")
    }

}
fun main(args: Array<String>) {

    var myA = object: A(10),AA{ // 如果超类有构造函数，几必须传递适当的参数给它,后面只能跟一个类，其他的都是接口
        override var name: String = "Wongkyunban"  // 这就是我将要将创建的对象与类有区别的地方，如果继承重写的话，代码就要写很多，也比较不方便

        override fun speak(str: String) {
            println("I am $str")
        }
    }
    myA.hi()
    myA.speak("Chinese")

}

39、单例类

Java：

// 懒汉式
public class LazySingleton {
    private static LazySingleton singleton = null;

    private LazySingleton() {
    }

    public static LazySingleton getSingleton() {
        if (singleton == null) singleton = new LazySingleton();
        return singleton;
    }
}

// 饿汉式
class HungrySingleton {
    private static HungrySingleton ourInstance = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return ourInstance;
    }


}

Kotlin：
在Kotlin中使用单例模式来声明一个对象会变得更加容易。声明对象和声明变量一样，对象声明并不是一个表达式，所以不能使用赋值语句进行赋值操作。对象声明一般是在object后面加上对象名称。

class Student()
object Singleton{
    var all = arrayListOf<Student>()
    fun show(){
        for (student in all){
            println(student.toString())
        }
    }
}

fun main(args: Array<String>) {

    Singleton.all.add(Student())
    Singleton.all.add(Student())
    Singleton.all.add(Student())

    Singleton.show()
}

40、顶层函数

在Kotlin文件里直接定义的函数就是顶层函数，它不是定义在类中的。

41、中缀调用

如下列中的to就是中缀调用。

    var map1: Map<String, String> = hashMapOf("key1" to "value1","key2" to "value2")
    // 与下面是等价
    var map1: Map<String, String> = hashMapOf("key1".to("value1"),"key2".to("value2"))

它的原型是这样的：

public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

42、伴生对象

Java：

Kotlin：
Kotlin中的类不能有静态成员，Java中的static关键字不属于Kotlin的一部分。虽然Kotlin可以通过包 函数和对象声明来实现static功能。 在大多数情况下，使用顶层函数，但是顶层函数不能访问类中的private成员。
Kotlin允许在类中使用 companion object创建伴生对象，用伴生对象的成员来代表Kotlin中的静态成员。伴生对象看起来就像Java中的静态成员。

class A{
    companion object MyFactory{
        fun create(): A = A()
        fun bye(){
            println("Bye Bye")
        }
     const val TAG: String = "A"

    }

    fun show(){
        println("Hello world AAA")
    }
}

fun main(args: Array<String>) {

    var a = A.create()
    a.show()
    A.bye()
    A.MyFactory.bye()
    println(A.tag)
}

在使用companion关键字时，伴生对象的名称可以省略不写，因此上面的代码可以改成：

class A{
    companion object {
        fun create(): A = A()
        fun bye(){
            println("Bye Bye")
        }
        const val TAG: String = "A"

    }

    fun show(){
        println("Hello world AAA")
    }
}

fun main(args: Array) {

    var a = A.create()
    a.show()
    A.bye()
    println(A.TAG)
}

伴生对象还可以实现接口：

interface BaseFactory<T>{
    fun myCreate(): T
}

class A{
    companion object: BaseFactory<A> {
        override fun myCreate(): A = A()
        
        fun bye(){
            println("Bye Bye")
        }
        const val TAG: String = "A"

    }

    fun show(){
        println("Hello world AAA")
    }
}

fun main(args: Array<String>) {

    var a = A.myCreate()
    a.show()
    A.bye()
    println(A.TAG)
}

43、泛型类

泛型，即 “参数化类型”，将类型参数化，可以用在类，接口，方法上。提高代码的重用性和程序安全性。
与 Java 一样，Kotlin 也提供泛型，为类型安全提供保证，消除类型强转的烦恼。
泛型类的声明和非泛型类的声明类似，泛型接口只是多了在类名后面添加了类型参数声明部分
Java：

// 声明一个泛型类
class Box<T> {

    private T t;

    public void add(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

public class Main {

    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.add("Hello world");
        System.out.println(stringBox.get());
    }
}

Kotlin：

// 声明一个泛型类
class Box<T> {

    private var t: T? = null

    fun add(t: T) {
        this.t = t
    }

    fun get(): T? {
        return t
    }
}

fun main(args: Array<String>) {
    val stringBox = Box<String>()
    stringBox.add("Hello world")
    println(stringBox.get())
}

44、泛型接口

泛型接口的声明和非泛型接口的声明类似，泛型接口只是多了在接口名后面添加了类型参数声明部分
Java：

// 声明一个泛型接口

interface Base<T>{
    void add(T t);
}
public class Main {

    public static void main(String[] args) {

       Base<String> stringBase = new Base<String>() {
           @Override
           public void add(String s) {
               System.out.println(s);
           }
       };
       stringBase.add("add Hello world");

    }
}

Kotlin：

// 声明一个泛型接口

interface Base<T> {
   fun add(t: T)
}

fun main(args: Array<String>) {
   val stringBase = object : Base<String> {
       override fun add(s: String) {
           println(s)
       }
   }
   stringBase.add("add Hello world")
}

45、泛型方法

泛型方法的声明和非泛型方法的声明类似，泛型方法只是多了在方法名前面添加了类型参数声明部分
Java：

// 声明一个泛型方法

class Base{
    public <T> void show(T t){
        if( t instanceof String){
            System.out.println(t);
        }
    }

    public <T> T get(T t){
        return t;
    }
}

public class Main {

    public static void main(String[] args) {

       Base base = new Base();
       System.out.println(base.get(9999));
       base.show("Hello world 999");

    }
}

Kotlin：

// 声明一个泛型方法

fun <T> show(t: T) {
    if (t is String) {
        println(t)
    }
}

fun <T> get(t: T): T {
    return t
}

fun main(args: Array<String>) {
    show("Hello world 999")
    println(get(8888))
}

46、泛型中的通配符

Java：
当操作的不同容器中的类型都不确定的时候，而且使用的元素都是从Object类中继承的方法，这时泛型就用通配符“?”来表示。泛型的通配符：“？” 相当于 “？ extends Object”，如：

        //使用通配符
        ArrayList<?> arr2;
        arr2 = new ArrayList<String>();
        arr2 = new ArrayList<Integer>();

Kotlin：
在Kotlin里是用*号

    //使用通配符
    var arr2: ArrayList<*>
    arr2 = ArrayList<String>()
    arr2 = ArrayList<Int>()

47、泛型限定

Java：
泛型限定就是对操作的数据类型限定在一个范围之内。限定分为上限和下限。
上限：？ extends E 接收E类型或E的子类型
下限：？ super E 接收E类型或E的父类型
限定用法和泛型方法，泛型类用法一样，在“<>”中表达即可。
一个类型变量或通配符可以有多个限定，多个限定用“&”分隔开，且限定中最多只能有一个类，但可以有多个接口；如果有类限定，类限定必须放在限定列表的最前面。如：T extends MyClass1 & MyInterface1 & MyInterface2

// 声明一个泛型限定  ? super  和 ？ extends

class Base{}
class SonClass extends Base{}

class Demo1 {
   public static <T> void copy(List<? super T> dest, List<? extends T> src) {
       int srcSize = src.size();
       if (srcSize > dest.size())
           throw new IndexOutOfBoundsException("Source does not fit in dest");

       for (int i = 0; i < srcSize; i++) {
           dest.add(i,src.get(i));
       }

   }
}

public class Main {

   public static void main(String[] args) {
       List<Base>  list1 = new ArrayList<>();
       list1.add(new Base());
       list1.add(new Base());

       // 或  因为 Object是Base的父类
//        List  list1 = new ArrayList<>();
//        list1.add(new Base());
//        list1.add(new Base());

       List<SonClass>  list2 = new ArrayList<>();
       list2.add(new SonClass());
       list2.add(new SonClass());
       Demo1.copy(list1,list2);
       for (Base son: list1) {
           if(son instanceof SonClass){
               System.out.println("SonClass");
           }
       }
   }
}

 
  
Kotlin：
 Kotlin 中使用 : 对泛型的的类型上限进行约束。最常见的约束是上限(upper bound)，默认的上界是 Any?，对于多个上限约束条件，可以用 where 子句(在Java中使用&)：
 
  
fun <T> copyWhenGreater(list: List<T>, threshold: T): List<String>
    where T : CharSequence,
          T : Comparable<T> {
    return list.filter { it > threshold }.map { it.toString() }
}

 
  
上面Java代码对应的Kotlin泛型限定如下：
 
  

// 声明一个泛型限定  ? super  和 ？ extends

open class Base

class SonClass : Base()

object Demo1 {
    fun <T> copy(dest: MutableList<in T>, src: List<T>) {
        val srcSize = src.size
        if (srcSize > dest.size)
            throw IndexOutOfBoundsException("Source does not fit in dest")

        for (i in 0 until srcSize) {
            dest.add(i, src[i])
        }

    }
}
fun main(args: Array<String>) {


    val list1 = ArrayList<Base>()
    list1.add(Base())
    list1.add(Base())


    // 或  因为 Object是Base的父类
//        List  list1 = new ArrayList<>();
//        list1.add(new Base());
//        list1.add(new Base());


    val list2 = ArrayList<SonClass>()

    list2.add(SonClass())
    list2.add(SonClass())

    Demo1.copy(list1, list2)

    for (son in list1) {
        if (son is SonClass) {
            println("SonClass")
        }

    }

}

 
  
Kotlin 中没有通配符类型，它有两个其他的东西：声明处型变（declaration-site variance）与类型投影（type projections）。
 
  
声明处型变
 声明处的类型变异使用协变注解修饰符：in、out，消费者 in, 生产者 out。
 使用 out 使得一个类型参数协变，协变类型参数只能用作输出，可以作为返回值类型但是无法作为入参的类型。
 
  
class Boob<out T>(val a: T) {
    fun foo(): T {  // T能作为返回值类型，但不能作为入参类型
        return a
    }

   // T不能作为入参类型，所以以下函数是错误的 
   // fun foo(b: T) {}
    
}

fun main(args: Array<String>) {
    var strBo: Boob<String> = Boob<String>("Hello")
    var anyBo: Boob<Any> = Boob<Any>("world")
    // 如果Boob类不支持型变，就会报如下错：
    // Type mismatch
    // Required:Boob
    // Found:   Boob
    anyBo = strBo  
    println(anyBo.foo())
}

 
  
in 使得一个类型参数逆变，逆变类型参数只能用作输入，可以作为入参的类型但是无法作为返回值的类型。它使得一个类型参数逆变。
 
  

class Boob<in T>(a: T) {
    // T不能作为返回值类型
//    fun foo(): T { 
//        return a
//    }

   // T能作为入参类型，但不能作为返回值类型
    fun foo(b: T) {}

}

fun main(args: Array<String>) {
    var strBo: Boob<String> = Boob<String>("Hello")
    var anyBo: Boob<Any> = Boob<Any>("world")
    strBo = anyBo
}

 
  
48、kotlin 委托
 
  
委托模式是软件设计模式中的一项基本技巧。在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。
 
  
Kotlin 直接支持委托模式，更加优雅，简洁。Kotlin 通过关键字 by 实现委托。
 
  
类委托
 类的委托即一个类中定义的方法实际是调用另一个类的对象的方法来实现的。
 
  

// 创建接口
interface Base{
    fun print()
}

// 实现接口
class BaseImpl(val x: Int):Base{
    override fun print() {
        println(x)
    }

}

// 通过by关键字建立委托类
class Entrust(b: Base):Base by b   //by 子句表示，将 b 保存在 Entrust的对象实例内部，而且编译器将会生成继承自 Base 接口的所有方法, 并将调用转发给 b

fun main(args: Array<String>) {
    val b = BaseImpl(100)
    var byClass = Entrust(b)
    byClass.print()
}


 
  
属性委托
 属性委托指的是一个类的某个属性值不是在类中直接进行定义，而是将其托付给一个代理类，从而实现对该类的属性统一管理。
 属性委托语法格式：
 
  
// 表达式指的是委托代理类
val/var <属性名>: <类型> by <表达式>

 
  
by 关键字之后的表达式就是委托, 属性的 get() 方法(以及set() 方法)将被委托给这个对象的 getValue() 和 setValue() 方法。属性委托不必实现任何接口, 但必须提供 getValue() 函数(对于 var属性,还需要 setValue() 函数)。
 
  
// 委托的类
class Entrust{

    // 重载操作符的函数需要用operator关键字标记


    // thisRef参数用于读出p的对象，property参数保存了对p自身的描述，如可取它的名字
    // thisRef参数类型必须与属性的所有者的类型相同或是它的超类型
    // property参数类型必须是KProperty<*>或是它的超类型
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String{
        return "$thisRef, 这里委托了 ${property.name} 属性"
    }

    // thisRef参数用于读出p的对象，property参数保存了对p自身的描述，如可取它的名字，value参数保存了将要被赋予的值
    // thisRef参数类型必须与属性的所有者的类型相同或是它的超类型
    // property参数类型必须是KProperty<*>或是它的超类型
    // value参数类型必须与属性的类型相同或是它的超类型
    operator fun setValue(thisRef: Any?,property: KProperty<*>,value: String){
        println("$thisRef 的 ${property.name} 属性赋值为 $value")
    }
}


// 定义包含属性委托的类
class Example{
    var p: String by Entrust()
}
fun main(args: Array<String>) {
    val e = Example()
    // 当我们从委托到一个Entrust实例的p读取时，将调用Entrust中的getValue()方法
    println(e.p)

    // 当给p赋值时，将调用Entrust中的setValue()方法

    e.p = "Hello world"
    println(e.p)
}

 
  
49、标准委托
 
  
Kotlin 的标准库中已经内置了很多工厂方法来实现属性的委托。
 延迟属性 Lazy
 lazy() 函数接受一个 Lambda 表达式作为参数, 返回一个 Lazy 实例，返回的实例可以作为实现延迟属性的委托： 第一次调用 get() 会执行已传递给 lazy() 的 lamda 表达式并记录结果， 后续调用 get() 只是返回记录的结果。
 
  

fun main(args: Array<String>) {
    val lazyValue: String by lazy {
        println("computed!")     // 第一次调用输出，第二次调用不执行
        "Hello world"
    }

    println(lazyValue)
    println(lazyValue)
}


 
  
可观察属性 Observable
 observable 可以用于实现观察者模式。
 Delegates.observable() 函数接受两个参数: 第一个是初始化值, 第二个是属性值变化事件的响应器(handler)。
 在属性赋值后会执行事件的响应器(handler)，它有三个参数：被赋值的属性、旧值和新值：
 
  
    var name: String by Delegates.observable("Hello"){
        prop,old,new ->
        println("old value:$old -> new value:$new")
    }

    name = "I Love the world"
    name = "I am coming"

 
  
把属性储存在映射中
 一个常见的用例是在一个映射（map）里存储属性的值。 这经常出现在像解析 JSON 或者做其他"动态"事情的应用中。 在这种情况下，可以使用映射实例自身作为委托来实现委托属性。
 
  
fun main(args: Array<String>) {

    // 构造函数接受一个映射参数
    val site = Site(mapOf(
        "name" to "百度",
        "url"  to "www.baidu.com"
    ))

    println(site.name)
    println(site.url)

}

class Site(val map: Map<String,Any?>){
    val name: String by map
    val url: String by map
}
//  不是每个实例自身都可以作为委托来实现委托属性，如下代码，因为Int类型没有getValue(MySite, 
// KProperty<*>)' method on delegate of type 'Int'，所以它不能拿来委托
// class MySite(val a: Int){
//    val b: Int by a
//}



 
  
Not Null
 notNull 适用于那些无法在初始化阶段就确定属性值的场合。
 
  
class Demo{
    var notNullValue: String by Delegates.notNull<String>()
}

fun main(args: Array<String>) {

      var demo = Demo()

    // println(demo.notNullValue)  如果属性在赋值前就被访问的话则会抛出异常

    demo.notNullValue = "Hello world"

    println(demo.notNullValue)


}

 
  
50、局部委托属性
 
  
可以将局部变量声明为委托属性
 
  

class Foo {
    fun doAction() {
        println("hello world")
    }
}

fun foo(add: () -> Foo) {
    //memoizedFoo 变量只会在第一次访问时计算
    val memoizedAddFunc by lazy(add)
    memoizedAddFunc.doAction()
}

fun main(args: Array<String>) {


    foo { Foo() }

}

 
  
51、翻译规则
 
  
在每个委托属性的实现的背后，Kotlin 编译器都会生成辅助属性并委托给它。 例如，对于属性 prop，生成隐藏属性 prop$delegate，而访问器的代码只是简单地委托给这个附加属性：
 
  
class Example{
    var prop: String by Entrust()
}

// 这段是由编译器生成的相应代码：
class Example {
    private val prop$delegate = Entrust()
    var prop: String
        get() = prop$delegate.getValue(this, this::prop)
        set(value: String) = prop$delegate.setValue(this, this::prop, value)
}


 
  
52、提供委托
 
  
暂缺
 
  
53、扩展函数
 
  
与定义一般的函数很像，区别在于需要在添加的函数名字之前放置想要扩展的类或者接口的类型。这个类或接口叫做接收器类型（receiver type）。
 
  
// 给String类扩展一个函数，名叫mylastChar()
fun String.mylastChar(): Char = this.get(this.length - 1 )


fun main(args: Array<String>) {
    var str: String = "Hello World"
    // 调用我们扩展出来的函数mylastChar()
    println(str.mylastChar())
    println("bye bye".mylastChar()) 
}

 
  
54、with的用法
 
  
class MyData{
    var name: String? = null
    var age: Int? = null
}


fun main(args: Array<String>) {
    var data = MyData()
    with(data){
        name = "Tom"
        age = 28
    }
    println(data.name)
    println(data.age)
}

 
  
谢谢阅读。如果错误，请给我留言。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Kotlin)

        

            

                
    
                    
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作
                        铭空间
kt文件和java文件
                        
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
    
                    
    • 
                    
  • Jooq 框架介绍及其核心要点
                        木南曌
Javajava
                        
    一、引言Jooq（JavaPersistenceforRelationalDatabases）是一个强大的类型安全的SQL查询构建器和ORM（Object-RelationalMapping）框架，专为Java和Kotlin设计。它为开发者提供了一种优雅的方式来编写SQL代码，同时还能享受到静态类型检查带来的好处。本文将详细介绍Jooq的核心功能，并通过一系列的代码示例来展示如何使用Jooq。二、
    
                    
    • 
                    
  • Kotlin 代替Java接口回调，就这么简单
                        深海呐
Android#Kotlinjavakotlin开发语言
                        
    假如你使用旧的接口回调：通常三步：1定义接口和方法；2使用接口中方法；3继承接口并实现方法；例：classXXXAdapter{publicvarmClickCollBack:clickCollBack?=null//1定义interfaceclickCollBack{//1定义funclick(int:Int)//1定义}itemView.setOnClickListener{mClickCol
    
                    
    • 
                    
  • Android 用线程池实现一个简单的任务队列(Kotlin)
                        深海呐
Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
                        
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
    
                    
    • 
                    
  • SpringBoot3与SpringBoot2的区别
                        bjzhang75
springboot
                        
    文章目录1、JDK环境2、SpringFramework版本3、主要变化和新特性3.1配置变化3.2GraalVM3.3安全性改进3.4性能优化3.4.1启动时间3.4.2内存使用3.5改进的依赖管理3.6全新启动器3.7Kotlin支持SpringBoot3与SpringBoot2的区别1、JDK环境SpringBoot3最低要求JDK17SpringBoot2最低要求JDK82、SpringF
    
                    
    • 
                    
  • Android清洁架构实战教程：基于AliAsadi/Android-Clean-Architecture
                        符凡言Elvis

                        
    Android清洁架构实战教程：基于AliAsadi/Android-Clean-ArchitectureAndroid-Clean-ArchitectureAdemomovieandroidappshowcasingCleanArchitecture,writteninKotlinandfeaturingJetpackComposeformodern,declarativeUIs.(Offlin
    
                    
    • 
                    
  • Flutter类
                        且听真言
Flutter类定义及使用构造函数get/set修饰符对象操作符继承接口和抽象类Mixins（混入）
                        
    Dart中的对象都继承自Object类，单继承（extend关键字）。Dart与Java、kotlin不同的是其无public、private、protected修饰符，默认public，通过在属性名、方法名前加_下划线来定义是否私有。实现一个简单的类classStudent{//默认publicfinalStringname;//默认publicfinalintage;Student(this.
    
                    
    • 
                    
  • DSL
                        Davisxy
kotlinDSLKotlinokhttp
                        
    转载：摘抄自《Kotlin极简教程》-陈光剑DSL是什么DSL(Domain-SpecificLanguage，领域特定语言)指的是专注于特定问题领域的计算机语言(领域专用语言)。不同于通用的计算机语言(GPL)，领域特定语言只用在某些特定的领域。比如用来显示网页的HTML语言，以及Emacs所使用的EmacLISP语言等。更加典型的例子是Gradle，它基于Ant和Maven，使用基于Groov
    
                    
    • 
                    
  • 最新vue3 +ts 安装并封装axios_vue3 ts axios封装，前端面试题2024对kotlin的要求
                        2401_84433769
程序员前端面试学习
                        
    自学几个月前端，为什么感觉什么都没学到？？这种现象在很多的初学者和自学前端的同学中是比较的常见的。因为自学走的弯路是比较的多的，会踩很多的坑，学习的过程中是比较的迷茫的。最重要的是，在学习的过程中，不知道每个部分该学哪些知识点，学到什么程度才算好，学了能做什么。很多自学的朋友往往都是自己去找资料学习的，资料上有的或许就学到了，资料上没有的或许就没有学到。这就会给人一个错误的信息就是，我把资料上的学
    
                    
    • 
                    
  • JetPack Compose简单介绍
                        蜗牛的小梦想
JetPackComposeandroidui
                        
    它是2019年I/O大会上公布的新的UI库，在今年下半年会发布它的正式版。既然它是一个UI库，那就要和我们传统写UI的方式作对比了。①传统写UI的方式：就是先在建立一个xml文件，在里面写好布局好，再回到Java文件（或者是Kotlin文件）里去把控件实例化出来后，再去调用。②Compose这个库：或者说它是一个框架，它重新定义了AndroidUI的写法，不再使用xml文件了，而是直接在Kotli
    
                    
    • 
                    
  • Jetpack Compose 架构如何选？MVP 、 MVVM 还是 MVI？
                        goodhighting
程序员架构
                        
    首先，先看看不借助任何架构的Compose代码是怎样的？不使用架构的情况下，逻辑代码将与UI代码耦合在一起，在Compose中这种弊端显得尤为明显。常规Android开发默认引入了MVC思想，XML的布局方式使得UI层与逻辑层有了初步的解耦。但是Compose中，布局和逻辑同样都使用Kotlin实现，当布局中夹了杂逻辑，界限变得更加模糊。此外，ComposeUI中混入逻辑代码会带来更多的潜在隐患。
    
                    
    • 
                    
  • Kotlin 极简小抄 P1（变量与常量、基本数据类型、流程控制）
                        我命由我12345
Kotlin-极简小抄kotlin开发语言android后端学习javajava-ee
                        
    一、KotlinKotlin由JetBrains开发，是一种在JVM（Java虚拟机）上运行的静态类型编程语言Kotlin旨在提高开发者的编码效率和安全性，同时保持与Java的高度互操作性Kotlin是Android应用开发的首选语言，也可以与Java一样用于服务器端开发二、Kotlin极简小抄1、初体验funmain(){println("HelloWorld")}2、注释//这是单行注释/*这
    
                    
    • 
                    
  • kotlin中Gson解析Json时对于泛型的应用
                        张子羽
安卓三分钟jsonkotlinandroid
                        
    Gosn解析Json我们都知道，在使用Gson解析json时，可以通过如下代码将json转为实体类valuser=Gson().fromJson(json,UserBean::class.java)实体类的定义而在开发过程中，我们也可能遇到这样的Json数据//一个登陆接口返回的数据{"data":{"admin":false,"chapterTops":[],"coinCount":10,"co
    
                    
    • 
                    
  • Kotlin data class Json序列化问题
                        AgentRich
kotlinjson开发语言
                        
    先说结果换了Solon框架后allinkt遇到了一个问题。就是json数据层级深的时候只能序列化第一层，经过测试主流的json框架都是这样。研究了一天终于找到一个不依赖的解决方法。先上结果代码：@OptIn(ExperimentalStdlibApi::class)funmain(args:Array){valret="""{"code":200,"msg":"成功","data":{"id":"
    
                    
    • 
                    
  • Kotlin reified改造JSON解析
                        折翅鵬
Kotlinkotlinjson开发语言
                        
    reified有什么用？funmyGenericFun(c:Class)在myGenericFun泛型函数体内，无法访问类型T，因为T只有在编译时可用，但在运行时就被擦除了，也就是泛型擦除，。因此，如果想在函数体中使用泛型类型作为普通类型使用，就需要显式将该类作为参数传递，如myGenericFun中所示。如果使用reifiedT创建内联（inline）函数，则就算在运行时也可以访问T的类型，因此
    
                    
    • 
                    
  • [Moshi]认识新一代对Kotlin友好的JSON解析框架
                        天空光芒

                        
    为什么是Moshi切换到kotlin之后，在使用fastJSON时遇到了一些问题，经过网上的查询，要使fastJSON能够正常工作，需要额外添加kotlin-reflect依赖，感觉不是很爽。于是一通搜索之后，找到了著名的Square团队的又一个优秀的开源库——Moshi。它在允许使用传统的反射机制进行JSON序列化与反序列化的同时，也可以通过注解的方式在编译时生成解析类，不必引入2M+的refl
    
                    
    • 
                    
  • 【安卓面试】
                        木啊木啊木
android面试职场和发展
                        
    百度-APP相关安卓开发数组排序view流程和surfaceViewrecycleViewview绘制流程停止一个线程停止线程的场景输入一个url观察者模式观察者模式的基本流程：安卓内存共享JNISQLkotlin与java混用的问题Linux命令及原理app启动流程小程序原理加密算法对称加密非对称加密安卓持久化存储方式启动模式和场景ANR以及如何避免数组排序八大排序-及复杂度viewView是用
    
                    
    • 
                    
  • Android kotlin开发项目MVP架构搭建
                        哎吆我呸
androidKotlin初入门
                        
    1、引入需要的网络库implementation'com.squareup.retrofit2:retrofit:2.7.1'implementation'com.squareup.retrofit2:converter-gson:2.7.1'implementation'com.jakewharton.retrofit:retrofit2-kotlin-coroutines-adapter:0.
    
                    
    • 
                    
  • 如何用Kotlin实现MVP架构的Android快速开发框架？
                        2401_84132496
程序员androidkotlin架构
                        
    下拉刷新和上拉加载更多空页面在断网情况下加载缓存网络请求错误并重新加载基于Kotlin的使用说明（Java的使用具体参考java版本的demo）导入依赖在根目录中的build.gradle文件中加入maven{url“https://jitpack.io”}在应用下的build.gradle文件中加入在自定义的Application类中的onCreate方法中初始化CommonLibrary//初
    
                    
    • 
                    
  • 深入理解Kotlin中的异步网络请求处理
                        小白学大数据
kotlin开发语言android爬虫
                        
    在现代移动和Web应用开发中，异步网络请求处理是核心功能之一。Kotlin，作为一种现代、简洁且功能强大的编程语言，提供了多种方式来处理异步任务，使得开发者能够编写出更加高效和响应迅速的应用。本文将深入探讨Kotlin中的异步网络请求处理，包括其原理、优势以及如何在实际项目中实现。异步网络请求的重要性在用户界面(UI)开发中，异步操作是至关重要的。它允许应用在不阻塞主线程的情况下，执行网络请求和其
    
                    
    • 
                    
  • android plaid,Plaid 开源库学习
                        AI沃浪讯
androidplaid
                        
    Plaid库是google之前的一个demo库，近期利用kotlin进行了重写.某种程度上，是Kotlin和Jetpack的一个实践。以下内容从三个方面来说：Plaid项目划分Plaid的代码结构Plaid的代码实现-coroutines协程实现1.Plaid项目划分Plaid模块化结构图：plaid代码结构模块化图属于多模块化的设计，core是继承模块，其他模块是业务模块。2.Plaid每个模块
    
                    
    • 
                    
  • 【Kotlin】OkHttp框架实现网络下载
                        小叮当不懒
Androidkotlinokhttpandroid
                        
    目录【Kotlin】OkHttp框架实现网络下载需求思路实现实现单线程下载功能实现多线程下载功能不积跬步，无以至千里；不积小流，无以成江海。要沉下心来，诗和远方的路费真的很贵！【Kotlin】OkHttp框架实现网络下载需求对网络上的资源进行下载，下载的文件保存在本地mnt/sdcard/Download文件夹。显示下载的进度和下载是否成功的提示。多线程下载，一个线程下载一张图片或者一个视频。只有
    
                    
    • 
                    
  • Kotlin反射(模块化讲解)
                        GRKF15
kotlin开发语言android
                        
    参考文档：Kotlin反射全解析1–基础概念-简书反射·Kotlin官方文档中文版反射·Kotlin语言官方参考文档中文版反射·kotlin-docs-zh反射·Kotlin语言官方参考文档中文版反射·Kotlin官方文档中文版Kotlin反射：深入探索与多场景应用-CSDN博客Kotlin反射：深入探索与多场景应用-CSDN博客反射·Kotlin官方文档中文版AndroidKotlin反射全解析
    
                    
    • 
                    
  • Kotlin 协程使用手册，2024年最新面试官没礼貌
                        2401_84167109
程序员kotlin开发语言android
                        
    协程的定义其实不太好描述，那我干脆由用途及定义，简述一下协程。轻量级的线程标题的说法可能不太准确，但也能一窥其功用。协程是工作在线程之上的。我们知道线程是由系统（语言系统或者操作系统）进行调度的，切换时有着一定的开销。而协程，它的切换由程序自己来控制，无论是CPU的消耗还是内存的消耗都大大降低。从这一点出发，它的应用场景可能就在于提高硬件性能的瓶颈。譬如说，你启动十万个协程不会有什么问题，但你启动
    
                    
    • 
                    
  • Github 2024-05-24 开源项目日报 Top10
                        老孙正经胡说
github开源Github趋势分析开源项目PythonGolang
                        
    根据GithubTrendings的统计，今日(2024-05-24统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下：开发语言项目数量Python项目3非开发语言项目2TypeScript项目2JavaScript项目1Kotlin项目1C#项目1C++项目1Shell项目1MicrosoftPowerToys:最大化Windows系统生产力的开源实用工具创建周期：1720天开发语
    
                    
    • 
                    
  • Kotlin 枚举类
                        wjs2024
开发语言
                        
    Kotlin枚举类概述Kotlin是一种现代的编程语言，由JetBrains开发，旨在提高开发者的工作效率和代码质量。它运行在Java虚拟机(JVM)上，与Java完全兼容，同时提供了许多现代语言特性，如空安全、扩展函数和协程等。Kotlin的设计哲学是简洁和表达性，这使得它成为Android开发的官方语言，并在后端开发中也越来越受欢迎。Kotlin枚举类简介枚举类是Kotlin中的一种特殊类，用
    
                    
    • 
                    
  • Android从零开始搭建MVVM架构（1），kotlin扩展函数原理
                        m0_63935228
程序员面试android移动开发
                        
    使用default的时候，即使是studio3.5里，也不提示，不过不影响。还有一点，在DataBinding里，已经处理了null。所以这个时候你在Activity里给user设置为null。也不会崩溃二、DataBinding在Fragment和RecyclerView里的使用在Fragment的使用和Activity里的使用一样。获取根目录的方式如下。//注意获取根布局是Viewview=a
    
                    
    • 
                    
  • Android中的线程（一）
                        川峰
Android知识笔记android多线程线程安全线程池线程通信
                        
    本文主要是对Android当中的线程相关的知识进行复习和总结。文章目录newThreadAsyncTaskHandlerThreadIntentServiceJobIntentServiceJobSchedulerWorkManager线程中断守护线程线程优先级线程状态线程池线程安全线程通信kotlin协程newThread缺乏统一管理，无限制创建，可能占用过多系统资源导致死机或oom，不推荐。A
    
                    
    • 
                    
  • 2021-03-01至2021-03-07
                        独行者103

                        
    这一周没啥事，主要还是那场求职的事情。我打算拒绝，因为我要并行做很多项目，这些项目不是说很难，而是都我一个人做，我觉得自己就算再有能耐也不如有一群帮手一起做。这周是双休，在家里休息了一段时间，感觉恢复了不少精力。看了看kotlin和vant组件。我觉得还是一步步来吧，先提升自己的审美。当然锻炼这个事情还是要继续的。
    
                    
    • 
                    
  • kotlin use
                        鹅鹅鹅_

                        
    实现了Closeable接口的对象可调用use函数use函数会自动关闭调用者（无论中间是否出现异常）Kotlin的File对象和IO流操作变得行云流水use函数内部实现也是通过try-catch-finally块捕捉的方式，所以不用担心会有异常抛出导致程序退出close操作在finally里面执行，所以无论是正常结束还是出现异常，都能正确关闭调用者javaFileInputStreamfis=nu
    
                    
    • 
                                
  • mongodb3.03开启认证
                                    21jhf
mongodb
                                    
    下载了最新mongodb3.03版本，当使用--auth 参数命令行开启mongodb用户认证时遇到很多问题，现总结如下： 
（百度上搜到的基本都是老版本的，看到db.addUser的就是，请忽略） 
Windows下我做了一个bat文件，用来启动mongodb，命令行如下： 
mongod --dbpath db\data --port 27017 --directoryperdb --logp
    
                                
    • 
                                
  • 【Spark103】Task not serializable
                                    bit1129
Serializable
                                    
    Task not serializable是Spark开发过程最令人头疼的问题之一，这里记录下出现这个问题的两个实例，一个是自己遇到的，另一个是stackoverflow上看到。等有时间了再仔细探究出现Task not serialiazable的各种原因以及出现问题后如何快速定位问题的所在，至少目前阶段碰到此类问题，没有什么章法 
1. 
  
package spark.exampl
    
                                
    • 
                                
  • 你所熟知的 LRU(最近最少使用)
                                    dalan_123
java
                                    
    关于LRU这个名词在很多地方或听说，或使用，接下来看下lru缓存回收的实现 
1、大体的想法 
    a、查询出最近最晚使用的项 
    b、给最近的使用的项做标记 
通过使用链表就可以完成这两个操作，关于最近最少使用的项只需要返回链表的尾部；标记最近使用的项，只需要将该项移除并放置到头部，那么难点就出现 你如何能够快速在链表定位对应的该项？ 
这时候多
    
                                
    • 
                                
  • Javascript 跨域
                                    周凡杨
JavaScriptjsonp跨域cross-domain
                                    
      
                                 
    
                                
    • 
                                
  • linux下安装apache服务器
                                    g21121
apache
                                    
    安装apache  
下载windows版本apache，下载地址：http://httpd.apache.org/download.cgi 
   1.windows下安装apache   
Windows下安装apache比较简单，注意选择路径和端口即可，这里就不再赘述了。  2.linux下安装apache：  
下载之后上传到linux的相关目录，这里指定为/home/apach
    
                                
    • 
                                
  • FineReport的JS编辑框和URL地址栏语法简介
                                    老A不折腾
finereportweb报表报表软件语法总结
                                    
      JS编辑框： 
1.FineReport的js。 
作为一款BS产品，browser端的JavaScript是必不可少的。 
FineReport中的js是已经调用了finereport.js的。 
大家知道，预览报表时，报表servlet会将cpt模板转为html，在这个html的head头部中会引入FineReport的js，这个finereport.js中包含了许多内置的fun
    
                                
    • 
                                
  • 根据STATUS信息对MySQL进行优化
                                    墙头上一根草
status
                                    
    mysql  查看当前正在执行的操作，即正在执行的sql语句的方法为: 
     show processlist 命令 
  
mysql> show global status;可以列出MySQL服务器运行各种状态值，我个人较喜欢的用法是show status like '查询值%';一、慢查询mysql> show variab
    
                                
    • 
                                
  • 我的spring学习笔记7-Spring的Bean配置文件给Bean定义别名
                                    aijuans
Spring 3
                                    
    本文介绍如何给Spring的Bean配置文件的Bean定义别名？ 
 
原始的 
 
 
<bean id="business" class="onlyfun.caterpillar.device.Business">
    <property name="writer">
        <ref b
    
                                
    • 
                                
  • 高性能mysql 之 性能剖析
                                    annan211
性能mysqlmysql 性能剖析剖析
                                    
    

1 定义性能优化
  mysql服务器性能，此处定义为 响应时间。
  在解释性能优化之前，先来消除一个误解，很多人认为，性能优化就是降低cpu的利用率或者减少对资源的使用。
  这是一个陷阱。
  资源时用来消耗并用来工作的，所以有时候消耗更多的资源能够加快查询速度，保持cpu忙绿，这是必要的。很多时候发现
  编译进了新版本的InnoDB之后，cpu利用率上升的很厉害，这并不
    
                                
    • 
                                
  • 主外键和索引唯一性约束
                                    百合不是茶
索引唯一性约束主外键约束联机删除
                                    
    目标;第一步;创建两张表 用户表和文章表 
        第二步;发表文章 
  
  
  1,建表; 
    ---用户表 BlogUsers
    --userID唯一的
    --userName
    --pwd
    --sex
        

    create 
    
                                
    • 
                                
  • 线程的调度
                                    bijian1013
java多线程thread线程的调度java多线程
                                    
    1.       Java提供一个线程调度程序来监控程序中启动后进入可运行状态的所有线程。线程调度程序按照线程的优先级决定应调度哪些线程来执行。 
  
2.       多数线程的调度是抢占式的（即我想中断程序运行就中断，不需要和将被中断的程序协商） 
a) 
    
                                
    • 
                                
  • 查看日志常用命令
                                    bijian1013
linux命令unix
                                    
    一.日志查找方法，可以用通配符查某台主机上的所有服务器grep "关键字" /wls/applogs/custom-*/error.log 
  
二.查看日志常用命令1.grep '关键字' error.log：在error.log中搜索'关键字'2.grep -C10 '关键字' error.log：显示关键字前后10行记录3.grep '关键字' error.l
    
                                
    • 
                                
  • 【持久化框架MyBatis3一】MyBatis版HelloWorld
                                    bit1129
helloworld
                                    
    MyBatis这个系列的文章，主要参考《Java Persistence with MyBatis 3》。 
  样例数据 
本文以MySQL数据库为例，建立一个STUDENTS表，插入两条数据，然后进行单表的增删改查 
  
  
CREATE TABLE STUDENTS
(
stud_id int(11) NOT NULL AUTO_INCREMENT,

    
                                
    • 
                                
  • 【Hadoop十五】Hadoop Counter
                                    bit1129
hadoop
                                    
      
 1. 只有Map任务的Map Reduce Job  
	File System Counters
		FILE: Number of bytes read=3629530
		FILE: Number of bytes written=98312
		FILE: Number of read operations=0
		FILE: Number of lar
    
                                
    • 
                                
  • 解决Tomcat数据连接池无法释放
                                    ronin47
tomcat 连接池　优化
                                    
     
 近段时间，公司的检测中心报表系统(SMC)的开发人员时不时找到我，说用户老是出现无法登录的情况。前些日子因为手头上 有Jboss集群的测试工作，发现用户不能登录时，都是在Tomcat中将这个项目Reload一下就好了，不过只是治标而已，因为大概几个小时之后又会 再次出现无法登录的情况。 
  
今天上午，开发人员小毛又找到我，要我协助将这个问题根治一下，拖太久用户难保不投诉。 
简单分析了一
    
                                
    • 
                                
  • java-75-二叉树两结点的最低共同父结点
                                    bylijinnan
java
                                    
    
import java.util.LinkedList;
import java.util.List;

import ljn.help.*;
public class BTreeLowestParentOfTwoNodes {

	public static void main(String[] args) {
		/*
		 * node data is stored in
    
                                
    • 
                                
  • 行业垂直搜索引擎网页抓取项目
                                    carlwu
LuceneNutchHeritrixSolr
                                    
    公司有一个搜索引擎项目，希望各路高人有空来帮忙指导，谢谢！ 
这是详细需求： 
（1） 通过提供的网站地址(大概100-200个网站)，网页抓取程序能不断抓取网页和其它类型的文件（如Excel、PDF、Word、ppt及zip类型），并且程序能够根据事先提供的规则，过滤掉不相干的下载内容。 
（2） 程序能够搜索这些抓取的内容，并能对这些抓取文件按照油田名进行分类，然后放到服务器不同的目录中。 

    
                                
    • 
                                
  • [通讯与服务]在总带宽资源没有大幅增加之前,不适宜大幅度降低资费
                                    comsci
资源
                                    
     
 
      降低通讯服务资费，就意味着有更多的用户进入，就意味着通讯服务提供商要接待和服务更多的用户，在总体运维成本没有由于技术升级而大幅下降的情况下，这种降低资费的行为将导致每个用户的平均带宽不断下降，而享受到的服务质量也在下降，这对用户和服务商都是不利的。。。。。。。。 
 
 
    &nbs
    
                                
    • 
                                
  • Java时区转换及时间格式
                                    Cwind
java
                                    
    本文介绍Java API 中 Date, Calendar, TimeZone和DateFormat的使用，以及不同时区时间相互转化的方法和原理。 
  
问题描述： 
向处于不同时区的服务器发请求时需要考虑时区转换的问题。譬如，服务器位于东八区（北京时间，GMT+8:00），而身处东四区的用户想要查询当天的销售记录。则需把东四区的“今天”这个时间范围转换为服务器所在时区的时间范围。 

    
                                
    • 
                                
  • readonly,只读，不可用
                                    dashuaifu
jsjspdisablereadOnlyreadOnly
                                    
    readOnly 和 readonly 不同，在做js开发时一定要注意函数大小写和jsp黄线的警告！！！我就经历过这么一件事： 
使用readOnly在某些浏览器或同一浏览器不同版本有的可以实现“只读”功能，有的就不行，而且函数readOnly有黄线警告！！！就这样被折磨了不短时间！！！（期间使用过disable函数，但是发现disable函数之后后台接收不到前台的的数据！！！） 
  
    
                                
    • 
                                
  • LABjs、RequireJS、SeaJS 介绍
                                    dcj3sjt126com
jsWeb
                                    
    LABjs 的核心是 LAB（Loading and Blocking）：Loading 指异步并行加载，Blocking 是指同步等待执行。LABjs 通过优雅的语法（script 和 wait）实现了这两大特性，核心价值是性能优化。LABjs 是一个文件加载器。RequireJS 和 SeaJS 则是模块加载器，倡导的是一种模块化开发理念，核心价值是让 JavaScript 的模块化开发变得更
    
                                
    • 
                                
  • [应用结构]入口脚本
                                    dcj3sjt126com
PHPyii2
                                    
    入口脚本 
入口脚本是应用启动流程中的第一环，一个应用（不管是网页应用还是控制台应用）只有一个入口脚本。终端用户的请求通过入口脚本实例化应用并将将请求转发到应用。 
Web 应用的入口脚本必须放在终端用户能够访问的目录下，通常命名为 index.php，也可以使用 Web 服务器能定位到的其他名称。 
控制台应用的入口脚本一般在应用根目录下命名为 yii（后缀为.php），该文
    
                                
    • 
                                
  • haoop shell命令
                                    eksliang
hadoophadoop shell
                                    
     
 cat 
 chgrp 
 chmod 
 chown 
 copyFromLocal 
 copyToLocal 
 cp 
 du 
 dus 
 expunge 
 get 
 getmerge 
 ls 
 lsr 
 mkdir 
 movefromLocal 
 mv 
 put 
 rm 
 rmr 
 setrep 
 stat 
 tail 
 test 
 text 
 
    
                                
    • 
                                
  • MultiStateView不同的状态下显示不同的界面
                                    gundumw100
android
                                    
    只要将指定的view放在该控件里面，可以该view在不同的状态下显示不同的界面，这对ListView很有用，比如加载界面，空白界面，错误界面。而且这些见面由你指定布局，非常灵活。 
 
PS：ListView虽然可以设置一个EmptyView，但使用起来不方便，不灵活，有点累赘。 
 
 

<com.kennyc.view.MultiStateView xmlns:android=&qu
    
                                
    • 
                                
  • jQuery实现页面内锚点平滑跳转
                                    ini
JavaScripthtmljqueryhtml5css
                                    
    平时我们做导航滚动到内容都是通过锚点来做，刷的一下就直接跳到内容了，没有一丝的滚动效果，而且 url 链接最后会有“小尾巴”，就像#keleyi，今天我就介绍一款 jquery 做的滚动的特效，既可以设置滚动速度，又可以在 url 链接上没有“小尾巴”。 
  
效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/37.htmHTML文件代码： 
&
    
                                
    • 
                                
  • kafka offset迁移
                                    kane_xie
kafka
                                    
    在早前的kafka版本中（0.8.0），offset是被存储在zookeeper中的。 
  
到当前版本（0.8.2）为止，kafka同时支持offset存储在zookeeper和offset manager（broker）中。 
  
从官方的说明来看，未来offset的zookeeper存储将会被弃用。因此现有的基于kafka的项目如果今后计划保持更新的话，可以考虑在合适
    
                                
    • 
                                
  • android > 搭建 cordova 环境
                                    mft8899
android
                                    
      
1 , 安装 node.js   
     http://nodejs.org 
     
node -v   查看版本 
  
2, 安装 npm 
  
可以先从  https://github.com/isaacs/npm/tags  下载 源码 解压到
    
                                
    • 
                                
  • java封装的比较器，比较是否全相同，获取不同字段名字
                                    qifeifei

                                    
     非常实用的java比较器，贴上代码： 
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;

i
    
                                
    • 
                                
  • 记录一些函数用法
                                    .Aky.
位运算PHP数据库函数IP
                                    
    高手们照旧忽略。 
想弄个全天朝IP段数据库，找了个今天最新更新的国内所有运营商IP段，copy到文件，用文件函数，字符串函数把玩下。分割出startIp和endIp这样格式写入.txt文件，直接用phpmyadmin导入.csv文件的形式导入。（生命在于折腾，也许你们觉得我傻X，直接下载人家弄好的导入不就可以，做自己的菜鸟，让别人去说吧） 
 
当然用到了ip2long()函数把字符串转为整型数
    
                                
    • 
                                
  • sublime text 3 rust
                                    wudixiaotie
Sublime Text
                                    
    1.sublime text 3 => install package => Rust 
2.cd ~/.config/sublime-text-3/Packages 
3.mkdir rust 
4.git clone https://github.com/sp0/rust-style 
5.cd rust-style 
6.cargo build --release 
7.ctrl
    
                                
    •