1、基本数据类型

1.1、数据类型介绍

kotlin没有区分包装类和数据类型，他只有统一的数据类型。

1.2、数据类型与java不对等

但是kotlin里面的数据类型，不能完全的去对等java中的数据类型和包装类，举一个简单例子：

fun getInt1(): Int { // 默认不可为null，函数的书写后一讲会表述
return 0
}

fun getInt2(): Int? { // 其中?表示可以返回null
return 0
}

上面有两个函数，我们看一下转换成java的结果

public static final int getInt1() {  // 不可为null的，转换java就是int
return 0;
}

@Nullable
public static final Integer getInt2() { // 可为null的情况，则为Integer
return 0;
}

故而从中我们可以看到，kotlin语言的灵活性，并且不可对等java的实现。

1.3、数据类型的长度

1.4、数据类型之间的转换

fun transfer() {
var str: String = "1";
var i: Int = str.toInt();

var j: Long = str.toLong();

var h: Double = str.toDouble();

var m: Char =  i.toChar();

var l: CharArray =  str.toCharArray();
}

kotlin语言将数据之间的转化都扁平化，你想转换成什么，只要toXXX就可以了。我们看看他的转换成java的结果。

public static final void transfer() {
String str = "1";
boolean var3 = false;
int i = Integer.parseInt(str);
boolean var5 = false;
long j = Long.parseLong(str);
boolean var7 = false;
double h = Double.parseDouble(str);
char m = (char)i;
boolean var9 = false;
Intrinsics.checkExpressionValueIsNotNull(str.toCharArray(), "(this as java.lang.String).toCharArray()");
}

java所有的实现方式，都是基于包装类的转换。并且有很多时候，实现的方式也不尽统一。

注：kotlin语言是支持无符号数的，但是由于java不支持，所以如果运行与java平台是没用的。

2、数组

我们这边先将，基本数据类型数组，也非常的直接，例如IntArray、DoubleArray。规律就是xxxArray。

fun getIntArray(): IntArray {
return IntArray(10); // 10表示数组大小
}

fun getDoubleArray(): DoubleArray {
return doubleArrayOf(170.0, 180.0, 190.0) // 初始化一个double数组，并且包含特定元素
}

fun getByteArray(): ByteArray {
return ByteArray(10) { 1 };  // 初始化长度为10的byte数组，并且值都为1
}

fun getShortArray(): ByteArray {
return ByteArray(10) { i -> 1 };  // 初始化长度为10的short数组，并且值都为1
}

看一下java源码：

@NotNull
public static final int[] getIntArray() {
return new int[10];
}

@NotNull
public static final double[] getDoubleArray() {
return new double[]{170.0D, 180.0D, 190.0D};
}

@NotNull
public static final byte[] getByteArray() {
byte var0 = 10;
byte[] var1 = new byte[var0];

for(int var2 = 0; var2 < var0; ++var2) {
int var4 = false;
byte var7 = 1;
var1[var2] = var7;
}

return var1;
}

@NotNull
public static final byte[] getShortArray() {
byte var0 = 10;
byte[] var1 = new byte[var0];

for(int var2 = 0; var2 < var0; ++var2) {
int var4 = false;
byte var7 = 1;
var1[var2] = var7;
}

return var1;
}

更多集合类，请关注。

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/

3、集合类

kotlin的集合类基本是与Java一致的，只是kotlin对大多数的集合类提供了一些很方便创建集合的方法，如下

fun getList(): List<String> {
return listOf("1", "2", "3") // 创建list的时候，用listof，注意全小写
}

fun getMap(): Map<String, String> {
return hashMapOf(Pair("1", "1"));  // 创建hashmap的的时候用hashmap
}

fun getArraySet(): ArraySet<String> {
var set: ArraySet<String> = ArraySet();  // 定义一个arraySet的对象
set.add("!11");  // 增加一个值
return set;
}

我们看一下编译后的java代码

@NotNull
public static final List getList() {
return CollectionsKt.listOf(new String[]{"1", "2", "3"});  // 通过kotlin辅助类创建list，该辅助类非常完全的帮助实现kotlin的list到java的转换
}

@NotNull
public static final Map getMap() {
return (Map)MapsKt.hashMapOf(new Pair[]{new Pair("1", "1")}); // 类似的map
}

@NotNull
public static final ArraySet getArraySet() {
ArraySet set = new ArraySet();                            // 不适用xxxOf的时候，与java基本一致。
set.add("!11");
return set;
}

我们看一下编译后的java代码

这里面需要注意一点，不管是listOf 还是mapOf，这些都是没有固定类型的，我看查看源码也可以发现

public fun <T> listOf(element: T): List<T> = java.util.Collections.singletonList(element)  // 单元素调用
public fun <T> listOf(vararg elements: T): List<T> = if (elements.size > 0) elements.asList() else emptyList()  // 多元素调用
public fun <K, V> mapOf(pair: Pair<K, V>): Map<K, V> = java.util.Collections.singletonMap(pair.first, pair.second) // 单元素
public fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V> = if (pairs.size > 0) pairs.toMap(LinkedHashMap(mapCapacity(pairs.size))) else emptyMap() // 多元素调用

虽然多元素的返回结果，在java里面都是可以增加元素的，但是在kotlin里面，List 和 Map都是没有增加元素的方法的，故而在官方文档里面说明了，这些方法都是返回的不可变集合。那如果要变成可变的咋办，两种办法：

HashMap<String, String>(map); // 强制转换
map.plus(Pair("1", "1"))  // 有一个plus方法增加元素

但是还是推荐不要去不指定类型使用。
关于更多的集合知识，可参考官方文档

https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/

4、其他常用类型

4.1、Unit

这个字段是对应java的oid字段，我们写一段函数

fun showUnit(): Unit {

}

看看java编译结果：

public static final void showUnit() {
}

这个字段在java 和 kotlin之间互调是有妙用的，java中的void是可以转换为kotlin中的Unit的。这个后面函数分析的时候会讲。

4.2、Nothing

Unit虽然可以替代void，但是他不能完全替代void，因为实际上java中void是表示没有返回值的，但是Unit还是可以打印的。那么我们想表示什么也不返回，用什么nothing。

而且Nothing还有其他的用途，参考源码EmptyList

internal object EmptyList : List<Nothing>, Serializable, RandomAccess {
override fun get(index: Int): Nothing = throw IndexOutOfBoundsException("Empty list doesn't contain element at index $index.")
}

当我们书写语句：

fun findAllPlayers(): List = emptyList()。可以看到，emptyList他就是明确的nothing类型的List，但是却可以赋值给明确类型的List
所以 nothing 其实表示不存在的值，但是他又可以理解为所有类的子类。

4.3、ANY

any就很好理解了，基本上可以类比java的object，从编译的结果可以明确看出来。