10天学会kotlin DAY1 kotlin 和 Java 的不同之处

} while (condition){

}

“for” 循环

Kotlin：

使用..运算符(range 表达式) 来表示区间：

val oneToTen = 1…10

for (i in 1…100){

println(i)

}

fun isNotDigit(c: Char) = c !in ‘0’…‘9’

区间是包含或者闭合的，意味着第二个值始终是区间的一部分。

迭代 map：

val binaryResp = TreeMap<Char, String>()

for (c in ‘A’…‘Z’) {

val binary = Integer.toBinaryString(c.toInt())

binaryResp[c] = binary

}

for ((letter, binary) in binaryResp) {

println(“$letter = $binary”)

}

使用下标迭代：

val list = arrayListOf(“10”, “11”, “111”)

for ((index, element) in list.withIndex()) {

println(“$index : $element”)

}

Java：

for (int i = 1; i <= 100; i++) {

System.out.println(i);

}

TreeMap<Character, String> binaryResp = new TreeMap<>();

Character[] characters = {‘A’, ‘B’, ‘C’,‘D’,‘Z’};

for (Character c : characters) {

String binary = Integer.toBinaryString©;

binaryResp.put(c, binary);

}

Set<Map.Entry<Character, String>> entries = binaryResp.entrySet();

for (Map.Entry<Character, String> entry : entries) {

System.out.println(entry.getKey() + “=” + entry.getValue());

}

List list = Arrays.asList(“10”, “11”, “111”);

for (int i = 0, size = list.size(); i < size; i++) {

System.out.println(i + “:” + list.get(i));

}

6.异常

---

抛出异常

Kotlin：

val percentage = 50

if (percentage !in 0…100)

throw IllegalArgumentException(“A percentage value must be between 0 and 100: $percentage”)

不必使用 new 关键字来创建异常实例。

与 Java 不同的是，Kotlin 中的 throw 结构是一个表达式，能作为另一个表达式的一部分使用：

val percentage =

if (number in 0…100) {

number

} else {

throw IllegalArgumentException(“A percentage value must be between 0 and 100: $percentage”)

}

Java：

int percentage = 50;

if (percentage < 0 || percentage > 100) {

throw new IllegalArgumentException("A percentage value must be between 0 and 100: " + percentage);

}

“try” “catch” 和 “finally”

Kotlin：

fun readNumber(reader: BufferedReader): Int? {

try {

val line = reader.readLine()

return Integer.parseInt(line)

} catch (e: NumberFormatException) {

return null

} finally {

reader.close() //finally 的作用和 Java 中的一样

}

}

Kotlin 不区分受检异常和未受检异常。 在这里没有处理readLine方法抛出的 IOException 异常。

“try” 也可以作为表达式：

fun readNumber(reader: BufferedReader): Int? {

return try {

val line = reader.readLine()

Integer.parseInt(line)

} catch (e: NumberFormatException) {

null

} finally {

reader.close()

}

}

Java：

public Integer readNumber(BufferedReader reader) throws IOException {

try {

String line = reader.readLine();

return Integer.parseInt(line);

} catch (NumberFormatException e) {

return null;

} finally {

reader.close();

}

}

IOException 是一个受检异常。在 Java 中必须显示地处理。必须声明函数能抛出的所有受检异常。如果调用另外一个函数，需要处理这个函数的受检异常，或者声明函数也能抛出这些异常。

7.创建集合

---

Kotlin：

val set = hashSetOf(1, 7, 53) //创建 HashSet 集合

val arrayList = arrayListOf(1, 7, 53) //创建 List 集合

val map = hashMapOf(1 to “one”, 2 to “two”, 3 to “three”) //创建 HashMap 集合

set.javaClass // Kotlin 的 javaClass 等价于 Java 的 getClass()

arrayList.last() // 获取列表的最后一个

arrayList.max() //得到数字列表的最大值

Java：

Set set = new HashSet(); //创建 HashSet 集合

set.add(1);

set.add(7);

set.add(53);

List arrayList = new ArrayList<>(); //创建 List 集合

arrayList.add(1);

arrayList.add(7);

arrayList.add(53);

Map<Integer, String> map = new HashMap<>(); //创建 HashMa

必看视频！获取2024年最新Java开发全套学习资料 备注Java

