Kotlin基础

最新推荐文章于 2022-10-17 19:06:36 发布

jiaqiangziji

最新推荐文章于 2022-10-17 19:06:36 发布

阅读量360

点赞数

分类专栏： Kotlin 文章标签： Kotlin Kotlin语法

本文链接：https://blog.csdn.net/jiaqiangziji/article/details/101177630

版权

Kotlin 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Kotlin 基础

变量
Kotlin 变量分为两种：
- 可变变量
+ 可变变量对应于Java 的普通变量。
+ 可变变量用 var 来修饰，可以进行多次修改。
- 不可变变量
+ 不可变变量相当于Java中用final关键字修饰的常量。
+ 不可变变量用 val 来修饰，只能进行一次初始化。

 声明变量：
     var 变量名：数据类型
     val 变量名 ：数据类型

 示例：
     可变变量：
     var a: Int = 1;
     或者
     var a: Int;
     a = 1;

     不可变变量
     val a: Int = 1;
     或者 
     val a: Int;
     a = 1;

     注意：
         - 在声明变量的时候如果未初始化变量，则要声明其具体数据类型。
             + var a; // f
             + var a:Int; // t
         - 在同一个方法中不可以重复声明同一个变量。
         - 可变变量可以多次赋值，不可变变量不可以进行第二次赋值。

数据类型
- Java 中的数据类型
  - 基本数据类型
    - 数值型
    - 字符型
    - 布尔型
  - 引用数据类型
    - 类
    - 接口
    - 数组
    - 枚举
    - 注解
- Kotlin 中不区分基本数据类型和引用数据类型
  - 数值型
    - Byte(字节)
      - Byre 类型变量会占用1个字节大小的内存空间。
    - Short(短整形)
      - Short 类型变量会占用2个字节大小的内存空间。
    - Int(整型)
      - Int 类型变量会占用4个字节大小的内存空间。
    - Long(长整型)
      - Long 类型变量会占用8个字节大小的内存空间。
      - 所有赋值后面要加上一个字母L，如果赋值未超过Int值的范围，则可以省略不加。
    - Float(浮点型)
      - Float 类型变量会占用4个字节大小的内存空间。
      - 所有赋值后面要加上一个字母F或(小写f)。
    - Double(双精度浮点型)
      - Double 类型变量会占用8个字节大小的内存空间。
      - 所有赋值后面不允许加字母D(或小写d),这与Java 是不同的。
  - 字符型
    - Char
      - Kotlin 中一个字符类型变量都占用2个字节。
      - 在给Char类型的变量赋值时，需要用一对英文半角格式的单引号 ‘’ 把字符括起来。
      - 在Kotlin中Char类型的变量不能直接赋值为数字，必须使用单引号把数字括起来才可以进行赋值。
  - 布尔型
    - 用Boolean表示
      - true。
      - false。
  - 数组型
    - 数组用Array表示。其中数值类型、布尔类型、字符类型都有数组的表现形式。
    - 数组类型变量的初始化有两种方式:
      - 数据类型(int,boolean,char)ArrayOf()方法进行初始化。
      - arrayOf()方法进行初始化。
  - 字符串型
    - 字符串用于存储多个字符，这一点于Java 中的字符串类型变量非常相似。
    - 字符串类型用”String“ 表示，在给String 类型的变量赋值时，需要用一对英文半角格式的双引号""把字符括起来。
    示例：
    var int_array: IntArray = intArrayOf(1,2,3);
    var boolean_array: BooleanArray = booleanArrayOf(true,true,false);
    var char_array: CharArray = charArrayOf(‘a’,‘b’,‘c’);
    
    注意：
    - Kotlin 中数组创建时用intArrayOf()(booleanArrayOf())方法，而不是Java中的 new 关键字。
    - 在 Kotlin 中不能使用stringArrayOf()方法创建字符串类型数组，因为String不属于基本数据类型。
    - 在Kotlin 中声明字符串数组，需要使用Array，并且对应的初始化数组是 arrayOf()。
    
    var int_array1: Array = arrayOf(1,2,3);
    var boolean_array1: Array = arrayOf(true,true,false);
    var string_array: Array = arrayOf(“abc”,“def”,“ghi”);
    或者
    var string_array1 = arrayOf(“Hello”,“Hi”,“OK”);
运算符
Kotlin 中的运算符基本与Java相似。
Kotlin 中运算符分为：
- 算术运算符
+ ++
* 自增(前)
- a=1;b=++a; a=2;b=2;
* 自增(后)
- a=1;b=a++; a=2;b=1;
+ –
* 自减(前)
- a=1;b=–a; a=0;b=0;
* 自减(后)
- a=1;b=a–;a=0;b=1;
- 赋值运算符
- 比较运算符
- 逻辑运算符
字符串
在Kotlin中字符串也是一样不可变的，字符串中的元素可以使用以下方式访问：
- 变量+角标的形式，如 str[i]。
+ var str: String = “Hello Word”;
// 获取某个字符串长度
str.length();
//通过索引方式访问某个字符,角标从0开始
str[index]
- for 循环遍历字符串,for 关键字后边() 中包含了3部分内容，分别是循环对象、in 和循环集合，{}中的执行语句为循环体。
+ var str = “Hell Word”;
for(s in str){
print©;
}
- 字符串查找
  - first(); // 获取第一个元素
  - last(); // 获取最后一个元素
  - get(index); // 根据索引获取元素
  - str[index]; // 根据索引获取元素
  - indextOf(’’)； //查找字符在原来字符串中第一次出现的索引
  - lastIndexOf(’’); //查找字符在原来字符串中最后一次出现的索引
