编程语言 on 牛哥聊技术

Go 与 Java 泛型：晚到的 vs 老牌的，对比谁更好用

Tue, 09 Dec 2025 15:30:00 +0800

写在前面

泛型是现代编程语言的"老话题"了——Java 1.5（2004 年）就有，C++、C#、TypeScript 都早早具备。但Go 直到 1.18（2022 年）才引入泛型。

很多人好奇——Go 的泛型和 Java 比有什么不同？只是"语法换换"还是真有本质差异？

本文从语法、实现机制、边界、常见用法做全面对比——让你看完能准确判断"什么场景哪个语言的泛型更好用"。

一、语法层面对比

最简单的例子：泛型函数

Java：

1
2
3
4
5
6


public static <T> T identity(T x) {
 return x;
}

String s = identity("hello");
Integer i = identity(42);

Go：

1
2
3
4
5
6


func Identity[T any](x T) T {
 return x
}

s := Identity("hello")
i := Identity(42)

非常相似——只是位置不同。Java 用 <T> 在返回类型前，Go 用 [T any] 在函数名后。

泛型类型 / 结构体

Java：

1
2
3
4
5
6
7


public class Box<T> {
 private T value;
 public Box(T value) { this.value = value; }
 public T get() { return value; }
}

Box<String> box = new Box<>("hello");

Go：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


type Box[T any] struct {
 value T
}

func NewBox[T any](v T) *Box[T] {
 return &Box[T]{value: v}
}

func (b *Box[T]) Get() T {
 return b.value
}

box := NewBox("hello") // 类型推断

Go 的方法接收者也要写 [T]——稍啰嗦。但类型推断更友好——NewBox("hello") 不用写 NewBox[string]。

二、约束系统的差异

这是两者最大的差异——怎么限制泛型的类型。

Java：基于 `extends` 的边界

1
2
3


public static <T extends Comparable<T>> T max(T a, T b) {
 return a.compareTo(b) > 0 ? a : b;
}

T extends Comparable<T> 限定 T 必须实现 Comparable 接口。

也支持 & 多个接口：

1

public static <T extends Comparable<T> & Serializable> ...

Go：基于"约束接口"

Go 用 interface 表达约束——但比 Java 灵活得多：

1
2
3
4
5
6
7
8


type Ordered interface {
 ~int | ~int64 | ~float64 | ~string
}

func Max[T Ordered](a, b T) T {
 if a > b { return a }
 return b
}

注意 ~int 中的 ~ 符号——表示"底层类型是 int 的所有类型"，包括 type MyInt int 这种自定义类型。

类型集合（type set）

Go 引入了"类型集合"概念——可以用 | 表达多个类型的并集：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


type Number interface {
 int | int8 | int16 | int32 | int64 | uint | uint8 | ...
 float32 | float64
}

func Sum[T Number](s []T) T {
 var total T
 for _, v := range s {
 total += v
 }
 return total
}

Java 做不到同样的事——Java 没法说"接受 int 或 long 但不接受其他"。Java 要这种行为只能用接口（牺牲基本类型）或重载方法。

三、实现机制：擦除 vs 单态化

这是最深的差异——编译器怎么处理泛型代码。

Java：类型擦除（Type Erasure）

Java 编译时把泛型类型擦除成 Object，运行时所有 List<String> 和 List<Integer> 都是同一个 List 类。

1
2
3


List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
System.out.println(a.getClass() == b.getClass()); // true！

类型擦除的代价

1
2
3
4
5
6
7


public <T> T create() {
 return new T(); // ❌ 不能 new T，运行时不知道 T 是什么
}

public <T> T[] toArray() {
 return new T[10]; // ❌ 同样不行
}

绕路要传 Class<T>：

1
2
3


public <T> T create(Class<T> clazz) {
 return clazz.getDeclaredConstructor().newInstance();
}

Go：单态化（Monomorphization）

Go 编译时为每个具体类型生成专门的代码——Max[int] 和 Max[float64] 是两段独立代码。

1
2


m1 := Max(1, 2) // 编译生成 Max_int
m2 := Max(1.0, 2.0) // 编译生成 Max_float64