p 集合

map.put(1, “one”);

map.put(2, “two”);

map.put(3, “three”);

set.getClass(); //Java 的 getClass() 等价于 Kotlin 的 javaClass

if (arrayList.size() > 0) // 获取列表的最后一个

arrayList.get(arrayList.size() - 1);

Collections.max(arrayList, new Comparator() { //得到数字列表的最大值

@Override

public int compare(Integer o1, Integer o2) {

if (o1 > o2) {

return 1;

} else if (o1 == o2) {

return 0;

}

return -1;

}

});

8.函数

---

命名参数

Kotlin：

假设现在有一个函数，它的作用是在集合元素中添加分割符号，然后将集合转化为字符串。

kotlin 函授默认都是public，其实kotlin 的函数，更规范，先有输入，再有输出

fun joinToString(collection: Collection, separator: String, prefix: String, postfix: String): String {

val result = StringBuffer(prefix)

for ((index, element) in collection.withIndex()) {

if (index > 0) result.append(separator)

result.append(element)

}

result.append(postfix)

return result.toString()

}

在调用函数时，显示地标明一些参数的名称，避免参数混淆：

val arrayList = arrayListOf(1, 7, 53)

joinToString(arrayList, separator = “;”, prefix = “[”, postfix = “]”)

Java：

public String joinToString(Collection collection, String separator, String prefix, String postfix) {

StringBuilder sb = new StringBuilder(prefix);

Iterator iterator = collection.iterator();

int i = 0;

while (iterator.hasNext()) {

if (i > 0) sb.append(separator);

sb.append(iterator.next());

i++;

}

sb.append(postfix);

return sb.toString();

}

在调用函数时，标明参数的名称：

List arrayList = new ArrayList<>();

arrayList.add(1);

arrayList.add(7);

arrayList.add(53);

joinToString(arrayList, /* separator /“;”,/ prefix / “[”, / postfix */ “]”);

默认参数

Kotlin：

声明函数的时候，指定参数的默认值，避免创建重载函数：

fun joinToString(

collection: Collection,

separator: String = “;”,

prefix: String = “”,

postfix: String = “”

): String

在调用函数时，可以用所有参数来调用，也可以省略掉部分参数：

joinToString(arrayList, “;”, “”, “”)

joinToString(arrayList)

joinToString(arrayList, “;”)

当使用常规的调用语法时，必须按照函数声明中定义的参数顺序来给定参数，可以省略的只有在末尾的参数。如果使用命名参数，可以省略中间的一些参数，也可以以任意顺序只给定需要的参数：

joinToString(arrayList, prefix = “[”,postfix = “]”)

Java：

public String joinToString(Collection collection) {

return joinToString(collection, “;”, “”, “”);

}

public String joinToString(Collection collection, String separator) {

return joinToString(collection, separator, “”, “”);

}

public String joinToString(Collection collection, String separator, String prefix, String postfix) {

//…

}

因为Java 没有默认值的概念，从Java 中调用 Kotlin 函数的时候，必须显示地指定所有参数值。如果需要从 Java 代码中做频繁的调用，而且希望它能对 Java 的调用者简便，可以用 @JvmOverloads 注解它。

@JvmOverloads

fun joinToString(

collection: Collection,

separator: String = “;”,

prefix: String = “”,

postfix: String = “”

): String

此时，编译器就会生成如下重载函数：

public String joinToString(Collection collection) {

}

public String joinToString(Collection collection, String separator) {

}

public String joinToString(Collection collection, String separator, String prefix) {

}

public String joinToString(Collection collection, String separator, String prefix, String postfix) {

}

每个重载函数的默认参数值都会被省略。

9.静态工具类

---

顶层函数（静态函数）

Kotlin：

Kotlin 中的新定义：顶层函数，也就是把函数直接放到代码文件的顶层，不用从属于任何的类。这些文件顶层的函数依然是包内的成员，如果需要从包外访问它，则需要 import ，但不再需要额外包一层。

实例：把 joinToString 直接放到 strings 的包中，创建一个名为 Join.kt 的文件。

package com.example.kotlin.strings

