Java,Python和Go语言特性及语法差异对比

    前段时间一直在找工作,比较颓废,很长时间都没有更新博客了,最近公司的项目需要用到Python语言和Go语言, 所以又重新学习了一下Python语言和Go语言,现在做一些总结,方便以后复习使用,同时也给其他初学Python语言和Go语言的同行一些参考。

目录

 1.Java、Python和Go语言的简要介绍

2.  Java、Python和Go语言跨平台支持方面的对比

3. Java、Python和Go语言的编译和构建工具对比

4.  性能调优和优化方面

5.  测试框架方面

 6.各语言的数据类型与变量声明的差异

7.各语言空值与空类型的表示

8.各语言声明函数方法和控制结构的差异

9. 各语言的异常与错误处理方式

10 .循环结构和迭代的差异

11.  字符串处理

12 .1 数组与切片

12. 2 各语言的List的对比

 12.3 各语言Set的对比

13. 映射(map)与字典

14.  对象与类

15. 包导入的对比

16 .注释的对比 

17. 数学运算和数值类型

18. 日期和时间的处理

19. 文件IO操作 

20. 网络编程 

21. 并发模型

22. 可拓展化和模块化

23. 内存管理和垃圾回收

24 .web应用方面

 25. 应用安全认证与授权方面

26. ORM(对象关系映射)操作方面

27 .Json数据处理方面

28. xml数据格式的处理


   1.Java、Python和Go语言的简要介绍

语言简介
JavaJava是一种跨平台的面向对象编程语言,由Sun Microsystems公司于1995年推出。它的设计目标是“一次编写,到处运行”,即具有跨平台、可移植性的特点。Java拥有强大的生态系统和丰富的库,广泛用于企业级应用开发、移动应用开发等领域。
PythonPython是一种简单易学、功能强大的高级编程语言,由Guido van Rossum于1991年创建。它具有清晰简洁的语法和丰富的标准库,被广泛应用于Web开发、科学计算、人工智能等领域。Python支持多种编程范式,包括面向对象、函数式编程等。
GoGo是由Google开发的一种静态类型、编译型、并发性强的编程语言,于2009年发布。Go语言具有简洁的语法、高效的并发模型和内建的垃圾回收器,适用于构建高性能、可靠、可维护的软件系统。Go语言被广泛应用于云计算、网络编程、分布式系统等领域。
2.  Java、Python和Go语言跨平台支持方面的对比
特性JavaPythonGo
跨平台性Java 通过 JVM 实现跨平台Python 通过解释器实现跨平台Go 通过编译器和标准库实现跨平台
可执行文件Java 程序需要在特定平台上运行 JVMPython 程序需要在特定平台上运行解释器Go 可以编译为特定平台的可执行文件
原生支持Java 语言本身没有提供原生支持Python 语言本身没有提供原生支持Go 语言提供原生支持,不需要依赖外部库
库和框架Java 生态系统提供丰富的跨平台库和框架Python 生态系统提供丰富的跨平台库和框架Go 生态系统提供丰富的跨平台库和框架
3. Java、Python和Go语言的编译和构建工具对比
特性JavaPythonGo
编译方式使用 javac 编译器使用 CPython 解释器使用 Go 编译器
构建工具使用 Maven、Gradle 等进行项目构建使用 setuptools、pip 等进行包管理和构建使用 Go 工具链中的 go build、go install 等进行项目构建
依赖管理

使用 Maven、Gradle 等进行

依赖管理,依赖配置文件为pom.xml或者build.gradle

使用 pip 进行依赖管理,通过requirements.txt文件管理依赖,

使用pip install命令安装依赖

使用 Go Modules 进行依赖管理,通过go.mod文件管理依赖,使用go mod命令安装依赖
打包方式打包为 JAR 文件打包为 egg、wheel 等打包为可执行文件
4.  性能调优和优化方面
特性JavaPythonGo
性能调优工具使用 Profiler、JVisualVM 等进行性能分析使用 Profiler、CProfile 等进行性能分析使用 Profiler、pprof 等进行性能分析
内存管理使用 JVM 参数进行堆内存设置和垃圾回收调优使用内存管理工具进行内存分析和调优使用 Go 内建的垃圾回收器进行内存管理和调优
并发性能使用线程池和并发集合进行性能优化使用多进程和协程进行性能优化使用 Go 协程和通道进行并发编程和性能优化
网络性能使用 NIO 进行非阻塞网络编程和性能优化使用异步框架和非阻塞 IO 进行性能优化使用并发模型和轻量级网络库进行性能优化
5.  测试框架方面
特性JavaPythonGo
测试框架JUnit、TestNG 等unittest、pytest 等testing、testify 等
断言库使用 assert 关键字进行断言使用 assert 语句进行断言使用 testing 包提供的断言函数
测试运行器使用 java 命令行或 IDE 运行测试使用 unittest 模块或命令行运行测试使用 go test 命令行或 IDE 运行测试
测试报告可以生成详细的测试报告可以生成详细的测试报告可以生成简单的测试报告
 6.各语言的数据类型与变量声明的差异
