四.kotlin中的操作符(Operator)
一元操作符
- 只有一个操作数的操作符称为一元操作符,例如:
a++自增操作符就是一元操作符,变量a是唯一一个操作数
一元操作符对应的方法
| 一元操作符 | 对应的方法 |
|---|---|
| = | |
| + | unaryPlus() |
| - | unaryMinus() |
| ++ | inc() |
| -- | dec() |
| ! | not() |
赋值操作符
- "="一个等号就是赋值操作符
//1.赋值操作符 =
//将字面量10赋值给变量a
var a = 10;
println("使用赋值操作符给变量a赋值为$a");
正操作符(算术操作符)
- "+"表示操作数的是正数
//将一个正数赋值给变量a
val a = +10;
负操作符(算术操作符)
- "-"表示操作数是负数
//将一个负数赋值给变量a
val a = -10;
自增操作符
-
"++"自增操作符
- 前自增,操作数先自增再进行其他操作
- 后自增,操作数先进行其他操作最后再进行自增
//2.自增操作符 ++
val b = a++;
println("后自增后的值为$b");
val c = ++a;
println("前自增后的值为$c");
自减操作符
-
"--"自减操作符
- 前自减,操作数先自减再进行其他操作
- 后自减,操作数先进行其他操作最后再进行自减
//3.自减操作符 --
val d = a--;
println("后自减后的值为$d");
val e = --a;
println("前自减后的值为$e");
否定操作符(取反操作符)
- "!"感叹号就是否定操作符,用于对Boolean类型的数据进行取反
//4.取反操作符 !
val f = true;
println("取反前的值为$f,取反后的值为${!f}");
二元操作符
二元操作符对应的方法
| 二元操作符 | 对应的方法 |
|---|---|
| + | plus() |
| - | minus() |
| * | times() |
| / | div() |
| % | rem() |
| += | |
| -= | |
| *= | |
| /= | |
| %= | |
| compareTo() | |
| < | compareTo() |
| >= | compareTo() |
| <= | compareTo() |
四则运算的操作符
- "+"加号操作符,相当于调用第一个操作数的plus()方法
- "-"减号操作符,相当于调用第一个操作数的minus()方法
- "*"乘号操作符,相当于调用第一个操作数的times()方法
- "/"除法操作符,相当于调用第一个操作数的div()方法
- "%"取余操作符,相当于调用第一个操作数的rem()方法
- "+="加法复合操作符,相当于调用第一个操作数的plusAssign()方法
- "-="减法复合操作符,相当于调用第一个操作数的minusAssign()方法
- "*="乘法复合操作符,相当于调用第一个操作数的timesAssign()方法
- "/="除法复合操作符,相当于调用第一个操作数的divAssign()方法
- "%="取余复合操作符,相当于调用第一个操作数的remAssign()方法
//1.四则运算操作符
val num1 = 10;
val num2 = 3;
var result = 0;
//1.1加法操作符
result = num1 + num2;
//等价的方法plus()
// result = num1.plus(num2);
//加法操作符: result = num1 + num2,result = 13
println("加法操作符: result = num1 + num2,result = $result");
//1.2减法操作符
result = num1 - num2;
//等价的方法minus()
// result = num1.minus(num2);
//减法操作符: result = num1 - num2,result = 7
println("减法操作符: result = num1 - num2,result = $result");
//1.3乘法操作符
result = num1 * num2;
//等价的方法times()
// result = num1.times(num2);
//乘法操作符: result = num1 * num2,result = 30
println("乘法操作符: result = num1 * num2,result = $result");
//1.4除法操作符
result = num1 / num2;
//等价的方法div()
// result = num1.div(num2);
//除法操作符: result = num1 / num2,result = 3
println("除法操作符: result = num1 / num2,result = $result");
//1.5取模操作符
result = num1 % num2;
//等价的方法rem()
// result = num1.rem(num2);
//取模操作符: result = num1 % num2,result = 1
println("取模操作符: result = num1 % num2,result = $result");
//1.6加法复合操作符
result = 0;
result += num1;
//等价下面的写法
// result = result + num1;
// result = result.plus(num1);
//加法复合操作符: result += num1,result = 10
println("加法复合操作符: result += num1,result = $result");
//1.7减法复合操作符
result = 0;
result -= num2;
//等价下面的写法
// result = result - num2;
// result = result.minus(num2);
//减法复合操作符: result -= num2,result = -3
println("减法复合操作符: result -= num2,result = $result");
//1.8乘法复合操作符
result = 1;
result *= num1;
//等价下面的写法
// result = result * num1;
// result = result.times(num1);
//乘法复合操作符: result *= num1,result = 10
println("乘法复合操作符: result *= num1,result = $result");
//1.9除法复合操作符
result = 10;
result /= num2;
//等价下面的写法
// result = result / num2;
// result = result.div(num2);
//除法复合操作符: result /= num2,result = 3
println("除法复合操作符: result /= num2,result = $result");
//1.10取模复合操作符
result = 10;
result %= num2;
//等价下面的写法
// result = result % num2;
// result = result.rem(num2);
//取模复合操作符: result %= num2,result = 1
println("取模复合操作符: result %= num2,result = $result");
比较操作符
- ">"大于操作符,相当于调用第一个操作数的compareTo()方法
- "<"小于操作符,相当于调用第一个操作数的compareTo()方法
- ">="大于等于操作符,相当于调用第一个操作数的compareTo()方法
- "<="小于等于操作符,相当于调用第一个操作数的compareTo()方法
- 如果操作数是基本数据类型可以直接使用比较操作符
- 如果操作数不是基础数据类型,可以让该类显示Comparable接口,然后就可以使用比较操作符
//2.比较操作符
//比较操作符等价的方法是compareTo()
// 该方法返回1表示第一个操作数大于第二个操作数
// 该方法返回-1表示第一个操作数小于第二个操作数
// 该方法返回0表示第一个操作数等于第二个操作数
//2>1=1,2<1=-1,1=1=0
println("2>1=${"2".toInt().compareTo(1)},2<1=${"1".toInt().compareTo(2)},1=1=${"1".toInt().compareTo(1)}");
//2.1大于操作符
//大于操作符: num1 > num2,结果 = true
println("大于操作符: num1 > num2,结果 = ${num1 > num2}");
//2.2小于操作符
//小于操作符: num1 < num2,结果 = false
println("小于操作符: num1 < num2,结果 = ${num1 < num2}");
//2.3大于等于操作符
//大于等于操作符: num1 >= num2,结果 = true
println("大于等于操作符: num1 >= num2,结果 = ${num1 >= num2}");
//2.4小于等于操作符
//小于等于操作符: num1 <= num2,结果 = false
println("小于等于操作符: num1 <= num2,结果 = ${num1 <= num2}");
位运算方法
- kotlin中没有专门的位运算操作符,只有对应的位运算方法
- 没有无符号左移
| kotlin位运算方法 | 对应Java中的位运算操作符 | 含义 | |
|---|---|---|---|
| and() | & | 按位与 | |
| or() | 按位或 | ||
| inv() | ! | 按位取反 | |
| xor() | 按位异或 | ||
| shl() | << | 左移 | |
| shr() | >> | 右移 | |
| ushr() | (Java中没有无符号数) | 无符号右移 |
//3.位运算方法
//3.1位与方法
result = num1.and(num2);
//简写
// result = num1 and num2;
//0b1010和0b11进行位与操作: result = 10
println("0b${num1.toString(2)}和0b${num2.toString(2)}进行位与操作: result = ${result.toString(2)}");
//3.2位或方法
result = num1.or(num2);
//简写
// result = num1 or num2;
//0b1010和0b11进行位或操作: result = 1011
println("0b${num1.toString(2)}和0b${num2.toString(2)}进行位或操作: result = ${result.toString(2)}");
//3.3按位取反操作符,没有简写,符号位也会被取反
result = num1.inv();
//0b1010进行位取反操作: result = -1011
println("0b${num1.toString(2)}进行位取反操作: result = ${result.toString(2)}");
//3.4异或方法
result = num1.xor(num2);
//简写
// result = num1 xor num2;
//0b1010和0b11进行异或操作: result = 1001
println("0b${num1.toString(2)}和0b${num2.toString(2)}进行异或操作: result = ${result.toString(2)}");
//3.5位左移方法,左移1位
result = num1.shl(1);
//简写
// result = num1 shl 1;
//0b1010进行位左移操作: result = 10100
println("0b${num1.toString(2)}进行位左移操作: result = ${result.toString(2)}");
//3.6位右移方法,右移1位
result = num1.shr(1);
//简写
// result = num1 shr 1;
//0b1010进行位右移操作: result = 101
println("0b${num1.toString(2)}进行位右移操作: result = ${result.toString(2)}");
//3.7无符号右移方法,右移1位
result = num1.ushr(1);
//简写
// result = num1 ushr 1;
//0b1010进行无符号位右移操作: result = 101
println("0b${num1.toString(2)}进行无符号位右移操作: result = ${result.toString(2)}");
猫王操作符(?:)
- kotlin中没有三元表达式,只有类似的猫王操作符(Elvis)
- "?:"猫王操作符,当第一个操作数为空时,返回指定的默认值,第一个操作数不为空时,返回第一个操作数,语法格式:
操作数?:默认值
//4.0猫王操作符
// var person = null;
var person = "我正在学习kotlin";
val res = person?:"空的";
println("猫王操作符案例,person变量的值是$res");
相等操作符
-
kotlin中有两种相等操作符,"等同"和"等于"
-
在kotlin中
- 不可空数值类型底层实现为Java的基础类型,所以只要值相同,两者就是"等于"
- 可空数值类型的底层实现为Java的包装类,所有两个可空的数值变量是不"等于"的
- "=="等同操作符,两个操作数的"值"相同时即为等同
- "==="等于操作符,两个操作数指向同一个引用时才可以被认为是等于
//5相等操作符,"==" 与 "==="
val a = 10;
val b = 10;
//不可空的数值类型相等,a==b的结果是true,a===b的结果是true
println("不可空的数值类型相等,a==b的结果是${a==b},a===b的结果是${a===b}");
//这里注意范围在8bit内的数值,在Java的包装类中是指向同一引用的,也就是说如果两个可控变量的值为100,则它们使用 === 操作符返回的也是true
val x:Int? = 100;
val y:Int? = 100;
//可空的数值类型相等,x==y的结果是true,x===y的结果是true
println("可空的数值类型相等,x==y的结果是${x==y},x===y的结果是${x===y}");
val n:Int? = 1000;
val m:Int? = 1000;
//可空的数值类型相等,n==m的结果是true,n===m的结果是false
println("可空的数值类型相等,n==m的结果是${n==m},n===m的结果是${n===m}");
//对象类型
val date1 = Date(100);
val date2 = Date(100);
//不可空的对象类型相等,date1==date2的结果是true,date1===date2的结果是false
println("不可空的对象类型相等,date1==date2的结果是${date1==date2},date1===date2的结果是${date1===date2}");
"in"和"!in"操作符
- 这两者属于逻辑操作符
- "in"操作符,相当于调用第二个操作数的contains()方法,用于判断第一个操作数是否在第二个操作数的范围内
- "!in"操作符,相当于调用第二个操作数的minus()方法,用于判断第一个操作数是否不在第二个操作数的范围内
//6."in"和"!in"操作符
val s = "我在学Kotlin";
//我在学Kotlin 是否包含'Kotlin'字符串,结果是true,我在学Kotlin 是否不包含'Java'字符串,结果是true
println("$s 是否包含'Kotlin'字符串,结果是${"Kotlin" in s},$s 是否不包含'Java'字符串,结果是${"Java" !in s}");
val arr = arrayOf(1,2,3,4,5);
//[1,2,3,4,5]是否包含数字3,结果是true,[1,2,3,4,5] 是否不包含数字6,结果是true
println("[${arr.joinToString(",")}]是否包含数字3,结果是${3 in arr},[${arr.joinToString(",")}] 是否不包含数字6,结果是${6 !in arr}");
"[]"索引操作符
- 用于操作操作数中指定位置的数据
//7.索引操作符
val data = arrayOf('我', '爱', '学', "Kotlin");
//这里相当于调用变量data的get()方法
val c = s[0];
//等价写法
// val c = s.get(0);
println("[${data.joinToString()}] 索引0的值为$c");
//这里相当于调用变量data的set()方法
data[0] = '你';
//等价写法
// data.set(0,"你");
println("此时,[${data.joinToString()}] 索引0的值为${data[0]}");
".."区间操作符
- ".."区间操作符,两个小点,主要用于创建区间对象,相当于调用第一个操作数的rangeTo()方法
- 区间两端都是闭区间
//8.".."区间操作符
//[1,10]
val seq = 1..10;
//等价写法
// val startNum = 1;
// val seq = startNum.rangeTo(10);
for (i in seq){
println(i);
}
操作符重写
- kotlin中的操作符实际上是调用定义在类中的操作符方法,所以只需要我们为自定义的类添加这些方法就可以使用这些操作符
- "operator"关键字用于修饰操作符方法,每一个操作符方法都必须使用该关键字进行修饰
- 自定义操作符方法时,也需要使用指定的方法名,如自定义"+"操作符的方法,就必须使用plus()作为方法名
- 案例:自定义操作符方法,实现
蓝色 + 黄色 = 绿色
class Blue{
private val color = "蓝色";
//"+"加法操作符重写,使用operator操作符关键字修饰,使用指定的方法名plus()
operator fun plus(color:Yellow):Green{
return Green();
}
fun info(){
println("我是$color");
}
}
class Green {
private val color = "绿色";
fun info(){
println("我是$color");
}
}
class Yellow {
private val color = "黄色";
fun info(){
println("我是$color");
}
}
fun main(){
//操作符重写
val blue = Blue();
val yellow = Yellow();
val green = blue + yellow;
green.info();
}
