1. 颠覆传统：什么是可变参数？

在Java 5之前，当我们想要处理数量不定的参数时，往往需要手动创建数组或者编写多个重载方法。这种笨拙的方式直到可变参数（Varargs）的出现才被彻底改变。

语法揭秘：

public static void printNames(String... names) {
    // 方法体
}

这三个神奇的省略号（...）背后，隐藏着Java设计者的智慧结晶。可变参数允许我们将不定数量的同类型参数传递给方法，让代码变得更加优雅简洁。

2. 底层原理：编译器如何实现魔法？

当我们在方法参数中使用String...时：

1. 编译器会自动将其转换为String[]
2. 调用方法时传入的参数会被包装成数组
3. 支持0到多个参数，甚至直接传递数组

经典案例对比：

// 传统数组方式
sum(new int[]{1, 2, 3});

// 可变参数方式
sum(1, 2, 3);

3. 高手必备：7大核心使用规则

1. 唯一性原则：每个方法只能有一个可变参数
2. 末位法则：必须作为参数列表的最后一个参数
3. 类型约束：所有参数必须是同一类型
4. 空值处理：可以接受null或空参数
5. 数组兼容：可以直接传递对应类型的数组
6. 重载优先级：当与固定参数方法冲突时，固定参数方法优先
7. 类型擦除注意：泛型可变参数可能引发类型安全问题

4. 性能陷阱：你不知道的隐藏成本

虽然可变参数非常方便，但在高频调用场景下需要注意：

// 每次调用都会隐式创建新数组
public static void log(String... messages) {
    // 实现
}

// 优化方案：为常用参数数量添加重载
public static void log(String message1) { /* 直接处理 */ }
public static void log(String message1, String message2) { /* 直接处理 */ }
public static void log(String... messages) { /* 通用处理 */ }

5. 实战宝典：6大经典应用场景

5.1 万能字符串拼接

public class StringJoin {
    public static String join(String delimiter, String... elements) {
        return String.join(delimiter, elements);
    }

    public static void main(String[] args) {
        System.out.println(StringJoin.join("+", "a", "b", "c"));
    }
}

5.2 智能参数校验

public static void validateNotNull(Object... objects) {
    for (Object obj : objects) {
        if (obj == null) {
            throw new IllegalArgumentException();
        }
    }
}

5.3 数学计算神器

public static double max(double... values) {
    if (values.length == 0) throw new IllegalArgumentException();
    double max = values[0];
    for (double v : values) {
        if (v > max) max = v;
    }
    return max;
}

5.4 构建模式革新

public class QueryBuilder {
    private List<String> conditions = new ArrayList<>();
    
    public QueryBuilder where(String... clauses) {
        conditions.addAll(Arrays.asList(clauses));
        return this;
    }
}

5.5 日志工具优化

public class Logger {
    public static void debug(String format, Object... args) {
        System.out.printf(format + "%n", args);
    }
}

5.6 现代Stream整合

public <T> List<T> mergeLists(List<T>... lists) {
    return Arrays.stream(lists)
                 .flatMap(List::stream)
                 .collect(Collectors.toList());
}

6. 高级技巧：突破常规的5种玩法

1. 泛型可变参数：

@SafeVarargs
public final <T> List<T> createImmutableList(T... elements) {
    return List.of(elements);
}

2. 反射黑科技：

Method method = MyClass.class.getMethod("printNames", String[].class);
method.invoke(null, (Object) new String[]{"A", "B"});

3. 注解处理器：

@SafeVarargs
public final <T> void processAnnotations(T... annotations) {
    // 处理注解逻辑
}

4. 动态代理：

public Object invoke(Object proxy, Method method, Object... args) {
    // 处理动态参数
}

5. 模式匹配：

switch (args.length) {
    case 0 -> handleNoArg();
    case 1 -> handleSingleArg(args[0]);
    default -> handleMultipleArgs(args);
}

7. 避坑指南：5个致命错误

1. 错误示范：将可变参数放在非末尾位置
2. 空指针陷阱：不检查可变参数数组是否为null
3. 类型混淆：混合使用不同类型参数
4. 性能黑洞：在热点代码中滥用可变参数
5. 重载灾难：过度复杂的方法重载结构

8. 未来展望：可变参数在新时代的发展

随着Java语言的演进，可变参数正在与新的特性深度融合：

• 与Record类型结合创建灵活的数据结构
• 在Switch模式匹配中处理可变参数
• 与密封类（Sealed Class）配合实现更安全的API设计
• 在虚拟线程（Loom项目）中的异步参数处理

9. 结语：选择与平衡的艺术

可变参数虽好，但需根据具体场景权衡使用：

适合场景：工具类方法、参数数量变化较大的API、测试工具代码

慎用场景：性能敏感的核心代码、参数类型不一致的情况、需要严格参数检查的方法

掌握可变参数的精髓，让你的Java代码在灵活性与严谨性之间找到完美平衡点，打造出既优雅又高效的API设计。