许多 Java 开发者第一次写 Go，都会问一句：

“Go 也支持 Lambda / Stream 吗？”

答案是：

Go 支持“函数作为一等公民”，
但 Go 并不是函数式编程语言。

这句话超级关键。

一、先给结论（避免误解）

Go 只借鉴了“函数是一等公民”，
拒绝了“函数式范式”。

二、Java Lambda：为了弥补 OOP 的不足

Java 8 之前

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("run");
    }
});

Java 8 之后（Lambda）

new Thread(() -> System.out.println("run")).start();

Java Lambda 的核心目标：

• 减少匿名类样板代码
• 配合 Stream API
• 提供“声明式集合操作”

三、Go：从一开始就支持函数作为值

Go 没有 Lambda 语法，但有匿名函数

go func() {
    fmt.Println("run")
}()

对比 Java Lambda，你会发现：

• 没有 ->
• 没有函数式接口
• 就是一个函数

四、函数作为参数（两边都支持）

Java

void process(Function<String, Integer> f) {
    f.apply("123");
}

Go

func process(f func(string) int) {
    f("123")
}

Go 更直接，没有泛型接口、没有包装。

五、函数作为返回值

Java

Supplier<Integer> counter() {
    return () -> 1;
}

Go

func counter() func() int {
    return func() int {
        return 1
    }
}

Go 的闭包语义比 Java 更“原生”

六、最容易踩坑的地方：闭包变量捕获

Java（值捕获，必须 final / effectively final）

for (int i = 0; i < 3; i++) {
    int x = i;
    Runnable r = () -> System.out.println(x);
}

Go（引用捕获，经典坑）

for i := 0; i < 3; i++ {
    go func() {
        fmt.Println(i) // 全是 3
    }()
}

正确写法：

for i := 0; i < 3; i++ {
    i := i
    go func() {
        fmt.Println(i)
    }()
}

这是 Java 开发者转 Go 最容易翻车的点之一

七、Stream API vs Go 的现实主义

Java Stream（声明式）

list.stream()
    .filter(x -> x > 10)
    .map(x -> x * 2)
    .forEach(System.out::println);

Go 的做法（命令式）

for _, x := range list {
    if x > 10 {
        fmt.Println(x * 2)
    }
}

Go 的态度是：

可读性 > 抽象优雅

八、为什么 Go 没有 map / filter / reduce？

这是设计层面的选择：

1. Go 不鼓励隐藏循环
2. 显式 for 更容易调试
3. 不鼓励链式临时对象
4. 性能和可读性优先

Go 官方多次明确：
“for is the only loop”

九、Java Lambda 的常见使用场景，在 Go 怎么办？

十、一个超级重大的误区

❌ 错误理解：

“Go 也能写函数，那就是函数式编程”

✅ 正确理解：

Go 是命令式语言，
只是支持函数作为值。

十一、什么时候 Go 的“函数式特性”特别好用？

✅ 推荐场景：

• 回调（hook）
• sort / filter 的条件函数
• 中间件（HTTP / gRPC）
• 并发任务包装

❌ 不推荐：

• 链式数据变换
• 高阶抽象 DSL
• 强不可变风格

十二、终极对照总结

写给 Java 转 Go 的一句实话

如果你在 Go 里疯狂怀念 Stream，
说明你还在用 Java 的方式写 Go。

当你真正适应 Go，你会发现：

for 循环并不丑，
隐藏复杂度才是真正的复杂。