移动端六大语言速记：第4部分 - 数据结构

移动端六大语言速记：第4部分 - 数据结构

本文对比Java、Kotlin、Flutter(Dart)、Python、ArkTS和Swift这六种移动端开发语言的数据结构特性，帮助开发者快速掌握各语言的语法差异。

4. 数据结构

4.1 数组与列表

各语言数组与列表的语法对比：

语言	数组声明	动态列表	初始化语法	常用操作
Java	Type[] arr	List<Type>	new Type[]{...}	add, remove, get, set
Kotlin	Array<Type>	List<Type>	arrayOf(...)	add, remove, get, set
Dart	List<Type>	List<Type>	[...]	add, remove, []
Python	list	list	[...]	append, remove, []
ArkTS	Type[]	Array<Type>	[...]	push, pop, []
Swift	[Type]	[Type]	[...]	append, remove, []

示例对比

Java:

// 固定大小数组
int[] numbers = new int[5];  // 创建固定大小数组
int[] nums = {1, 2, 3, 4, 5};  // 数组字面量// 动态列表
List<String> fruits = new ArrayList<>();
fruits.add("Apple");  // 添加元素
fruits.remove(0);  // 删除元素
String fruit = fruits.get(0);  // 获取元素
fruits.set(0, "Banana");  // 修改元素// 列表操作
int size = fruits.size();  // 获取大小
boolean contains = fruits.contains("Apple");  // 检查包含
fruits.clear();  // 清空列表

Kotlin:

// 数组
val numbers = Array(5) { 0 }  // 创建固定大小数组
val nums = arrayOf(1, 2, 3, 4, 5)  // 数组字面量// 列表
val fruits = mutableListOf<String>()  // 可变列表
fruits.add("Apple")  // 添加元素
fruits.removeAt(0)  // 删除元素
val fruit = fruits[0]  // 获取元素
fruits[0] = "Banana"  // 修改元素// 列表操作
val size = fruits.size  // 获取大小
val contains = "Apple" in fruits  // 检查包含
fruits.clear()  // 清空列表// 不可变列表
val immutableList = listOf(1, 2, 3)

Dart:

// 列表（Dart中没有独立的数组类型）
List<int> numbers = List<int>.filled(5, 0);  // 固定大小列表
var nums = [1, 2, 3, 4, 5];  // 列表字面量// 可增长列表
List<String> fruits = [];
fruits.add("Apple");  // 添加元素
fruits.removeAt(0);  // 删除元素
String fruit = fruits[0];  // 获取元素
fruits[0] = "Banana";  // 修改元素// 列表操作
int length = fruits.length;  // 获取长度
bool contains = fruits.contains("Apple");  // 检查包含
fruits.clear();  // 清空列表// 不可变列表
const immutableList = [1, 2, 3];

Python:

# 列表（Python中没有独立的数组类型）
numbers = [0] * 5  # 创建固定大小列表
nums = [1, 2, 3, 4, 5]  # 列表字面量# 列表操作
fruits = []  # 创建空列表
fruits.append("Apple")  # 添加元素
fruits.pop(0)  # 删除并返回元素
fruit = fruits[0]  # 获取元素
fruits[0] = "Banana"  # 修改元素# 其他操作
size = len(fruits)  # 获取长度
contains = "Apple" in fruits  # 检查包含
fruits.clear()  # 清空列表# 列表推导式
squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

ArkTS:

// 数组
let numbers: number[] = new Array(5).fill(0);  // 创建固定大小数组
let nums: number[] = [1, 2, 3, 4, 5];  // 数组字面量// 数组操作
let fruits: string[] = [];
fruits.push("Apple");  // 添加元素
fruits.splice(0, 1);  // 删除元素
let fruit: string = fruits[0];  // 获取元素
fruits[0] = "Banana";  // 修改元素// 其他操作
let length: number = fruits.length;  // 获取长度
let contains: boolean = fruits.includes("Apple");  // 检查包含
fruits.length = 0;  // 清空数组// 数组方法
let mapped = nums.map(x => x * 2);  // 映射
let filtered = nums.filter(x => x > 2);  // 过滤