实际上 Go 做的是部分单态化（GCShape）——按"GC 形状"分组，不是每个类型都独立。

对比

	Java（擦除）	Go（单态化）
编译速度	快	慢（要展开多份）
二进制体积	小	大
运行时性能	中（要装箱拆箱）	高（特化代码）
反射支持	弱（运行时类型擦除）	强（保留类型信息）
不能 new T	真	可以（用 reflect）

四、装箱与基本类型

Java 泛型最大的痛——不能用基本类型：

1
2


List<int> l = ...; // ❌ 不行
List<Integer> l = ...; // ✓ 装箱

每个 int 都被装箱成 Integer 对象——内存占用 4-5 倍，还有 GC 压力。

Go 没这个问题：

1
2


list := []int{1, 2, 3} // 直接是 int，无装箱
GenericFunc[int](42) // 直接传 int

Go 在数值密集场景下泛型性能远超 Java 泛型。

五、常见用法对比

1. 集合工具函数

Java（用 Stream）：

1
2
3


List<Integer> doubled = list.stream()
 .map(i -> i * 2)
 .collect(Collectors.toList());

Go（自己实现 Map）：

1
2
3
4
5
6
7
8
9


func Map[T, U any](s []T, f func(T) U) []U {
 r := make([]U, len(s))
 for i, v := range s {
 r[i] = f(v)
 }
 return r
}

doubled := Map(list, func(i int) int { return i * 2 })

Go 1.21 之后标准库有 slices 包：

1
2
3
4
5


import "slices"

slices.Sort(list)
slices.Contains(list, 5)
slices.Max(list)

2. 容器类

Java：

1

Map<String, List<User>> usersByCity = new HashMap<>();

Go：

1

usersByCity := make(map[string][]*User)

Go 的内置容器（map、slice）已经支持泛型——不需要单独的"泛型容器"。这是 Go 的优势。

3. 错误处理 / Result 类型

Rust 风格 Result 类型——Java 没有但能实现：

Java：

1
2
3
4
5


public class Result<T, E> {
 private final T value;
 private final E error;
 // ...
}

Go：

1
2
3
4
5
6
7


type Result[T any] struct {
 Value T
 Err error
}

func Ok[T any](v T) Result[T] { return Result[T]{Value: v} }
func Err[T any](e error) Result[T] { return Result[T]{Err: e} }

不过 Go 社区主流仍是 (value, error) 双返回——Result 类型不流行。

六、Go 泛型的限制

Go 1.18 引入泛型时刻意做了"最小可用"——功能上比 Java 少很多：

1. 无方法泛型

Go 的方法不能引入新的泛型参数——只能复用所属类型的参数：

1
2
3
4
5
6
7


type Box[T any] struct { v T }

// ❌ 不行：方法不能有自己的泛型参数
func (b *Box[T]) Map[U any](f func(T) U) *Box[U] { ... }

// ✓ 必须包装成顶级函数
func MapBox[T, U any](b *Box[T], f func(T) U) *Box[U] { ... }

这是 Go 泛型的最大遗憾——写流式 API 比 Java 啰嗦。

状态更新（截至 Go 1.25, 2025-08）：方法泛型仍未支持，且 Go FAQ 明确写着 “we do not anticipate that Go will ever add generic methods”。社区有持续提案（issue #77273 是当前最新的 spec 提案），但官方态度悲观。技术原因主要是"参数化方法会产生无限多的具体方法签名"——会破坏 reflect 包的向后兼容。所以可见的未来里，写 Go 泛型流式 API 都得用顶级函数包一层。

2. 无变型（Variance）

Java 有 ? extends T / ? super T 表达协变 / 逆变——Go 没有。

1

List<? extends Number> list = new ArrayList<Integer>(); // ✓

1

// Go 没有等价语法

3. 无 Constraint Inference

Java 的类型推断范围广，能推断出复杂约束——Go 仅做"显式 + 简单推断"。

4. 没有"条件实现"

Go 的方法集是"全有或全无"——无法表达"仅当 T 满足某个约束时，Box[T] 才实现某个接口"（C# 的 where T: IFoo + 条件 impl，或 Rust 的 conditional impl<T: Foo> Bar for Box<T> 都做得到，Go 没有等价物）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


