Java 开发者写代码，很少是“裸写”的，背后必定离不开一堆工具类：

• Objects
• StringUtils
• Collections
• Optional
• StopWatch
• UUID

但当你切换到 Go，很快会发现：

Go 没有“工具类大全”，但能力并没有缺失。

只是：
Java 用“类”，Go 用“语言特性 + 标准库组合”。

一、Objects 工具类 → Go 的零值与显式判断

Java：Objects

Objects.requireNonNull(obj);
Objects.equals(a, b);
Objects.isNull(obj);

Go 的做法

1️⃣ 判空（nil）

if obj == nil {
    return errors.New("obj is nil")
}

Go 没有 requireNonNull，但鼓励在入口显式判断。

2️⃣ equals（直接用 ==）

if a == b {
    ...
}

前提：

• 基本类型
• 可比较 struct
• 指针

⚠️ slice / map 不能直接比较（这是设计选择）。

二、StringUtils → strings / strconv / unicode

Java

StringUtils.isEmpty(s);
StringUtils.join(list, ",");
StringUtils.trim(s);

Go 的等价写法

1️⃣ 判空字符串

if s == "" {
}

或更严谨：

strings.TrimSpace(s) == ""

2️⃣ join

strings.Join(arr, ",")

3️⃣ trim

strings.TrimSpace(s)

4️⃣ 字符串与数字转换（高频）

i, err := strconv.Atoi(s)
s := strconv.Itoa(i)

Go 把字符串工具拆进多个包，而不是聚焦在一个类。

三、Collections 工具类 → 语言级操作

Java

Collections.sort(list);
Collections.emptyList();
Collections.unmodifiableList(list);

Go 的思路：你就是直接操作

1️⃣ 排序

sort.Ints(arr)
sort.Slice(users, func(i, j int) bool {
    return users[i].Age < users[j].Age
})

2️⃣ 空集合

var s []int      // nil slice
s := []int{}     // empty slice

Go 区分 nil vs empty，Java 没这个概念。

3️⃣ 不可变集合？

Go 没有官方不可变集合。

推荐做法：

• 只读约定
• 返回 copy

func GetData() []int {
    return append([]int{}, data...)
}

四、Optional → 多返回值 + error

Java Optional（你必定很熟）

Optional<User> userOpt = find();
userOpt.ifPresent(...)

Go 的惯用方式

func find() (*User, error) {
    ...
}

使用时：

u, err := find()
if err != nil {
    return err
}

Go 用 返回值 + error
Optional 在 Go 里没有存在必要

五、StopWatch → time 包

Java

StopWatch sw = new StopWatch();
sw.start();
// do work
sw.stop();
System.out.println(sw.getTotalTimeMillis());

Go

start := time.Now()
// do work
elapsed := time.Since(start)
fmt.Println(elapsed)

简单、直接、无对象。

六、UUID → crypto/rand / uuid 库

Java

UUID.randomUUID().toString();

Go（标准做法）

import "github.com/google/uuid"

id := uuid.NewString()

Go 标准库不直接提供 UUID，但这是少数例外。

七、对 Java 开发者最重大的一个转变

Java 思维

工具 = 静态方法 + 工具类

Go 思维

工具 = 语言特性 + 小而专的标准库

• 没有 Utils 大杂烩
• 每个包只干一件事
• 组合优于继承

八、阶段性总结