星星博客 »  > 

Kotlin基础(一):内置类型

前言

本文主要讲解内置类型,主要包括:基本类型、数组、区间、集合框架、函数、案例:计算器


Kotlin文章列表

Kotlin文章列表: 点击此处跳转查看


目录

在这里插入图片描述


(一)基本类型

(1)Kotlin与Java基本类型比较

在这里插入图片描述

(2)声明变量

(2.1)kotlin声明变量

在这里插入图片描述

(2.2)kotlin与java声明变量比较

java:

int a = 2final String b = "Hello Java"

kotlin:

var a : lnt = 2
val b:String = "Hello Kotlin"

(2.3)kotlin声明变量类型自动推导

var a = 2
val b:String = "Hello Kotlin"

(2.4) kotlin与java易混淆的Long类型标记

java:

long c = 12345678910l;  // ok but not good.    
long d = 12345678910L; // ok

kotlin:

val c = 12345678910l // compile error    
val d = 1234567890L; // ok

(2.5)kotlin的数值类型转换

java:

int e = 10;    
long f = e; // implicit conversion

kotlin:

val e : Int =10    
val f : Long = e.toLong() // ok

(2.6)kotlin无符号类型

在这里插入图片描述


(3)kotlin的字符串

字符串比较
a == b:比较内容,等价于Java的equals
a === b:比较对象是否是同一个对象

字符串模板
“Hello, $name” => “Hello,小明”

val j = "I love China"
println("Value of String 'j' is: $j) // no need brackets  
println("Length of String 'j' is: ${j.length})") // need brackets
System. out.printf("Length of String 'j' is: %d\n", j.length)

(二)数组

(1)kotlin与java数组比较

在这里插入图片描述

(2)kotlin与java数组的创建

java:

int[] c = new int[]{1, 2, 3, 4, 5};

kotlin:

val c = intArayof(1, 2, 3, 4, 5)
val c1 = IntArray(size: 5){it + 1} 
it 为数组下标,从0到size - 1   

例如:

val c = IntArray( size: 5){3 * (it + 1))}    // y = 3 * (x + 1)
it的取值为0, 1, 2, 3, 4
c的值为[3, 6, 91215]

(3)kotlin与java数组的长度

java:

int[] a = new int[5];    
System.out.println(a.length);

kotlin:

val a = IntArray(5)    
println(a.size) 

(4)kotlin与java数组的读写

java:

String[] d = new String[]{"Hello","World"};
d[1] = "Java";
System.outprintln(d[0] + "," + d[1]);

kotlin:

val d = arrayof{"Hellb", "World")
d[1] = "Kotlin"
println("${d[0]}, $(d[1]}")

(5)kotlin与java数组的遍历

java:

float[] e = new float[]{1, 3, 5, 7}; 
for (float element : e) {
     System. out println(element);
}

kotlin:

val e = floatArrayof(1f, 3f, 5f, 7f)    
for (element in e) {
    println(element)
}

或者另一种写法

e.forEach { element ->
        println(element)
}

(6)kotlin与java数组的包含关系

java:

for (float element : e) {
      if (element == 1f) {
          System. out.println("If exists in variabl 'e'");
          break;
      }
}

kotlin:

if (1f in e) {
    println("If exists in variabl 'e'");
}

(三)区间

(1)闭区间的创建

… 表示闭区间

val intRange = 1 .. 10     // [1, 10]    
val charkange = 'a' .. 'z'    
val longRange = 1L .. 100L

(2)开区间的创建

until表示开区间,但是不包含结束值

val intRangeExclusive = 1 until 10   // [1, 10)    
val charRangeEXclusive = 'a' until 'z'    
val long RangeExclusive = 1L until 100L

(3)倒序区间的创建

downTo为倒序区间,也是闭区间

val intRangeReverse = 10 downTo 1  // [10, 9..…,1]
val charRangeReverse = 'z' downTo 'a'
val longRangeReverse = 100L downTo 1L

(4)区间的步长

val intRangeWithStep = 1 .. 10 step 2    
val charRangeWithStep = 'a' .. 'z' step 2    
val longRangeWithStep = 1L .. 100L step 5

(5)区间的迭代与包含

for (element in intRange) {
     println(element)
}

intRange.forEach {
    println(it)
}

if (3 in intRange) {
    println("3 in range 'intRange'")
}

if (12 !in intRange) {
     println("12 not in range 'intRange'")
}

(6)区间的应用

val array = intArrayOf(1, 3, 5, 7)
for(i in array.indices) {
    println(array[i])
}

indices返回[0, array.size)

(四)集合框架

(1)kotlin集合框架的特点

增加了“不可变”集合框架的接口
没有另起炉灶,复用 Java API的所有实现类型
提供了丰富易用的方法,例如 forEach/map/flatMap
运算符级别的支持,简化集合框架的访问


(2)kotlin与java集合框架的接口类型对比