type Stringer interface {
 String() string
}

type Box[T any] struct { v T }

// ✓ 可以无条件实现 Stringer，T 是不是 Stringer 都行
func (b Box[T]) String() string { return fmt.Sprintf("%v", b.v) }

// ❌ 没法表达"仅当 T 是 Stringer 时 Box[T] 才实现 Stringer"

5. 顺手吐槽：`[]` 把泛型、map、切片三件事挤在一起

以下纯属个人意见，不喜请轻喷。

Java / C# / Rust / TypeScript 都用 <T> 表达泛型，和数组下标 []、Map 访问 .get(k) 各管一摊，看一眼就知道是哪件事。Go 当年的官方理由是 <> 会和比较运算符 < > 在解析时产生歧义（例如 a, b = w < x, y > (z) 这种）——所以选了已经被 map / slice 占用的方括号。

听起来很学术，但实际上：

Java、C#、Rust、TypeScript 全都用 <>，解析器写得也都没出问题——所谓的歧义在工程上是可以处理的，无非是写编译器麻烦点
Go 团队选 [] 真正避开的是"写解析器麻烦"，但代价是把这个负担转嫁给了所有读代码的人——同一个 [] 现在要在脑子里区分三件事：

1
2
3
4


m[k] // map 访问（运行时）
s[i] // 切片下标（运行时）
List[int] // 泛型类型实参（编译期）
List[int]{1,2} // ↑ 后面跟花括号才知道是泛型实例化，不是数组下标

实际项目里读到 Cache[string, User] 一开始要愣两秒——脑子里要切换到"哦这是泛型"。pool.Get[*User]() 这种调用乍一看像是"取下标然后调用"，得想一下才反应过来。

不算硬伤，但确实是 Go 泛型读起来"差点意思"的最直接原因。省了编译器作者一次工，让全世界的 Go 程序员每天多想一秒——这买卖不太划算。

6. 顺便再吐一句：Go 的时间格式

同样是个人吐槽。

既然提到了 Go 的语法选择——Go 的时间格式化设计也是一脉相承的"为我自己方便"：别的语言都用 %Y-%m-%d %H:%M:%S 这种 strftime / ISO 风格，Go 偏要让你记一个 reference time：

1
2
3


"Mon Jan 2 15:04:05 MST 2006"
// 对应美式记忆：1 月 2 日 下午 3 点 4 分 5 秒 2006 年，时区 MST，星期一
// 1 / 2 / 3 / 4 / 5 / 6 / 7 顺口溜

设计者很得意——“你看，1234567 多好记”。

问题是：

01/02 是美式日期格式（MM/DD），全世界绝大部分国家用 DD/MM
15:04:05 旁边还要配 AM/PM 的 12 小时制
MST（Mountain Standard Time）是美国山地时区——非美国人这辈子用不到几次
整个"顺口溜"只有美国人觉得顺口

所以 Go 程序员每次写 time.Format("2006-01-02 15:04:05") 时，都得在脑子里把美式 1/2/3/4/5/6/7 顺口溜过一遍——其他语言一句 %Y-%m-%d %H:%M:%S 就能表达的事，Go 要绕一圈。

跟泛型用 [] 一样，这两件事有同一种气味——设计者当年的便利感，最后由所有用户来承担。多少有点 American-centric 的味道。

不影响 Go 是好语言，但读 / 写这两处时偶尔会忍不住想"本来可以不这样的"。

七、Java 泛型的限制

1. 类型擦除导致的反射受限

1
2


List<String> list = new ArrayList<>();
list.getClass(); // 只是 ArrayList，不知道 String

要拿到 String 类型信息要 TypeReference（Jackson 等库的常见做法）。

2. 不能 new T

如前所述。

3. 数组与泛型不兼容

1
2


T[] arr = new T[10]; // ❌
List<String>[] lists = new List<String>[10]; // ❌

历史包袱——Java 数组先于泛型存在，两者设计不兼容。

八、性能对比

	Java	Go