Swift:

// 数组
var numbers = Array(repeating: 0, count: 5)  // 创建固定大小数组
var nums = [1, 2, 3, 4, 5]  // 数组字面量// 数组操作
var fruits: [String] = []  // 创建空数组
fruits.append("Apple")  // 添加元素
fruits.remove(at: 0)  // 删除元素
let fruit = fruits[0]  // 获取元素
fruits[0] = "Banana"  // 修改元素// 其他操作
let count = fruits.count  // 获取数量
let contains = fruits.contains("Apple")  // 检查包含
fruits.removeAll()  // 清空数组// 不可变数组
let immutableArray = [1, 2, 3]

4.2 字典/哈希表

各语言字典/哈希表的语法对比：

语言	类型声明	初始化语法	常用操作	特殊特性
Java	Map<K,V>	new HashMap<>()	put, get, remove	支持多种Map实现
Kotlin	Map<K,V>	mutableMapOf()	put, get, remove	支持只读Map
Dart	Map<K,V>	{}	[], putIfAbsent	字面量语法简洁
Python	dict	{}	[], get, pop	支持字典推导式
ArkTS	Map<K,V>	new Map()	set, get, delete	支持链式操作
Swift	[K:V]	[:]	[], updateValue	支持可选链

示例对比

Java:

// 创建字典
Map<String, Integer> scores = new HashMap<>();// 添加和修改
scores.put("Alice", 95);
scores.put("Bob", 87);// 获取值
Integer score = scores.get("Alice");  // 95
Integer defaultScore = scores.getOrDefault("Charlie", 0);// 检查键
boolean hasKey = scores.containsKey("Alice");// 删除
scores.remove("Bob");// 遍历
for (Map.Entry<String, Integer> entry : scores.entrySet()) {System.out.println(entry.getKey() + ": " + entry.getValue());
}

Kotlin:

// 创建字典
val scores = mutableMapOf<String, Int>()// 添加和修改
scores["Alice"] = 95
scores["Bob"] = 87// 获取值
val score = scores["Alice"]  // 95
val defaultScore = scores.getOrDefault("Charlie", 0)// 检查键
val hasKey = "Alice" in scores// 删除
scores.remove("Bob")// 遍历
for ((name, score) in scores) {println("$name: $score")
}// 不可变字典
val immutableMap = mapOf("one" to 1, "two" to 2)

Dart:

// 创建字典
Map<String, int> scores = {};// 添加和修改
scores["Alice"] = 95;
scores["Bob"] = 87;// 获取值
int? score = scores["Alice"];  // 95
int defaultScore = scores["Charlie"] ?? 0;// 检查键
bool hasKey = scores.containsKey("Alice");// 删除
scores.remove("Bob");// 遍历
scores.forEach((key, value) {print("$key: $value");
});// 不可变字典
const immutableMap = {"one": 1, "two": 2};

Python:

# 创建字典
scores = {}# 添加和修改
scores["Alice"] = 95
scores["Bob"] = 87# 获取值
score = scores["Alice"]  # 95
default_score = scores.get("Charlie", 0)# 检查键
has_key = "Alice" in scores# 删除
del scores["Bob"]# 遍历
for name, score in scores.items():print(f"{name}: {score}")# 字典推导式
square_dict = {x: x**2 for x in range(5)}

ArkTS:

// 创建字典
let scores = new Map<string, number>();// 添加和修改
scores.set("Alice", 95);
scores.set("Bob", 87);// 获取值
let score = scores.get("Alice");  // 95
let defaultScore = scores.get("Charlie") ?? 0;// 检查键
let hasKey = scores.has("Alice");// 删除
scores.delete("Bob");// 遍历
scores.forEach((value, key) => {console.log(`${key}: ${value}`);
});

Swift:

// 创建字典
var scores: [String: Int] = [:]// 添加和修改
scores["Alice"] = 95
scores["Bob"] = 87// 获取值
let score = scores["Alice"]  // Optional(95)
let defaultScore = scores["Charlie", default: 0]// 检查键
let hasKey = scores.keys.contains("Alice")// 删除
scores.removeValue(forKey: "Bob")// 遍历
for (name, score) in scores {print("\(name): \(score)")
}// 不可变字典
let immutableDict = ["one": 1, "two": 2]

4.3 集合

各语言集合的语法对比：

语言	类型声明	初始化语法	常用操作	特殊特性
Java	Set<T>	new HashSet<>()	add, remove	支持多种Set实现
Kotlin	Set<T>	mutableSetOf()	add, remove	支持只读Set
Dart	Set<T>	{}	add, remove	字面量语法简洁
Python	set	set()	add, remove	支持集合推导式
ArkTS	Set<T>	new Set()	add, delete	支持链式操作
Swift	Set<T>	[]	insert, remove	支持集合运算

示例对比

Java:

// 创建集合
Set<String> fruits = new HashSet<>();// 添加元素
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Apple");  // 重复元素不会被添加// 检查元素
boolean hasApple = fruits.contains("Apple");// 删除元素
fruits.remove("Banana");// 集合运算
Set<String> otherFruits = new HashSet<>(Arrays.asList("Apple", "Orange"));
fruits.addAll(otherFruits);  // 并集
fruits.retainAll(otherFruits);  // 交集
fruits.removeAll(otherFruits);  // 差集

Kotlin:

// 创建集合
val fruits = mutableSetOf<String>()// 添加元素
fruits.add("Apple")
fruits.add("Banana")
fruits.add("Apple")  // 重复元素不会被添加// 检查元素
val hasApple = "Apple" in fruits// 删除元素
fruits.remove("Banana")// 集合运算
val otherFruits = setOf("Apple", "Orange")
val union = fruits union otherFruits  // 并集
val intersect = fruits intersect otherFruits  // 交集
val diff = fruits - otherFruits  // 差集// 不可变集合
val immutableSet = setOf("Apple", "Banana")

Dart:

// 创建集合
Set<String> fruits = {};// 添加元素
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Apple");  // 重复元素不会被添加// 检查元素
bool hasApple = fruits.contains("Apple");// 删除元素
fruits.remove("Banana");// 集合运算
Set<String> otherFruits = {"Apple", "Orange"};
Set<String> union = fruits.union(otherFruits);  // 并集
Set<String> intersect = fruits.intersection(otherFruits);  // 交集
Set<String> diff = fruits.difference(otherFruits);  // 差集

Python:

# 创建集合
fruits = set()# 添加元素
fruits.add("Apple")
fruits.add("Banana")
fruits.add("Apple")  # 重复元素不会被添加# 检查元素
has_apple = "Apple" in fruits# 删除元素
fruits.remove("Banana")  # 如果元素不存在会抛出异常
fruits.discard("Banana")  # 如果元素不存在不会抛出异常# 集合运算
other_fruits = {"Apple", "Orange"}
union = fruits | other_fruits  # 并集
intersect = fruits & other_fruits  # 交集
diff = fruits - other_fruits  # 差集# 集合推导式
squares = {x**2 for x in range(5)}

ArkTS:

// 创建集合
let fruits = new Set<string>();// 添加元素
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Apple");  // 重复元素不会被添加// 检查元素
let hasApple = fruits.has("Apple");// 删除元素
fruits.delete("Banana");// 遍历元素
fruits.forEach(fruit => {console.log(fruit);
});// 转换为数组
let fruitsArray = Array.from(fruits);

Swift:

// 创建集合
var fruits: Set<String> = []// 添加元素
fruits.insert("Apple")
fruits.insert("Banana")
fruits.insert("Apple")  // 重复元素不会被添加// 检查元素
let hasApple = fruits.contains("Apple")// 删除元素
fruits.remove("Banana")// 集合运算
let otherFruits: Set = ["Apple", "Orange"]
let union = fruits.union(otherFruits)  // 并集
let intersect = fruits.intersection(otherFruits)  // 交集
let diff = fruits.subtracting(otherFruits)  // 差集// 不可变集合
let immutableSet: Set = ["Apple", "Banana"]