特性JavaPythonGo
类型系统静态类型系统动态类型系统静态类型系统
变量声明使用关键字 int, String 等声明;示例:int num=10使用关键字 var 或直接赋值声明;示例:num=10使用关键字 var 或类型名称声明; 示例: var num int=10或者num :=10
类型推断不支持类型推断支持类型推断支持类型推断
零值有明确的零值不明确的零值有明确的零值
7.各语言空值与空类型的表示
特性JavaPythonGo
空值使用 null 表示空值使用 None 表示空值使用 nil 表示空值
空类型使用 nil 表示空类型
空安全需要显式检查空值,否则可能引发空指针异常需要显式检查 None,否则可能引发 NoneType 错误需要显式检查 nil,否则可能引发空指针异常
8.各语言声明函数方法和控制结构的差异
特性JavaPythonGo
函数声明使用关键字 publicprivate无需关键字声明,使用 def使用关键字 func
返回多个值不支持返回多个值支持直接返回多个值,使用元组支持直接返回多个值,函数签名指定多个返回类型
控制结构使用 {} 包围代码块使用缩进表示代码块使用 {} 包围代码块
函数(方法)声明示例

public int add(int a,int b){

     return a+b;

}

def add(a,b):

     return a+b

func add(a,b int) int {

      return a+b

}

函数调用int result = add(3, 5);result = add(3, 5)result := add(3, 5)
默认参数不支持支持支持
可变参数支持支持支持
可变参数示例
public class Main {
    public static void main(String[] args) {
        printNumbers(1, 2, 3, 4, 5);
    }

    // 带有可变参数的函数
    public static void printNumbers(int... numbers) {
        System.out.println("Printing numbers:");
        for (int number : numbers) {
            System.out.println(number);
        }
    }
}

# 可变参数函数示例
def print_numbers(*args):
    print("Printing numbers:")
    for number in args:
        print(number)

# 调用可变参数函数
print_numbers(1, 2, 3, 4, 5)

package main

import "fmt"

// 可变参数函数示例
func printNumbers(numbers ...int) {
    fmt.Println("Printing numbers:")
    for _, number := range numbers {
        fmt.Println(number)
    }
}

func main() {
    // 调用可变参数函数
    printNumbers(1, 2, 3, 4, 5)
}

匿名函数不支持支持支持
闭包不支持支持支持
控制结构if-else、switch-case、for、while 等if-else、for、while 等if-else、for、switch-case 等

9. 各语言的异常与错误处理方式
特性JavaPythonGo
异常类型Checked 异常和 Unchecked 异常内置异常类型和自定义异常错误类型
异常捕获使用 try-catch-finally 语句捕获异常使用 try-except-else-finally 语句捕获异常使用 defer-recover 捕获错误
异常抛出使用 throw 关键字抛出异常使用 raise 关键字抛出异常使用 errors.New() 函数抛出错误
异常链可以将异常链起来,形成异常链可以将异常链起来,形成异常链Go 不支持异常链
自定义异常可以自定义异常类可以自定义异常类Go 不支持自定义异常类
代码示例:
try {
    // 可能抛出异常的代码
    int result = 10 / 0; // 会抛出 ArithmeticException 异常
} catch (ArithmeticException e) {
    // 捕获异常并处理
    System.out.println("发生了算术异常:" + e.getMessage());
} finally {
    // 可选的 finally 语句块
    System.out.println("这里是 finally 语句块");
}

try:
    # 可能抛出异常的代码
    result = 10 / 0  # 会抛出 ZeroDivisionError 异常
except ZeroDivisionError as e:
    # 捕获异常并处理
    print("发生了除零异常:", e)