- 字符串截取
  - substring(startIndex : Int)
    - 从 startIndex 为起始索引下标，从下标位置截取到字符串末尾，返回值String类型
  - substring(startIndex : Int,endIndex: Int)
    - startIndex 为起始索引下标，endIndex 为结束索引下标，字符串从 startIndex 位置截取到 endIndex-1处的字符。
  - substring(range: IntRange)
    - IntRange 表示截取范围，截取范围内的字符串。
  - subSenquence(startIndex : Int,endIndex: Int)
    - 与 subString() 类似，字符串从 startIndex 位置截取到 endIndex-1 处的字符，只不过返回值为 CharSequnce。
  - subSenquence(range: IntRange)
    - 与 subString() 类似，截取范围内的字符串，返回值为 CharSequnce。
- 字符串替换
  - replace(oldChar,newChar,ignoreCase = false)
    - oldChar 表示要替换的字符串，newChar 表示新的字符串， ignoreCase 表示是否引用 java 中的 replace() 方法，默认为 false;
  - replaceFirst(oldValue,new Value)
    - 在原始字符串中查找第 1 个与 oldValue 相同的字符串，把满足条件的第 1 个字符串替换成 newValue 新的字符串。如果不满足条件，则返回原始字符串
  - replaceBefore(delimiter,newValue)
    - 在原始字符串中查找第 1个与 delimiter 相同的字符串，将满足条件的第一个字符串之前的所有字符替换为 newValue,如果不满足条件，则返回原始字符串。
  - replaceAfter(delimiter,newValue)
    - 在原始字符串中查找第 1个与 delimiter 相同的字符串，将满足条件的第一个字符串之后的所有字符替换为 newValue,如果不满足条件，则返回原始字符串。
- 字符串分隔
  - split()方法。
- 字符串去空格
  - trim()
    - 删除字符串前面的空格。
  - trimEnd()
    - 删除字符串后面的字符。
