// for 循环
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
// foreach 循环
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
for (String item : list) {
System.out.println(item);
}
// while 循环
int i = 0;
while (i < 5) {
System.out.println(i);
i++;
}
# for 循环
for i in range(5):
print(i)
# foreach 循环
list = ["A", "B"]
for item in list:
print(item)
# while 循环
i = 0
while i < 5:
print(i)
i += 1
// for 循环
for i := 0; i < 5; i++ {
fmt.Println(i)
}
// foreach 循环
list := []string{"A", "B"}
for _, item := range list {
fmt.Println(item)
}
// while 循环
i := 0
for i < 5 {
fmt.Println(i)
i++
}
11. 字符串处理
特性
Java
Python
Go
字符串类型
String 类型
字符串是基本类型
字符串是基本类型
字符串声明
String str = "hello";
str = "hello"
str := "hello"
字符串连接
String result = str1 + str2;
result = str1 + str2
result := str1 + str2
字符串长度
int length = str.length();
length = len(str)
length := len(str)
子串提取
String sub = str.substring(2, 5);
sub = str[2:5]
sub := str[2:5]
字符串拼接
String result = String.join("-", strs);
result = "-".join(strs)
result := strings.Join(strs, "-")
字符串查找
int index = str.indexOf("o");
index = str.find("o")
index := strings.Index(str, "o")
字符串替换
String newStr = str.replace("old", "new");
new_str = str.replace("old", "new")
newStr := strings.Replace(str, "old", "new", -1)
字符串分割
String[] parts = str.split(",");
parts = str.split(",")
parts := strings.Split(str, ",")
12 .1 数组与切片
特性
Java
Python
Go
数组声明
int[] arr = new int[5];
arr = [1, 2, 3, 4, 5]
var arr [5]int
切片声明
不适用
不适用
slice := []int{1, 2, 3, 4, 5}
长度固定
是
否
否
长度可变
否
是
是
访问元素
int element = arr[0];
element = arr[0]
element := slice[0]
切片操作
不适用
sub_slice = slice[1:3]
subSlice := slice[1:3]
添加元素
不适用
slice.append(6)
slice = append(slice, 6)
删除元素
不适用
del slice[2]
slice = append(slice[:2], slice[3:]...)
12. 2 各语言的List的对比
特性
Java
Python
Go
数据结构
ArrayList、LinkedList 等
List（内置类型）
切片（slice）
动态大小
是
是
是
内存管理
由JVM自动管理内存
由Python解释器自动管理内存
由Go运行时自动管理内存
元素类型
可以是任意Java对象类型
可以是任意Python对象类型
可以是任意Go语言类型
迭代器
使用 Iterator 进行迭代
使用 for 循环或迭代器进行迭代
使用 for range 循环进行迭代
切片
不支持
不支持
内置类型为切片，类似动态数组
列表推导式
不支持
支持
不支持
代码示例
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
// 创建一个 ArrayList
List<Integer> list = new ArrayList<>();
// 添加元素到列表
list.add(1);
list.add(2);
list.add(3);
// 打印列表内容
System.out.println("Java List:");
for (int i : list) {
System.out.println(i);
}
}
}
# 创建一个列表
list = [1, 2, 3]
# 打印列表内容
print("Python List:")
for i in list:
print(i)
package main
import "fmt"
func main() {
// 创建一个切片
list := []int{1, 2, 3}
// 打印切片内容
fmt.Println("Go List:")
for _, value := range list {
fmt.Println(value)
}
}
12.3 各语言Set的对比
特性
Java
Python
Go
数据结构
HashSet、TreeSet 等
set（内置类型）
map[key]struct{}（模拟 set）
动态大小
是
是
是
内存管理
由JVM自动管理内存
由Python解释器自动管理内存
由Go运行时自动管理内存
元素类型
可以是任意Java对象类型
可以是任意Python对象类型
可以是任意Go语言类型
元素唯一性
是
是
是
操作方式
使用 add()、remove()、contains() 等方法
使用 add()、remove()、in 运算符等方法，可以进行交集、并集、差集等常见的集合操作
使用 map 的键值对操作
遍历
使用迭代器或 foreach 循环进行遍历
使用 for 循环或迭代器进行遍历
使用 for range 循环或键值对遍历
集合推导式
不支持
不支持
不支持
代码示例
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(String[] args) {
// 创建一个 HashSet
Set<Integer> set = new HashSet<>();
// 添加元素到集合
set.add(1);
set.add(2);
set.add(3);
// 打印集合内容
System.out.println("Java Set:");
for (int i : set) {
System.out.println(i);
}
}
}
# 创建一个集合
set = {1, 2, 3}
# 打印集合内容
print("Python Set:")
for i in set:
print(i)
package main
import "fmt"
func main() {
// 创建一个模拟 set 的 map
set := make(map[int]struct{})
// 添加元素到集合
set[1] = struct{}{}
set[2] = struct{}{}
set[3] = struct{}{}
// 打印集合内容
fmt.Println("Go Set:")
for key := range set {
fmt.Println(key)
}
}
import (
"encoding/json"
"fmt"
)
func main() {
// 将结构体转换为 JSON 字符串
type Person struct {
Name string `json:"name"`
Age int `json:"age"`
}
person := Person{Name: "John", Age: 30}
jsonBytes, _ := json.Marshal(person)
jsonStr := string(jsonBytes)
fmt.Println(jsonStr) // 输出 {"name":"John","age":30}
// 将 JSON 字符串转换为结构体
var newPerson Person
json.Unmarshal(jsonBytes, &newPerson)
fmt.Println(newPerson.Name) // 输出 John
fmt.Println(newPerson.Age) // 输出 30
}
28. xml数据格式的处理
特性
Java
Python
Go
XML 库
DOM、SAX、JAXB、Dom4j 等
xml.etree.ElementTree、lxml 等
encoding/xml、第三方库如 xmlpath 等
XML 解析
使用 DOM 解析器或 SAX 解析器进行解析
使用 ElementTree 模块进行解析
使用 encoding/xml 包进行解析
XML 生成
使用 DOM 或 JAXB 进行 XML 文档的生成
使用 ElementTree 模块进行 XML 文档的生成
使用 encoding/xml 包进行 XML 文档的生成
XPath 支持
支持使用 XPath 进行 XML 查询和遍历
不支持 XPath，但可以使用 ElementTree 模块进行遍历
支持使用 XPath 进行 XML 查询和遍历
命名空间支持
支持处理 XML 命名空间
支持处理 XML 命名空间
支持处理 XML 命名空间
错误处理
提供异常机制进行错误处理
可以使用异常机制或返回 None 进行错误处理
提供错误返回值或错误接口进行错误处理
代码示例
import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception {
// 读取 XML 文件
File file = new File("example.xml");
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(file);
// 解析 XML
NodeList nodeList = doc.getElementsByTagName("book");
for (int i = 0; i < nodeList.getLength(); i++) {
Node node = nodeList.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE) {
Element element = (Element) node;
String title = element.getElementsByTagName("title").item(0).getTextContent();
String author = element.getElementsByTagName("author").item(0).getTextContent();
System.out.println("Book: " + title + " by " + author);
}
}
}
}
import xml.etree.ElementTree as ET
# 读取 XML 文件
tree = ET.parse('example.xml')
root = tree.getroot()
# 解析 XML
for book in root.findall('book'):
title = book.find('title').text
author = book.find('author').text
print("Book: {} by {}".format(title, author))
package main
import (
"encoding/xml"
"fmt"
"os"
)
// 定义 XML 结构体
type Book struct {
Title string `xml:"title"`
Author string `xml:"author"`
}
func main() {
// 读取 XML 文件
file, _ := os.Open("example.xml")
defer file.Close()
// 解码 XML
var books []Book
xml.NewDecoder(file).Decode(&books)
// 打印结果
for _, book := range books {
fmt.Printf("Book: %s by %s\n", book.Title, book.Author)
}
}
454
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