finally:
    # 可选的 finally 语句块
    print("这里是 finally 语句块")

import (
    "errors"
    "fmt"
)

func main() {
    defer func() {
        if r := recover(); r != nil {
            // 捕获错误并处理
            fmt.Println("发生了错误:", r)
        }
    }()
    // 可能发生错误的代码
    err := someFunction() // 会返回一个错误
    if err != nil {
        // 处理错误
        panic(err)
    }
}

func someFunction() error {
    // 可能返回错误的逻辑
    return errors.New("这是一个错误")
}

10 .循环结构和迭代的差异
特性JavaPythonGo
for 循环for (int i = 0; i < 5; i++) {...}for i in range(5): ...for i := 0; i < 5; i++ {...}
foreach 循环for (String item : list) {...}for item in list: ...for _, item := range list {...}
while 循环while (condition) {...}while condition: ...for condition {...}
do-while 循环支持不支持不支持
迭代器使用 Iterator 接口进行迭代使用 for...in 循环或迭代器使用 range 关键字进行迭代
嵌套循环支持多层嵌套循环支持多层嵌套循环支持多层嵌套循环
代码示例
// 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.  字符串处理
特性JavaPythonGo
字符串类型String 类型字符串是基本类型字符串是基本类型
字符串声明String str = "hello";str = "hello"str := "hello"
字符串连接String result = str1 + str2;result = str1 + str2result := 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 数组与切片
特性JavaPythonGo
数组声明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的对比
特性JavaPythonGo
数据结构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的对比
特性JavaPythonGo
数据结构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)
    }
}

 注意:Python中创建一个空集合(Set)必须用 set() 而不是 { },因为 { } 是用来创建一个空字典

