Java & Kotlin 公共语法特征

函数

int calculate(int i , int j) {
    return i + j;
}

fun calculate(i: Int, j: Int): Int {
    return i + j;
}

循环

for (int i = 0; i < 10; i++) {
    // 循环体
}

int[] array = {1, 2, 3};
for (int num : array) {
    // 循环体
}

int i = 0;
while (i < 10) {
    // 循环体
    i++;
}

for (i in 0 until 10) {
    // 循环体
}

val array = intArrayOf(1, 2, 3)
for (num in array) {
    // 循环体
}

var i = 0
while (i < 10) {
    // 循环体
    i++
}

变量声明

int num = 10;
String str = "Hello";
final int CONSTANT_NUM = 100;

var num: Int = 10
val str: String = "Hello"
val x = 10                         // Kotlin 可以自动推断出 x 是 Int 类型
var topLevelVar: Int = 10          // 可变顶层属性
val topLevelVal: String = "Hello"  // 不可变顶层属性
lateinit var lateinitVar: String   // 延迟初始化的可变属性
val lazyVal: Int by lazy {         // 懒加载属性
    // 初始化代码
    println("Lazy initialization")
    10
}

Lambda表达式

public interface Comparator<T> {
    int compare(T o1, T o2);
}

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");
Collections.sort(list, (a, b) -> a.compareTo(b));

Collections.sort(list, (a, b) -> {
    System.out.println("Comparing " + a + " and " + b);
    return a.compareTo(b);
});

val list: MutableList<String> = ArrayList()
list.add("Apple")
list.add("Banana")
list.add("Orange")
Collections.sort(list, { a, b -> a.compareTo(b) })

Collections.sort(list) { a, b ->
    println("Comparing $a and $b")
    a.compareTo(b)
}

数组

• 特点：固定大小，存储相同类型的元素
• 优点：随机访问元素效率高
• 缺点：大小固定，插入和删除元素相对较慢

int[] ints = new int[3];
ints[0] = 1;
ints[1] = 2;
ints[2] = 3;

int[] ints = {1,2,3};

String[] strings = new String[3];
strings[0] = "a";
strings[1] = "b";
strings[2] = "c";

String[] strings = {"a", "b", "c"};

val ints = IntArray(3)
ints[0] = 1
ints[1] = 2
ints[2] = 3

val ints = intArrayOf(1, 2, 3)

val strings = Array(3) { "" }
strings[0] = "a"
strings[1] = "b"
strings[2] = "c"

val strings = arrayOf("a", "b", "c")

List

List<String> arrayList = new ArrayList<>();
List<String> arrayList = new LinkedList<>();

val mutableList: MutableList<String> = ArrayList()
val mutableList: MutableList<String> = LinkedList() // Kotlin没有LinkedList，使用Java的

ArrayList

• 特点：动态数组，可变大小
• 优点：高效的随机访问和快速尾部插入
• 缺点：中间插入和删除相对较慢

LinkedList

• 特点：双向链表，元素之间通过指针连接
• 优点：插入和删除元素高效，迭代器性能好
• 缺点：随机访问相对较慢

HashSet

• 特点：无序集合，基于HashMap实现
• 优点：高效的查找和插入操作
• 缺点：不保证顺序

TreeSet

• 特点：TreeSet 是有序集合，底层基于红黑树实现，不允许重复元素
• 优点：提供自动排序功能，适用于需要按顺序存储元素的场景
• 缺点：性能相对较差，不允许插入 null 元素

HashMap

• 特点：基于哈希表实现的键值对存储结构
• 优点：高效的查找、插入和删除操作
• 缺点：不保证顺序

TreeMap

• 特点：基于红黑树实现的有序键值对存储结构
• 优点：有序，支持按照键的顺序遍历
• 缺点：插入和删除相对较慢