- 字符串字面值
  - 字符串的字面值是一串字符常量，字符串字面值常量使用双引号括起来的""的零个或多个字符，如 “Hello”。Kotlin有两种类型的字符串字面值：
    - 转义字符串，包含转移字符。
      - 转义是采用传统的反斜杠""方式将字符进行转移，与Java 类似。
    - 原生字符串，可以包含转义字符、换行、任意文本。
      - 原生字符串是使用3对引号(""" “”")把所有的字符括起来，原生字符串可以有效的保证字符串中原有内容的输出，即使原生字符串中包含转义字符也不会被转义。
- 模板表达式
  - 模板表达式就是在字符串中添加占位符，字符串模板表达式由 ${变量名/函数/表达式}组成，也可以省略{}，例如：“$ 变量名”。
    示例：
    - 使用模板表达式存储字符串的值。
      - var a = 1;
        var s1 = “a is ${a}”;
        or
        var s2 = “a is $a”;
    - 使用模板表达式调用其他方法。
      - fun count():Int{
        return 1+2;
        }
        
        println(${count});
选择结构语句
1. if 条件语句(同Java)
2. if…else 语句(同Java)
3. 三元运算符
  if(判断条件)? 表达式1 else 表达式2；
4. if…else if…else 语句(同Java)
5. when条件语句，等同于 Java 的 switch(条件)
  在使用when最为表达式使用时，则必须要有else分支，除非编译器能够检测出所有可能情况都已经覆盖。
  示例：
  var num: Int = 2;
  when(num){
  1 -> print(1);
  2 -> print(2);
  3 -> print(3);
  4 -> print(4);
  else ->{
  print(“不匹配”);
  }
  }
  
  如果 when 语句中，多个目标值后面的执行语句是一样的，则可以把多个目标值放在一起，用逗号哥开。
  var month: Int = 5;
  when(month){
  12,1,2-> print(“冬季”);
  3,4,5 -> print(“春季”);
  6,7,8 -> print(“夏季”);
  9,10,11 -> print(“秋季”);
  else ->{
  print(“一年就12个月”);
  }
  }
  
  如果 when 语句中不提供参数，则所有的分支条件都是简单的布尔表达式，当一个分支条件为真时可执行该分支后面的执行语句。
  var a: Int = 5;
  var b: Int = 6;
  when {
  a > b-> print(“a > b”);
  3,4,5 -> print(“a < b”);
  else ->{
  print(“a 等于 b”);
  }
  }
6. 循环语句
  - while 循环语句(同 Java)
  - do…while 循环语句(同 Java)
  - for
    - for (循环对象 in 循环条件){
      执行语句
      …
      }
    for() 中的包含了循环对象、in 和循环条件，{} 中执行语句为循环体
    示例：
    for (i in 0…3){
    println(“结果${i}”);
    }
  - forEach 循环语句
    - 普通的 forEach 语句
      - 调用者.forEach(){
        println(“it=${it}”);
        
        }
    - 带角标的 forEach Indexed 语句
      - 调用者.forEachIndexed(){ index,it ->
        println(“角标= $i n d e x 元素 =$ {it}”);
        }
  - 跳转语句
    - break语句(跟Java类似)
      break@loop
      嵌套循环中用来直接跳出内外层循环的。
    - continue 语句(跟Java类似)
      同样可以带有 @loop
  - 区间
    - 正向区间
      - 区间通常指一类数据集合，可以分为：
        rangeTo (other: Int)
        1.rangeTo(3);
        
        … 形式的操作符
        1…3;
        
        until (to:Int)
        使用该函数输出的区间不包含结尾元素，并且该函数在使用时可以省略(),unit 后面加上空格符，空格符后面加上范围值即可。
        1 until 3
    - 逆向区间
      - downTo(to: Int)函数，并且该函数也可以省略()。
        3 downTo 1;
    - 步长
      - step (step: Int),括号也可以省略不写只要在 step 后面加上空格符，空格符后面加上步长即可。
数组（前面已有）
- 数组修改
  - set(index,newValue);
- 查找元素角标
  - indexOf(value);
  - indexOfFirst{ //查找数组中第1个元素为 num 对应的角标。
    it ==num; // 将需要查找的元素赋值给 it。
    }
  - lastIndexOf(num);查找数组中指定元素中的最后一个角标。
  - indexOfLast{ // 查找数组中最后1个元素为 num 对应的角标。
    it == num; // 将需要查找的元素赋值给 it。
    }
变量类型转换
- 类型检查
  避免变量在进行类型转换时，由于类型不一致而出现类型转换异常的问题，可以使用：
  - is 操作符
  - !is 操作符
  var a: Boolean = someObj is Class;
  var a: Boolean = someObj !is Class;
- 智能类型转换
  当当前对对象属于 is 后面的数据类型，则在使用该对象时可以自动进行智能类型转换。
- 强制类型转换
  - as 操作符进行强制类型转换。
    var a = “a”;
    var b: String = a as String;
  - as?
    针对 as 操作符进行强制类型转换时，转换错误，程序会报错并抛出异常。为了避免这种情况，Kotlin 提供了安全转换类型操作符 as?，使用 as? 操作符转换失败，会返回null，不会抛出异常。
    
    var a = 1;
    var b: String? = a as? String;
    b?.length
空值处理
- 可空类型变量(?)
  Kotlin 把变量分为两种，一种是可空类型的变量，一种是非空类型的变量。一般情况下，一个变量默认是非空类型。当某个变量的值可以为空时，必须在声明处的数据类型后添加 “？” 来标识该引用为空。
  var a: String; // 声明非空变量
  var a: String?; // 声明可空变量
  
  判断变量是否为空
  if(a != null){
  // 执行语句
  }
- 安全调用符(?.)
  安全调用符是为了解决可控变量在使用时需要通过 if…else 语句判断而复杂所提供的一个安全符 ” ?.“,专门用于调用可空类型变量中的成员方法和属性，其语法格式为：
  变量?.成员
  其作用是为了判断变量是否为null,不为 null,才调用变量的成员方法或属性。
  var name: String? = null;
  var length = name?.length;
- Elvis 操作符(?：)
  Elvis 操作符(?:)出现时未来解决在使用安全调用符调用可控变量中的成员方法或属性时，如果当前变量为空，则会返回一个 null 值，但有时及时当前变量为null，也不想返回一个null值而是指定一个默认值出现的。
  Elvis 操作符(?：) 域法格式为：
  表达式?:表达式。
  如果左侧表达式非空，则返回左侧表达式的值，否则返回右边默认值。
  var name: String? = null;
  var length = name?.length ?: 0;
- 非空断言(!!.)
  非空断言(!!.) 会将任何变量(可空类型变量或者非空类型变量)转换为非空类型变量，若该变量为空则抛出异常。
  
  var str: String? = null;
  var length = str!!.length;
  运行结果：
  抛出异常。

jiaqiangziji

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Kotlin基础

Kotlin 基础变量Kotlin 变量分为两种：- 可变变量+ 可变变量对应于Java 的普通变量。+ 可变变量用 var 来修饰，可以进行多次修改。- 不可变变量+ 不可变变量相当于Java中用final关键字修饰的常量。+ 不可变变量用 val 来修饰，只能进行一次初始化。声明变量： var 变量名：数据类型 val 变量名：数据类型示例：...
复制链接

扫一扫

专栏目录