13. 映射(map)与字典
特性JavaPythonGo
映射声明使用 Map 接口及实现类使用字典(dict)使用映射(map)
声明与初始化Map<String, Integer> map = new HashMap<>();map = {}map := make(map[string]int)
添加键值对map.put("key", value);map["key"] = valuemap["key"] = value
获取键值对int value = map.get("key");value = map["key"]value := map["key"]
删除键值对map.remove("key");del map["key"]delete(map, "key")
键的遍历使用 Map.keySet()Map.entrySet() 方法使用 for key in dict:for key, value in dict.items():使用 for key, value := range map {}
14.  对象与类
特性JavaPythonGo
类声明使用关键字 class使用关键字 class使用关键字 typestruct
对象实例化ClassName obj = new ClassName();obj = ClassName()var obj ClassNameobj := ClassName{}
方法声明在类中声明方法,使用关键字 publicprivate在类中声明方法,无需关键字在结构体中声明方法,使用关键字 func
继承使用 extends 关键字使用括号表示基类,如 class SubClass(BaseClass):使用匿名字段表示组合,如 type SubClass struct { BaseClass }
多态支持支持不直接支持,但可以通过接口实现多态
15. 包导入的对比
特性JavaPythonGo
导入方式使用 import 关键字使用 import 关键字使用 import 关键字
导入路径使用完整的包路径,如 import java.util.ArrayList;直接指定包名,如 import numpy使用相对或绝对路径,如 import "fmt"
别名导入不支持支持支持
16 .注释的对比 
特性JavaPythonGo
单行注释使用 ///* */使用 #''' '''使用 ///* */
多行注释使用 /* */使用 ''' '''使用 /* */
文档注释使用特定格式的注释,如 Javadoc使用特定格式的注释,如 docstrings支持在函数或方法前使用注释说明
17. 数学运算和数值类型
特性JavaPythonGo
数值类型整数、浮点数、双精度浮点数等整数、浮点数整数、浮点数
运算符+, -, *, /, %+, -, *, /, //, %+, -, *, /, %
整数除法会保留整数部分,不会自动转换为浮点数结果为浮点数结果为整数
类型转换需要显式转换自动进行类型转换需要显式转换
数学函数提供 Math 类和相关方法提供 math 模块和相关函数提供 math 包和相关函数
18. 日期和时间的处理
特性JavaPythonGo
日期时间类java.util.Date, java.time.*datetime 模块time
日期时间格式化使用 SimpleDateFormat 类进行格式化使用 strftime() 函数进行格式化使用 time.Format() 方法进行格式化
日期时间解析使用 SimpleDateFormat 类进行解析使用 strptime() 函数进行解析使用 time.Parse() 方法进行解析
时间戳使用 System.currentTimeMillis() 获取毫秒级时间戳使用 time.time() 获取秒级时间戳使用 time.Now().Unix() 获取秒级时间戳
时区处理使用 java.time.ZoneIdjava.time.ZonedDateTime使用 pytz 库或 datetime 类的 tzinfo 属性使用 time.LoadLocation()time.In() 方法
19. 文件IO操作 
特性JavaPythonGo
文件读取使用 FileInputStreamBufferedReader使用 open() 函数使用 os.Open() 函数
文件写入使用 FileOutputStreamBufferedWriter使用 open() 函数使用 os.Create() 函数
文件关闭需要显式调用 close() 方法关闭文件流使用 with 语句自动关闭文件使用 defer 关键字延迟关闭文件
文件路径操作使用 java.nio.file.Path 类进行路径操作使用 os.path 模块进行路径操作使用 path/filepath 包进行路径操作
文件权限使用 File 类和 setWritable(), setReadable() 方法使用 os.chmod() 函数设置文件权限使用 os.Chmod() 函数设置文件权限
20. 网络编程 
特性JavaPythonGo
客户端套接字使用 Socket 类和 ServerSocket 类进行套接字编程使用 socket 模块进行套接字编程使用 net 包进行套接字编程
服务器套接字使用 ServerSocket 类进行服务器套接字编程使用 socket 模块进行服务器套接字编程使用 net 包进行服务器套接字编程
HTTP请求使用 HttpURLConnection 类进行HTTP请求使用 requests 库进行HTTP请求使用 net/http 包进行HTTP请求
HTTP服务器使用 HttpServer 类进行HTTP服务器搭建使用 http.server 模块进行HTTP服务器搭建使用 net/http 包进行HTTP服务器搭建
WebSocket使用第三方库或框架进行WebSocket编程使用第三方库进行WebSocket编程使用 github.com/gorilla/websocket 包进行WebSocket编程
21. 并发模型
特性JavaPythonGo
并发模型使用线程或者 Executor 框架使用 threading 模块或 asyncio使用 Go 协程和通道
同步机制使用 synchronized 关键字或 java.util.concurrent 包提供的同步机制使用互斥锁和条件变量使用 sync 包提供的锁和通道
原子操作使用 Atomic 类或 java.util.concurrent.atomic 包提供的原子操作使用 multiprocessing 模块或原子操作使用原子函数和原子类型
22. 可拓展化和模块化
特性JavaPythonGo
模块化系统使用 module-info.java 文件和 JPMS 规范使用模块和包管理器使用包和模块化文件
模块定义使用 module 关键字定义模块使用 __init__.py 文件定义模块使用 packageimport 关键字定义模块
模块导入使用 import 关键字导入模块使用 import 语句导入模块使用 import 关键字导入包
可见性使用 exports 关键字指定模块导出的包使用 __all__ 变量指定模块导出的成员使用首字母大小写控制导出成员的可见性
23. 内存管理和垃圾回收
特性JavaPythonGo
内存管理由 JVM 进行自动内存管理由解释器进行自动内存管理使用垃圾收集器进行自动内存管理
垃圾回收机制使用标记-清除算法和其他算法使用引用计数和垃圾收集器使用标记-清除算法和其他算法
24 .web应用方面
特性JavaPythonGo
Web 框架Spring Boot、Servlet、JSP、Struts 等Django、Flask、FastAPI 等Gin、Echo、Beego、Martini 等
路由和中间件使用 Spring MVC 等框架进行路由和中间件处理使用 Django 或 Flask 中间件进行路由和中间件处理使用 Gin 或 Echo 中间件进行路由和中间件处理
数据库连接使用 JDBC 连接数据库使用 ORM 框架如 Django ORM 连接数据库使用原生 SQL 或 ORM 框架连接数据库
模板引擎使用 JSP、Thymeleaf 等模板引擎使用 Django 自带的模板引擎或 Jinja2 模板引擎使用 HTML 模板或第三方模板引擎
异步处理支持使用 CompletableFuture 进行异步处理支持使用异步框架如 asyncio 进行异步处理支持使用 goroutine 和通道进行异步处理
WebSocket支持使用 Spring WebSocket 进行 WebSocket 开发支持使用第三方库进行 WebSocket 开发支持使用第三方库如 gorilla/websocket 进行 WebSocket 开发
RESTful API支持使用 Spring MVC 进行 RESTful API 开发支持使用 Django REST framework 进行 RESTful API 开发支持使用第三方库如 Gin 或 Echo 进行 RESTful API 开发
 25. 应用安全认证与授权方面