泛型函数调用开销	装箱 + 虚调用	无装箱 + 直接调用
内存占用	每个对象多一层 object header	紧凑数组
GC 影响	装箱对象增加 GC 负担	无影响
编译速度	快	慢（单态化）
二进制体积	小	大（每个特化版本）

数值密集场景 Go 泛型快 2-5 倍 —— 因为 Go 不装箱。

九、典型场景该用谁

flowchart TD
 Q1{要写库还是业务?}
 Q1 -->|库| Lib{需要复杂类型约束?}
 Q1 -->|业务| Biz[两个都够用]
 Lib -->|是，需要变型 / 复杂边界| Java[Java 泛型表达力更强]
 Lib -->|否，简单约束| Either[Go 更简洁]

实战建议：

Go 项目：用 1.21+ 标准库的 slices / maps 包——日常需求够了；自己写库时少滥用泛型（Go 社区文化是"够用就好"）
Java 项目：泛型几乎是必须——集合、Stream、CompletableFuture 都依赖

十、Go 社区对泛型的争议

Go 引入泛型的争议持续多年——有人觉得 Go 不需要泛型：

“Go 的简单是它的核心优势——加泛型只会让代码变复杂”

也有人坚定支持：

“没有泛型，每个排序函数都要写一遍”

最终 Go 团队选择了保守的最小可用方案——这是为什么 Go 泛型没有方法泛型、没有变型、没有约束推断。

这个保守是好事还是坏事？——主流意见是好事。Go 泛型保留了 Go 的简洁哲学，业务代码里 90% 场景不需要泛型。

十一、什么时候真的该用泛型

不论 Go 还是 Java——别为了用泛型而用泛型。判断标准：

✅ 真的需要：

写数据结构（链表、树、图）
写算法工具（排序、查找、map/filter/reduce）
写容器（cache、pool）
写跨类型的辅助函数（Identity、Coalesce）

❌ 不该用：

业务实体（User、Order 不需要泛型化）
单一类型的工具函数
“为了通用"的过度设计

简单代码胜过抽象代码——这条原则在两个语言都适用。

小结

把全文压一句：

Go 泛型的设计哲学是『最小可用 + 高性能』，Java 泛型是『表达力强 + 历史包袱重』——前者赢在简洁和速度，后者赢在生态成熟和工具完善。

各自适合的场景：

Go 泛型：性能敏感、数值密集、库开发场景胜出
Java 泛型：复杂业务建模、需要变型、生态丰富时胜出

但两者最重要的共同点：90% 的业务代码根本不需要泛型。把泛型当工具，需要时拿出来用——不要为了显示"会泛型"而强行抽象。

Lua 速通——核心语法与特性

Tue, 22 Apr 2025 15:00:00 +0800

写在前面

Lua 是一门有意保持小巧的脚本语言——核心语法只有几十条规则，标准库非常精简，参考实现的解释器只有约 2.4 万行 C 代码（含标准库），编译后产物约 250 KB。

但它表达力并不弱：first-class function、metatable、协程、模式匹配——很多被现代语言陆续吸收的特性，Lua 早就有。

本文给一份偏语言本身的速通——讲清楚 Lua 的核心语法、表、面向对象的实现方式、协程，以及一些容易踩的语法陷阱。读完之后你能看懂多数 Lua 代码，也能写出一些不丢人的 Lua。

一、最基本的语法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


-- 注释从两个减号开始
print("Hello, world!")

-- 变量（默认全局）
x = 10
local y = 20 -- local 是局部，强烈推荐永远用 local