4.4 高级数据结构

各语言支持的高级数据结构对比：

语言	栈	队列	树	其他特殊结构
Java	Stack	Queue, Deque	TreeMap, TreeSet	PriorityQueue
Kotlin	MutableList	ArrayDeque	TreeMap, TreeSet	PriorityQueue
Dart	List	Queue	SplayTreeMap	HashSet
Python	list	collections.deque	-	heapq
ArkTS	Array	Array	Map	Set
Swift	Array	Array	-	IndexSet

示例对比

Java栈和队列:

// 栈
Stack<Integer> stack = new Stack<>();
stack.push(1);
stack.push(2);
int top = stack.pop();  // 2// 队列
Queue<Integer> queue = new LinkedList<>();
queue.offer(1);
queue.offer(2);
int first = queue.poll();  // 1// 双端队列
Deque<Integer> deque = new ArrayDeque<>();
deque.addFirst(1);
deque.addLast(2);

Kotlin栈和队列:

// 使用MutableList作为栈
val stack = mutableListOf<Int>()
stack.add(1)
stack.add(2)
val top = stack.removeAt(stack.lastIndex)  // 2// 使用ArrayDeque作为队列
val queue = ArrayDeque<Int>()
queue.addLast(1)
queue.addLast(2)
val first = queue.removeFirst()  // 1

Dart栈和队列:

// 使用List作为栈
List<int> stack = [];
stack.add(1);
stack.add(2);
int top = stack.removeLast();  // 2// 队列
Queue<int> queue = Queue<int>();
queue.add(1);
queue.add(2);
int first = queue.removeFirst();  // 1

Python栈和队列:

# 使用list作为栈
stack = []
stack.append(1)
stack.append(2)
top = stack.pop()  # 2# 使用deque作为队列
from collections import deque
queue = deque()
queue.append(1)
queue.append(2)
first = queue.popleft()  # 1# 优先队列（堆）
import heapq
heap = []
heapq.heappush(heap, 2)
heapq.heappush(heap, 1)
smallest = heapq.heappop(heap)  # 1

ArkTS栈和队列:

// 使用Array作为栈
let stack: number[] = [];
stack.push(1);
stack.push(2);
let top = stack.pop();  // 2// 使用Array作为队列
let queue: number[] = [];
queue.push(1);
queue.push(2);
let first = queue.shift();  // 1

Swift栈和队列:

// 使用Array作为栈
var stack: [Int] = []
stack.append(1)
stack.append(2)
let top = stack.removeLast()  // 2// 使用Array作为队列
var queue: [Int] = []
queue.append(1)
queue.append(2)
let first = queue.removeFirst()  // 1

总结

通过对比六种移动端开发语言的数据结构特性，我们可以发现：

1. 数组与列表：

   • Java区分固定数组和动态List
   • Kotlin提供了丰富的集合操作符
   • Dart统一使用List类型
   • Python的列表最为灵活，支持推导式
   • ArkTS和Swift的数组操作类似JavaScript

2. 字典/哈希表：

   • Java的Map接口有多种实现
   • Kotlin支持便捷的键值对语法
   • Dart和Python的字典语法最简洁
   • ArkTS的Map类似JavaScript
   • Swift的字典支持可选链和默认值

3. 集合：

   • 所有语言都支持基本的集合操作
   • Kotlin和Swift提供了强大的集合运算操作符
   • Python的集合支持推导式
   • Java提供了多种Set实现

4. 高级数据结构：

   • Java提供了最完整的数据结构实现
   • Kotlin复用了Java的数据结构
   • Python通过标准库提供了丰富的数据结构
   • 其他语言主要依赖基本数据结构的组合

选择合适的数据结构对于程序的性能和可维护性至关重要。在实际开发中，应根据具体需求和语言特性选择最适合的数据结构实现方式。