Kotlin学习笔记(一)—基础语法与Java全面PK(1)

2401_84023683

于 2024-04-30 01:25:47 发布

阅读量144

点赞数 5

分类专栏：程序员文章标签： java kotlin 学习

本文链接：https://blog.csdn.net/2401_84023683/article/details/138330602

版权

程序员专栏收录该内容

202 篇文章 0 订阅

订阅专栏

对应Java代码:

void sum(int a,int b){
System.out.println(String.format(“sum of %d and %d is %d”,a,b,a+b));

}1234

Tips:在字符串内 $符号后带变量名代表这个变量的值，$ 符号后带{},代表{}里面表达式的值。Unit返回类型相当于Java里的void

4.函数参数含数组参数：

fun printArray(vararg args:Int){
for(arg in args){
print("$arg ")
}
}12345

fun printArray(args:Array){
for(arg in args){
print("$arg ")
}
}12345

对应Java代码:

void printArray(Integer…args){
for(Integer arg:args){
System.out.println(arg+" ");
}

}123456

2.定义常量和变量

1.Kotlin常量相当于Java里对变量添加final，定义时复制后将不能改变其值:

val a: Int = 1 // 直接定义时赋值
val b = 2 // 在常量声明时可不指定类型
val c: Int // 定义时不赋值
c = 3 // 在其他地方才赋值1234

注意:第三种方式定义常量时必须要制定类型，否则编译出错。
对应Java代码

final int a = 1;
final int b = 2;
final int c = 3;123

这里Kotlin和Java的区别就体现出来了，Java声明常量必须要给常量赋初值，必须指定常量的类型。而Kotlin可以不声明常量类型，并且可以延后给常量赋值，但需要声明常量类型。

3.注释

Kotlin的注释跟Java完全一样。

4.使用条件表达式

Kotlin使用条件表达式与Java的写法有出入，但效果没明显区别。

fun max(a:Int,b:Int):Int{
return if(a>b) a else b
}123

fun max(a:Int,b:Int):=if(a>b) a else b1

对应的Java代码

int max(int a,int b){
return a > b ? a : b;
}123

5.可空的参数或返回值

Kotlin对于可空的参数和返回值，在声明参数类型后加?符号，表示参数可空。

fun toInt(s:String):Int?{
return s.toIntOrNull();
}123

对应Java代码

@Nullable Integer toInt(String s){
return Integer.valueOf(s);
}123

注意：在Java代码中Integer.value()方法若参数不可转为整形会crash。

6.检查类型

Kotlin在检查类型写法也与Java不同。Kotlin用is代替了Java的Instanceof。此外，如果变量被检查符合某种类型，无需进行强制转换，系统将自动将变量转换为那个类型。例如:

fun getStringLength(obj:Any):Int?{
if(obj is String){
//系统自动将obj转换为String类型
return obj.length
} else
//return obj.length 在此处使用obj.length将报错
return null
}12345678

fun getStringLength(obj:Any):Int?{
if(obj !is String){
return null
//return obj.length 在此处使用obj.length将报错
} else
//系统自动将obj转换为String类型
return obj.length
}12345678

对应的Java代码

@Nullable Integer getStringLength(Object obj){
if(obj instanceof String){
String s = (String)obj;
return s.length;
}else{
return null;
}
}12345678

7.遍历数组类型

Kotlin在遍历数组上与Java上也有区别,如下：

val items = listOf(“apple”, “banana”, “kiwi”)
for (item in items) {
println(item)
}1234

val items = listOf(“apple”, “banana”, “kiwi”)
for (index in items.indices) {
println(“item at $index is ${items[index]}”)
}1234

对应的Java代码

final String[] items = new String[]{“apple”,“banana”,“kiwi”};
for(String item:items){
System.out.println(item);
}1234

final String[] items = new String[]{“apple”,“banana”,“kiwi”};
int size = items.size;
for(int i = 0;i<size;i++){
System.out.printlin(String.format(“item at %d is %s”,i,items[i]));
}12345

8.while循环

Kotlin在用while循环与Java无任何区别。

9.范围检查

Kotlin相对于Java简化了数据范围检测的写法。如下:

1.检查数据是否在数值范围内

val x = 10
val y = 9
if (x in 1…y+1) {
println(“fits in range”)
}12345

对应Java代码

final x = 10;
final y =9;
if(x>=1&&x<=y+1){
System.out.println(“fits in range”);
}12345

2.检查数据是否在数值范围外

val list = listOf(“a”, “b”, “c”)

if (-1 !in 0…list.lastIndex) {
println(“-1 is out of range”)
}
if (list.size !in list.indices) {
println(“list size is out of valid list indices range too”)
}12345678

对应Java代码

final Array list = Arrays.asList(“a”,“b”,“c”);
if(-1 < 0||-1 > list.size()-1){
System.out.println(“-1 is out of range”);
}
if(list.size()<0||list.size()>list.size()-1){
System.out.println(“list size is out of valid list indices range too”);
}1234567

通过上面的对比，Kotlin的代码效率就体现出来了。

3.遍历数值范围

for (x in 1…5) {
print(x)
}123

对应的Java代码

for(int i=0;i<=5;i++){
System.out.print(x+“”);
}123

4.步进遍历数值范围

for (x in 1…10 step 2) {
print(x)
}
println()
for (x in 9 downTo 0 step 3) {
print(x)
}1234567

对应的Java代码

int x;
for(x = 1;x<=10;x+=2){
System.out.print(x+“”);
}
System.out.print(“\n”);
for(x=9;x>=0;x-=3){
System.out.print(x+“”);
}12345678

通过对比，Kotlin的代码简洁性又体现出来了。