在这里插入图片描述
不可变的意思是:不能添加或者删除元素
可变的意思是:可以添加或者删除元素


(3)kotlin与java集合框架的创建

java:

List<String> stringList = new ArraylList<>();
List<Integer> intList = new ArraylList<>(Arrays.asList(1, 2, 3));

kotlin:

var stringList = ArrayList<String>()

val intList : List<Int>= listof(1, 2, 3)
val intList2 : MutableList<Int> = mutableListof(1, 2, 3)

val map: Map<String, Any> = mapOf("name" to "benny", "age" to "20")
val map2: Map<String, Any> = mutableMapOf("name" to "benny", "age" to "20")

"name" to "benny"可以理解为,k - v
Any等价与java中的object

(4)kotlin与java集合框架的修改

java:

for (int i = 0; i < 10;  i++) {
    stringList.add(num: " 1)
}

kotlin:

for (i in 0.. 10) {
    stringList +="num : $i"
}

(5)kotlin与java集合框架的读写

java:
(1)List

stringList.set(5, "HelloWorld");
String valueAt5 = stringList.get(5);

(2)Map

HashMap<String, Integer> map = new HashMap<>;    
map.put("Hello, 10);
System.out.printIn(map. get( "Hello" );

kotlin:
(1)Map

stringList[5] = "HelloWorld"
val valueAt5 = stringList[5]

(2)Map

val map = HashMap<String, Int>()
map["Hello"] = 10
println(map["Hello"])

(6)pair triple

val pair = "Hello" to "Kotlin"
val pair2 = Pair("Hello", "Kotlin'")    两种创建方式
val first = pair.first
val second = pair.second   获取对应元素
val(x, y) = paik

val triple = Triple("x", 2, 3.0)
val first = triple.first
val second = triple.second 
val third = triple.third
val(x, y, z) = triple

(五)函数

(1)函数的定义

在这里插入图片描述

fun main(args:Array<String>) {
    println(args.contentToString())
}                                                                               
iUnit等价于Java的void函数,返回值为Unit可省略

(2)函数的类型

在kotlin中如果函数A想作为函数B的参数,那么函数A该怎么写呢?此时就需要了解函数的类型

fun fool{}      () -> Unit

fun foo(p0 : Int) : String {...}    (Int)-> String

class Foo {
     fun bar(p0: String, p1: Long): Any{...}              Foo.(String, Long) -> Any   或者  Foo.(String, Long) -> Any 
}

(3)函数的引用

函数的引用类似C语言中的函数指针, 可用于函数传递

fun foo() { }                     ::foo

fun foo(p0: Int): String {...}            ::foo

class Foo {
    fun bar(p0: String, p1 Long): Any(...)                            Foo::bar
}

定义变量来接收值

fun foo() { }                 val f :() -> Unit = ::foo 或者 val f = ::foo          

fun foo(p0: Int): String {...}        val g :(Int) -> String = ::foo 或者 val g = ::foo

class Foo {
    fun bar(p0: String, p1 Long): Any(...)                      val h:(Foo, String, Long) ->Any = Foo::bar 或者 val h = Foo::bar
}

class Foo {
    fun bar(p0: String, p1 Long): Any(...)                     
}
val foo = Foo()
val m = foo::bar

(4)变长参数

multiParameters("1", "2", "3")

fun multiParameters(vararg args : String) {
    println(args.contentToString())
}

(5)多返回值

fun multiReturnValues() : Triple<Int, Long, Double> {
    return Triple(1, 3L, 4.0)
}

val(a, b, c) = multiReturnValues()
val d = a + b

(6)默认参数

函数定义:

fun defaultParameter(x: int, y: String, z: long = 0L)  {

}

函数调用: defaultParameter(5, " Hello")
默认参数应该是最后一个


(六)案例:计算器

/**
* 输入的格式如下
* input: 3 * 4
* 
*/
fun main(vararg args: String) {

    if (args.size < 3) {
        return showHelp()
    }

    val operators = mapOf(
        "+" to ::plus,
        "-" to ::minus,
        "*" to ::times,
        "/" to ::div
    )

    val op = args[1]
    val opFunc = operators[op] ?: return showHelp()

    try {
        println("Input: ${args.joinToString(" ")}")
        println("Output: ${opFunc(args[0].toInt(), args[2].toInt())}")
    } catch (e: Exception) {
        println("Invalid Arguments.")
        showHelp()
    }
}

fun plus(arg0: Int, arg1: Int): Int {
    return arg0 + arg1
}

fun minus(arg0: Int, arg1: Int): Int {
    return arg0 - arg1
}

fun times(arg0: Int, arg1: Int): Int {
    return arg0 * arg1
}

fun div(arg0: Int, arg1: Int): Int {
    return arg0 / arg1
}

fun showHelp() {
    println(
        """
        Simple Calculator:
            Input: 3 * 4
            Output: 12
    """.trimIndent()
    )
}

相关文章