-- 字符串
local name = "Lua"
print("Hi, " .. name) -- 字符串拼接用 ..
print(#name) -- # 取长度

-- 数字
local a = 1.5
local b = 2

-- nil（不存在/未定义）
local nothing = nil

-- 布尔（注意：只有 false 和 nil 是 falsy，0 是 truthy！）
if 0 then print("0 是 truthy") end -- 会执行

⚠️ 几个和主流语言不一样的地方：

nil 不是 null——访问不存在的字段返回 nil
0 是真值！这和大多数语言相反
字符串拼接用 ..，不是 +
取长度用 #str，不是 len(str)

二、控制流

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


-- if
if x > 10 then
 print("big")
elseif x > 5 then
 print("medium")
else
 print("small")
end

-- while
while x > 0 do
 x = x - 1
end

-- repeat-until（条件为 true 时退出）
repeat
 x = x + 1
until x > 100

-- for（数值型）
for i = 1, 10 do print(i) end -- 1 到 10
for i = 1, 10, 2 do print(i) end -- 步长 2
for i = 10, 1, -1 do print(i) end -- 倒序

-- for（迭代器）
for k, v in pairs(table) do print(k, v) end
for i, v in ipairs(array) do print(i, v) end

注意——for 没有 ++ --，循环结束用 end。

三、函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


function add(a, b)
 return a + b
end

-- 多返回值（Lua 一大特色）
function divmod(a, b)
 return a / b, a % b
end
local q, r = divmod(7, 2)

-- 可变参数
function printAll(...)
 local args = {...}
 for i, v in ipairs(args) do print(i, v) end
end

-- 匿名函数 + 局部变量
local sayHello = function(name)
 print("Hello, " .. name)
end
sayHello("World")

函数是 first-class value——可以传递、返回、存进表，闭包语义和 JS / Python 类似。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


function counter()
 local n = 0
 return function()
 n = n + 1
 return n
 end
end

local next = counter()
print(next()) -- 1
print(next()) -- 2

四、Table——Lua 唯一的数据结构

Lua 的核心是 table——既是数组、又是字典、又是对象——一个数据结构表达所有：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


-- 数组式
local arr = {10, 20, 30}
print(arr[1]) -- 10（注意从 1 开始！）
print(#arr) -- 3

-- 字典式
local user = { name = "alice", age = 30 }
print(user.name)
print(user["name"])

-- 混合
local mixed = { "a", "b", "c", color = "red" }

⚠️ Lua 的数组从 1 开始！ 不是 0。这是和 99% 主流语言的不同——也是新手最容易踩的坑。

表的常用操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


table.insert(arr, 40) -- 末尾追加
table.remove(arr, 1) -- 移除第 1 个
table.concat(arr, ", ") -- 拼成字符串
table.sort(arr) -- 排序

-- 字典遍历
for k, v in pairs(user) do
 print(k, v)
end

-- 数组遍历
for i, v in ipairs(arr) do
 print(i, v)
end

pairs 遍历所有键值对（包括字符串 key）；ipairs 只遍历数字索引 1, 2, 3…——遇到 nil 停止。

五、字符串与模式匹配

字符串是 Lua 里仅次于 table 的常用类型，标准库里有不少利器：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


local s = "Hello, Lua!"

print(#s) -- 11
print(string.upper(s)) -- HELLO, LUA!
print(string.sub(s, 8, 10)) -- Lua
print(string.rep("ab", 3)) -- ababab

-- 也可以用 OO 调用
print(s:upper())
print(s:find("Lua")) -- 8 10

模式匹配

Lua 没有正则，但有自己的轻量"模式"语法：

1
2
3
4
5
6


local date = "2025-04-22"
local y, m, d = string.match(date, "(%d+)-(%d+)-(%d+)")
print(y, m, d) -- 2025 04 22

-- 替换
print(string.gsub("hello world", "world", "Lua")) -- hello Lua 1

%d 数字、%a 字母、%w 字母数字、%s 空白——和 PCRE 不完全一样但够用，性能也好。

六、Metatable 与面向对象

Lua 没有 class，但 metatable 几乎能模拟出任何 OO 特性：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


local Animal = {}
Animal.__index = Animal

function Animal.new(name)
 local self = setmetatable({}, Animal)
 self.name = name
 return self
end

function Animal:eat() -- 注意冒号 :
 print(self.name .. " is eating")
end

local dog = Animal.new("Rex")
dog:eat() -- 调用也用冒号

冒号 : 是语法糖——obj:method() 等价于 obj.method(obj)，自动传 self。

元方法（metamethods）

metatable 里几个特殊键名能"重载"运算符：

1
2
3
4
5
6
7
8


local Vec = {}
Vec.__index = Vec
Vec.__add = function(a, b) return setmetatable({x = a.x + b.x, y = a.y + b.y}, Vec) end
Vec.__tostring = function(v) return "(" .. v.x .. ", " .. v.y .. ")" end

local v1 = setmetatable({x = 1, y = 2}, Vec)
local v2 = setmetatable({x = 3, y = 4}, Vec)
print(v1 + v2) -- (4, 6)

常用元方法：__index / __newindex / __add / __sub / __mul / __eq / __lt / __tostring / __call。

继承

1
2
3
4
5


local Dog = setmetatable({}, {__index = Animal})

function Dog:bark()
 print(self.name .. ": woof!")
end

子类查找方法时，自身没有就沿 __index 一路向上找——这就是 Lua 的"原型继承"。

七、协程（coroutine）

协程是 Lua 一个常被忽略的强项——轻量级、对称式协程，比线程便宜得多：

1
2
3
4
5
6
7
8
9


local co = coroutine.create(function(a, b)
 print("start: " .. a .. ", " .. b)
 local c = coroutine.yield(a + b)
 print("resumed with: " .. c)
 return "done"
end)

print(coroutine.resume(co, 1, 2)) -- start: 1, 2 \n true 3
print(coroutine.resume(co, 99)) -- resumed with: 99 \n true done

yield 把控制权还给调用者并把值传出去；resume 重新激活协程并把值传进去。

协程能用来写生成器：

1
2
3
4
5
6
7
8
9


local function range(from, to)
 return coroutine.wrap(function()
 for i = from, to do
 coroutine.yield(i)
 end
 end)
end

for v in range(1, 5) do print(v) end -- 1 2 3 4 5

coroutine.wrap 是 create + resume 的简化包装。

八、模块化

1
2
3
4
5
6
7
8


-- mylib.lua
local M = {}

function M.greet(name)
 return "Hello, " .. name
end

return M

1
2
3


-- main.lua
local lib = require("mylib")
print(lib.greet("World"))

require 自动从 package.path 里找 .lua 文件，结果会被缓存——同一个模块多次 require 只加载一次。

九、几个常踩的语法陷阱

1. 数组从 1 开始

1
2
3


local a = {10, 20, 30}
print(a[0]) -- nil（不是 10！）
print(a[1]) -- 10

2. nil 不能放在数组中间

1
2
3


local a = {1, 2, nil, 4}
print(#a) -- 不一定是 4，可能是 2
for i,v in ipairs(a) do print(v) end -- 只打到 2

ipairs 遇 nil 停——这种 sparse array 在 Lua 里要特别小心。

3. 0 和 "" 是 truthy

1
2
3
4


if 0 then print("yes") end -- yes
if "" then print("yes") end -- yes
if nil then print("yes") end -- 不打印
if false then print("yes") end -- 不打印

只有 false 和 nil 是 falsy。

4. 字符串与数字自动转换

1
2


local x = "10" + 5 -- 15（字符串自动转数字）
local y = 10 .. "abc" -- "10abc"

便利但容易隐藏 bug——关键代码显式 tonumber() / tostring()。

5. 默认全局

1
2
3
4


function foo()
 x = 10 -- 这是全局变量！
 local y = 20 -- 这才是局部
end

永远写 local——否则一不小心污染全局。

6. 整数与浮点（5.3+）

Lua 5.3 引入了原生 integer 类型，整数除法用 //：

1
2


print(7 / 2) -- 3.5（浮点）
print(7 // 2) -- 3 （整除）

5.3 之前所有数字都是 double——老脚本升到 5.3 时除法行为可能微妙改变。

十、Lua 的设计哲学

了解一下 Lua 之所以这么设计的几条核心原则：

极简正交：核心特性极少，但每条都正交，能组合出强大能力
机制不策略：metatable 是机制，怎么实现 OO / 继承 / 运算符重载都是策略
数据结构唯一性：只用 table 表达所有复合数据
首类函数 + 闭包：函数式编程的基本元素都齐了

正是这种克制让 Lua 能在两万多行 C 代码里塞下一门完整的语言——也让它的标准库相对寒酸（“麻雀虽小五脏不全”），需要用 luarocks 或 LuaJIT 的 ffi 补足。

十一、Lua 版本与 LuaJIT

Lua 5.x 版本演进

5.1：经典版，使用面最广
5.2：引入 goto、bit32 库
5.3：引入原生 integer 类型、整除 //、原生位运算符 & | ~ << >>（bit32 库被废弃）
5.4：generational GC、<const> 与 <close> 属性

5.1 → 5.4 不完全兼容——升级时要核对每条变化。

LuaJIT

LuaJIT 是 Lua 的 JIT 编译器实现——比标准 Lua 快 5-10 倍，性能直逼 C。它的 ffi 库还能直接调用 C 函数，扩展能力极强。

不过 LuaJIT 主要兼容 5.1 + 部分 5.2 特性——和 5.3 / 5.4 的 integer 等新特性不兼容。

包管理

luarocks 是事实标准——类似 npm/pip。

十二、什么场景该用 Lua

✅ 适合

轻量脚本：启动快、依赖少，比 Python 启动几十倍快
DSL / 配置：用作业务规则、配置文件的承载语言
作为宿主程序的扩展层：被嵌入到其他程序里执行业务逻辑（这是它历史上最常见的用法之一）
性能敏感的脚本：LuaJIT 性能接近 C

❌ 不适合

独立大型应用：标准库薄，生态远不如 Python / Node
复杂业务系统：OO 弱、错误处理粗糙
数据科学：没有 NumPy / Pandas 之类生态

小结

把全文压一句：

**Lua 是一门用很少的概念表达很多能力的小语言——核心是 table 与 first-class function，加上 metatable 和协程，几乎能覆盖任何脚本场景。 **

记住几个关键点：

数组从 1 开始
local 永远要写
nil 和 false 才是 falsy
字符串拼接用 ..
table 是唯一复合数据结构
metatable 是 Lua OO 与运算符重载的统一机制
协程是它被低估的强项

掌握了这些，你已经可以读懂 95% 的 Lua 代码，并写出符合语言风格的脚本。

编程语言 on 牛哥聊技术

Go 与 Java 泛型：晚到的 vs 老牌的，对比谁更好用

写在前面

一、语法层面对比

最简单的例子：泛型函数

泛型类型 / 结构体

二、约束系统的差异

Java：基于 extends 的边界

Go：基于"约束接口"

类型集合（type set）

三、实现机制：擦除 vs 单态化

Java：类型擦除（Type Erasure）

类型擦除的代价

Go：单态化（Monomorphization）

对比

四、装箱与基本类型

五、常见用法对比

1. 集合工具函数

2. 容器类

3. 错误处理 / Result 类型

六、Go 泛型的限制

1. 无方法泛型

2. 无变型（Variance）

3. 无 Constraint Inference

4. 没有"条件实现"

5. 顺手吐槽：[] 把泛型、map、切片三件事挤在一起

6. 顺便再吐一句：Go 的时间格式

七、Java 泛型的限制

1. 类型擦除导致的反射受限

2. 不能 new T

3. 数组与泛型不兼容

八、性能对比

九、典型场景该用谁

十、Go 社区对泛型的争议

十一、什么时候真的该用泛型

小结

Lua 速通——核心语法与特性

写在前面

一、最基本的语法

二、控制流

三、函数

四、Table——Lua 唯一的数据结构

表的常用操作

五、字符串与模式匹配

模式匹配

六、Metatable 与面向对象

元方法（metamethods）

继承

七、协程（coroutine）

八、模块化

九、几个常踩的语法陷阱

1. 数组从 1 开始

2. nil 不能放在数组中间

3. 0 和 "" 是 truthy

4. 字符串与数字自动转换

5. 默认全局

6. 整数与浮点（5.3+）

十、Lua 的设计哲学

十一、Lua 版本与 LuaJIT

Lua 5.x 版本演进

LuaJIT

包管理

十二、什么场景该用 Lua

✅ 适合

❌ 不适合

小结

Java：基于 `extends` 的边界

5. 顺手吐槽：`[]` 把泛型、map、切片三件事挤在一起