fun joinToString(

collection: Collection,

separator: String = “;”,

prefix: String = “”,

postfix: String = “”

): String {

val result = StringBuffer(prefix)

for ((index, element) in collection.withIndex()) {

if (index > 0) result.append(separator)

result.append(element)

}

result.append(postfix)

return result.toString()

}

在 Kotlin 中调用顶层函数：

com.example.kotlin.strings.joinToString(arrayList, “;”, “”, “”)

1

在 Java 中调用顶层函数：

com.example.kotlin.strings.JoinKt.joinToString(arrayList, /* separator /“;”,/ prefix / “[”, / postfix */ “]”);

要改变包含Kotlin 顶层函数的生成的类的名称，需要为这个文件添加 @JvmName 的注解，将其放到这个文件的开头，位于包名的前面：

@file:JvmName(“StringFunctions”)

package com.example.kotlin.strings

fun joinToString(

collection: Collection,

separator: String = “;”,

prefix: String = “”,

postfix: String = “”

): String {

//…

}

然后在 Java 中再调用顶层函数，类型需要改变：

com.example.kotlin.strings.StringFunctions.joinToString(arrayList, /* separator /“;”,/ prefix / “[”, / postfix */ “]”);

顶层函数对应 Java 中的静态函数。

Java：

public class JoinJava {

public static String joinToString(Collection collection, String separator, String prefix, String postfix) {

StringBuilder sb = new StringBuilder(prefix);

Iterator iterator = collection.iterator();

int i = 0;

while (iterator.hasNext()) {

if (i > 0) sb.append(separator);

sb.append(iterator.next());

i++;

}

sb.append(postfix);

return sb.toString();

}

}

顶层属性（静态变量）

Kotlin:

Kotlin 中的新定义：顶层属性，和顶层函数一样，属性也是放到文件的顶层。

@file:JvmName(“StringFunctions”)

package com.example.kotlin.strings

const val LANGUAGE_KOTLIN: String = “Kotlin”

在 Kotlin 中调用顶层函数：

com.example.kotlin.strings.LANGUAGE_KOTLIN

在 Java 中调用顶层函数：

com.example.kotlin.strings.StringFunctions.LANGUAGE_KOTLIN;

顶层属性对应 Java 中的静态属性。

Java：

public static final String LANGUAGE_KOTLIN = “Kotlin”;

10.可变参数

---

Kotlin：

参数通过 vararg 来修饰：

fun convertNumbersToList(vararg values: Int) {

println(values)

}

convertNumbersToList(1, 2, 3, 5)

Java：

public void convertNumbersToList(int …values){

System.out.println(values);

}

convertNumbersToList(1,2,3,4);

11.字符串和正则表达式

---

Kotlin：

在三重引号中的字符串，不会对任何字符进行转义，包括反斜杠。

实例：使用正则表达式解析文件路径。

文件路径格式：

“/users/wangjiang/koltin-book/chapter.adoc”

“/users/wangjiang/koltin-book/” 目录

“chapter” 文件名

“.adoc” 扩展名

函数解析文件路径：

fun parsePath(path: String) {

val regex = “”“(.+)/(.+).(.+)”“”.toRegex()

val matchResult = regex.matchEntire(path)

if (matchResult != null) {

val (directory, filename, extension) = matchResult.destructured

println(“Dir:$directory,name:$filename,ext:$extension”)

}

}

三重引号字符串除了避免转义字符以外，还可以包含任何字符，包括换行符。

val kotlinLogo = “”"| //

.| //

.|/ \

“”“.trimMargin(”.")

Log.d(“parsePath”,kotlinLogo)

| //

| //

|/ \

Java：

函数解析文件路径：

public void parsePath(String path) {

Pattern pattern = Pattern.compile(“(.+)/(.+)\.(.+)”);

Matcher matcher = pattern.matcher(path);

if (matcher.find()) {

Log.d(“parsePath”, “Dir:” + matcher.group(1) + “,name:” + matcher.group(2) + “,ext:” + matcher.group(3) );

}

}

总结

最后

文章中涉及到的知识点我都已经整理成了资料，录制了视频供大家下载学习，诚意满满，希望可以帮助在这个行业发展的朋友，在论坛博客等地方少花些时间找资料，把有限的时间，真正花在学习上，所以我把这些资料，分享出来。相信对于已经工作和遇到技术瓶颈的朋友们，在这份资料中一定都有你需要的内容。