特性JavaPythonGo
认证框架Spring Security;ShiroDjango Authentication FrameworkGin-OAuth2、Flask-OAuthlib 等
认证方式基于用户名密码、OAuth2、LDAP 等基于用户名密码、OAuth2、社交认证等基于用户名密码、OAuth2、JWT 等
授权框架Spring Security;ShiroDjango Authorization FrameworkCasbin、Go-Authorization 等
授权方式基于角色、权限、RBAC 等基于角色、权限、RBAC 等基于角色、权限、RBAC 等
第三方认证支持第三方认证如OAuth2、LDAP 等支持第三方认证如OAuth2、社交认证等支持第三方认证如OAuth2、JWT 等
单点登录支持单点登录支持单点登录支持单点登录
26. ORM(对象关系映射)操作方面
特性JavaPythonGo
主要框架Hibernate、MyBatis、Spring Data JPA 等Django ORM、SQLAlchemy 等GORM、XORM 等
数据库支持支持各种关系型数据库如MySQL、Oracle等支持各种关系型数据库如MySQL、PostgreSQL等支持各种关系型数据库如MySQL、PostgreSQL等
数据模型定义使用注解或XML文件定义实体类和数据库表映射关系使用类和元类定义模型类和数据库表映射关系使用结构体和标签定义实体类和数据库表映射关系
查询语言使用HQL(Hibernate Query Language)进行查询使用Django ORM提供的QuerySet进行查询使用原生SQL或链式查询进行查询
事务处理支持使用注解或编程式事务管理进行事务处理支持使用装饰器或上下文管理器进行事务处理支持使用事务处理函数进行事务处理
缓存支持支持二级缓存和查询缓存支持查询缓存支持缓存查询结果和预编译查询
迁移和数据填充支持数据库迁移和数据填充工具支持数据库迁移和数据填充工具支持数据库迁移和数据填充工具
27 .Json数据处理方面
特性JavaPythonGo
JSON 库Jackson、Gson 、FastJson等json 模块、第三方库如 simplejson 等encoding/json、第三方库如 jsoniter 等
JSON 解析使用 ObjectMapper 类解析 JSON 数据使用 json 模块解析 JSON 数据使用 json 包或第三方库解析 JSON 数据
JSON 序列化使用 ObjectMapper 类将对象序列化为 JSON 字符串使用 json 模块将对象序列化为 JSON 字符串使用 json 包或第三方库将对象序列化为 JSON 字符串
JSON 对象使用 JsonObject、JsonArray 等类表示 JSON 对象使用 dict、list 等数据结构表示 JSON 对象使用 map、slice 等数据结构表示 JSON 对象
JSON 格式化可以格式化 JSON 字符串输出可以格式化 JSON 字符串输出可以格式化 JSON 字符串输出
错误处理提供异常机制进行错误处理可以使用异常机制或返回 None 进行错误处理提供错误返回值或错误接口进行错误处理
代码示例
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        // 将对象转换为 JSON 字符串
        String json = mapper.writeValueAsString(new Person("John", 30));
        System.out.println(json);
        // 将 JSON 字符串转换为对象
        Person person = mapper.readValue(json, Person.class);
        System.out.println(person.getName()); // 输出 John
        System.out.println(person.getAge()); // 输出 30
    }
    
    static class Person {
        private String name;
        private int age;

        public Person() {}

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
}

import json

# 将字典转换为 JSON 字符串
data = {'name': 'John', 'age': 30}
json_str = json.dumps(data)
print(json_str)  # 输出 {"name": "John", "age": 30}

# 将 JSON 字符串转换为字典
data = json.loads(json_str)
print(data['name'])  # 输出 John
print(data['age'])   # 输出 30

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数据格式的处理
特性JavaPythonGo
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)
	}
}

今天就先总结这些,以后学习中遇到了其他的,再增加调整 ,文中的代码示例由于在表格中看起来比较拥挤,有种乱码的既视感,不过直接点击复制到对应IDE编辑器或者文本编辑器中是完整的,不会乱码。

  • 32
    点赞
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值