10.when表达式

when表达式是Kotlin新增的用于多情况的取值判定。来见识一下他的威力:

fun describe(obj:Any):String =
when(obj){
1 -> “One”
“Hello” -> “Greeting”
is Long -> “Long”
!is String -> “isn’t String”
else -> “Unknown”
}12345678

对应的Java代码:

String describe(Object obj){
if(obj instanceof Integer && (int)obj == 1){
return “One”;
}else if(obj instanceof String &&（(String)obj）.equal(“Hello”)){
return “Greeting”;
}else if(obj instanceof Long){
return “Long”;
}else if(!(obj instanceof String)){
return “isn’t String”;
}else{
return “Unknown”;
}
}12345678910111213

我已经是尽量简洁的用Java代码还原，但是由于Java代码需要各种判定类型，强制转换，简洁性终究还是被Kotlin完胜。此外，when还能这样操作:

val a = “bbb”;
val b = 5;
when{
a.equal(“bbb”) -> {
print(“a is bbb”)
print(“a”)
}
b == 5 -> print -> print(“b == 5”)
}123456789

两种when的区别是前者是对()内的对象进行判定。后者是不指定对象。

11.集合操作

Kotlin对于集合的操作可谓是对Java代码的又一颠覆。对比一下：

1.判断对象是否在集合内

val fruits = setOf(“apple”,“banana”,“orange”)
if(“apple” in fruits){
println(“apple is in fruits”)
}1234

而Java代码

final Set fruits = new HashSet();
fruits.add(“apple”);
fruits.add(“banana”);
fruits.add(“orange”);
if(fruits.contains(“apple”)){
System.out.println(“apple is in fruits”);
}
12345678

2.对集合的一系列操作

val fruits = listOf(“banana”, “avocado”, “apple”, “kiwi”)
fruits
.filter { it.startsWith(“a”) } //过滤非a开头的元素
.sortedBy { it } //对集合排序
.map { it.toUpperCase() } //重新映射
.forEach { println(it) } //逐个操作集合元素123456

看到这代码是不是似曾相识。这分明就是RxJava换种写法。这种写法我们称作 lambda表达式，是一种链式操作。在filter{}等里面，有一个常量参数it代表当前元素。
用原生的Java写写看:

…//fruit的初始化
Set tempSet = new TreeSet<>();
for(String fruit :fruits){
if(fruit.startWith(“a”)){
//遍历过程中不能对集合进行增删操作，否则容易出现异常
tempSet.add(fruit);
}
}
fruits.removeAll(tempSet);
Collections.sort(fruits);
for(String fruit:fruits){
String s = fruit.toUpperCase();
forEach(s);
}

void forEach(String s){
System.out.println(s);
}123456789101112131415161718

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

12.类的继承和接口

Kotlin在继承类和接口实现上比Java有了很大的区别。其一，实例化对象不用加new。其二，Java写在构造器的参数在Kotlin可以在类声明时在类名后声明。其他的不可描述。

fun main(args: Array) {
val rectangle = Rectangle(5.0, 2.0) //no ‘new’ keyword required
val triangle = Triangle(3.0, 4.0, 5.0)
println(“Area of rectangle is ${rectangle.calculateArea()}, its perimeter is ${rectangle.perimeter}”)
println(“Area of triangle is ${triangle.calculateArea()}, its perimeter is ${triangle.perimeter}”)
}

abstract class Shape(val sides: List) {
val perimeter: Double get() = sides.sum()
abstract fun calculateArea(): Double
}

interface RectangleProperties {
val isSquare: Boolean
}

class Rectangle(
var height: Double,
var length: Double
) : Shape(listOf(height, length, height, length)), RectangleProperties {
override val isSquare: Boolean get() = length == height
override fun calculateArea(): Double = height * length
}

class Triangle(
var sideA: Double,
var sideB: Double,
var sideC: Double
) : Shape(listOf(sideA, sideB, sideC)) {
override fun calculateArea(): Double {
val s = perimeter / 2
return Math.sqrt(s * (s - sideA) * (s - sideB) * (s - sideC))
}
}12345678910111213141516171819202122232425262728293031323334

用Java代码

… // main函数省略

abstract class Shape{
private double perimeter;
Shape(List sides){
for(Double side :sides){
perimeter+=side;
}
}
abstract double calculateArea();
}

interface RectangleProperties {
boolean isSquare();
}

class Rectangle extends Shape{
double height;
double length;

惊喜

最后还准备了一套上面资料对应的面试题（有答案哦）和面试时的高频面试算法题（如果面试准备时间不够，那么集中把这些算法题做完即可，命中率高达85%+）

in函数省略

abstract class Shape{
private double perimeter;
Shape(List sides){
for(Double side :sides){
perimeter+=side;
}
}
abstract double calculateArea();
}

interface RectangleProperties {
boolean isSquare();
}

class Rectangle extends Shape{
double height;
double length;

惊喜

[外链图片转存中…(img-0kOz86Tw-1714411529640)]

[外链图片转存中…(img-zYTMxeE5-1714411529641)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

2401_84023683

关注

5
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Kotlin学习笔记(一)—基础语法与Java全面PK(1)

1.Kotlin常量相当于Java里对变量添加final，定义时复制后将不能改变其值:val a: Int = 1 // 直接定义时赋值val b = 2 // 在常量声明时可不指定类型val c: Int // 定义时不赋值c = 3 // 在其他地方才赋值1234注意:第三种方式定义常量时必须要制定类型，否则编译出错。对应Java代码123这里Kotlin和Java的区别就体现出来了，Java声明常量必须要给常量赋初值，必须指定常量的类型。
复制链接

扫一扫