- * 前言
- 1️⃣ 概念
- 2️⃣ 优势和缺点
- 3️⃣ 特征和应用场景
-
-
- 3.1 特征
- 3.2 应用场景
-
- 4️⃣ 使用和原理
- 5️⃣ 使用技巧
-
-
- 5.1 可变参数结合泛型
- 5.2 使用元组或列表进行参数传递
- 5.3 使用默认值
- 5.4 缓存计算结果
-
- 6️⃣ 实战：构建动态日志工具
- * 总结
* 前言
你是不是曾经为了传递不确定数量的参数而纠结不已？在Java编程领域，我们常常遭遇需求多变的情况。为了应对这种情况，Java提供了一项强大而灵活的特性——***可变参数（Variable Arguments）***。通过灵活运用可变参数，我们可以让代码更加简洁、高效，减少冗余。本文将带你深入了解Java的可变参数机制和其魔幻般的应用。
当然，我们不能仅仅止步于表面，我们会深入探索可变参数的精髓。首先，我会向你介绍可变参数的基本语法，你将看到如何定义和使用这项魔法功能。
接下来，我们将进入更高级的领域，学习如何结合可变参数与其他特性，如方法重载和泛型。你将了解到如何发挥可变参数的真正威力，并将其应用于实际项目中。
此外，我还会与你分享几个聪明的技巧和最佳实践，以确保你能够充分利用可变参数的优势。你将学到如何处理边界情况、保持代码的可读性，并避免潜在的陷阱。
最后，我将通过一些实例和案例研究向你展示可变参数在实战中的威力。无论是构建动态日志工具，还是优化大型数据处理系统，可变参数都能助你一臂之力。
所以，朋友们，准备好迎接这个属于Java的魔法时刻了吗？让我们探索可变参数的奇妙世界，解锁编程的无限可能！
注意：本文适合已经掌握基本Java基础语法的读者。如果你对方法、参数等概念不熟悉，建议先学习本专栏的之前文章中的相关基础知识再来挑战这个精彩的话题。
1️⃣ 概念
Java可变参数（Variable Arguments）是从Java 5版本开始引入的一种特性。它允许在方法中传递不定数量的参数，而无需明确指定参数的个数。 这种特性极大地提升了方法的灵活性和可扩展性。
可变参数的出现使得我们能够优雅地处理方法的重载问题。以前，为了满足不同参数个数的调用需求，我们不得不创建多个不同参数个数的方法。而现在，我们只需要定义一个带有可变参数的方法，就能自由传入任意个数的参数。这不仅简化了代码，还降低了代码维护的成本。
2️⃣ 优势和缺点
Java可变参数的优势及缺点如下所示：
优点：
- 灵活性：可变参数允许方法接受任意数量的参数，使得方法可以应对不同数量的输入；
- 简洁性：相比于使用数组或集合作为参数，可变参数更加简洁，不需要手动创建和初始化数组；
- 代码复用：通过使用可变参数，可以提高方法的重用性，避免编写多个具有不同参数个数的重载方法。
缺点：
- 性能影响：由于可变参数实际上是将参数打包成数组进行处理，因此可能对性能产生一定的影响；
- 类型限制：可变参数只能位于方法的最后一个位置，并且只能有一个可变参数。这会限制一些方法的设计和使用场景。
3️⃣ 特征和应用场景
3.1 特征
可变参数具有如下特征，在实际使用时需要注意这些特点，避免不当的使用造成错误：
- 可变参数本质上是一个数组，使用时像一个普通的形参一样声明；
- 如果方法同时存在其他形参，可变参数必须放置在方法签名的最后一个位置；
- 在方法体内，可以将可变参数当作数组使用，进行遍历、操作或传递给其他方法。
3.2 应用场景
- 日志框架 中的可变参数方法允许用户根据需要传递任意数量的日志消息；
- 常见的工具类 如String.format()和System.out.printf()等均使用了可变参数来格式化字符串；
- 用于表示一个复杂对象的构造函数，其中一些属性由可变参数来表示。
4️⃣ 使用和原理
* 使用方式
声明可变参数时需要在类型后面加上省略号(...)，例如public void methodName(Type... variableName)。
下面是一个示例代码，演示了使用可变参数的方法：
public class VariableArgumentsExample {
public static void sumNumbers(int... numbers) {
int sum = 0;
for (int num : numbers) {
sum += num;
}
System.out.println("Sum: " + sum);
}
public static void main(String[] args) {
sumNumbers(1, 2, 3); // 可传入任意数量的参数
sumNumbers(4, 5, 6, 7, 8);
}
}
运行结果：
Sum: 6
Sum: 30
在上述示例中，sumNumbers()方法接受可变参数numbers，并计算它们的总和。方法体内部使用了增强的for循环来遍历可变参数数组，实现求和的逻辑。
* 原理
编译器会将可变参数转换为数组，然后将其传递给方法。在方法内部，我们可以像操作数组一样操作这个参数。
下面是一个示例代码，演示了可变参数的原理：
class PrincipleExample {
public static void printInfo(String... numbers) {
if (numbers instanceof String[]){
System.out.println("传入的可变参数是一个字符串数组：" + numbers);
for (int i = 0; i <= 3; i++) {
System.out.println(numbers[i]);
}
}
}
public static void main(String[] args) {
printInfo("hello","world","!"); // 可传入任意数量的参数
}
}
运行结果：
传入的可变参数是一个字符串数组：[Ljava.lang.String;@1b6d3586
hello
world
!
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
at com.example.PrincipleExample.printInfo(VariableArgumentsExample.java:26)
at com.example.PrincipleExample.main(VariableArgumentsExample.java:32)
这个Java程序示例主要包含了一个类 PrincipleExample 和两个方法。
第一个方法 printInfo 是一个静态方法，接受可变参数 String... numbers。通过使用可变参数的语法 ...，该方法可以接受任意数量的字符串参数。在方法体内部，我使用 instanceof 运算符判断输入参数 numbers 是否为字符串数组类型(String[])。如果条件成立，即传入的参数确实为字符串数组，将打印出一条消息以及接下来的四个参数值（元素索引从0到3）。
由于循环条件是 i <= 3，所以导致了数组越界异常，程序报错打印出了异常信息。正确的应将循环条件修改为 i < numbers.length，以适应不同数量的输入参数。
5️⃣ 使用技巧
5.1 可变参数结合泛型
可变参数（Varargs）可以理解为一个方法接受可变数量的相同类型参数，它是Java语言提供的一种方便的语法糖。在方法声明中，使用三点(…)表示可变参数。在方法内部，可变参数被当作数组处理，允许将传入的参数当作数组来操作。
泛型是Java语言的一种特性，它使我们能够编写更加通用灵活的代码。通过引入类型参数，在创建实例或调用方法时，可以在编译期间指定类型，并且对其进行类型检查。这样就可以实现代码的重用和类型安全。
这两个特性之间并没有直接关联，但它们可以结合使用来优化代码的灵活性和可读性。下面是一个结合应用的示例：
public class VariableArgumentsAndGenerics {
public static <T> void printArray(T... elements) {
for (T element : elements) {
System.out.print(element + " ");
}
System.out.println();
}
public static void main(String[] args) {
Integer[] intArray = {
1, 2, 3, 4, 5};
Double[] doubleArray = {
1.1, 2.2, 3.3, 4.4};
// 使用可变参数和泛型的方法打印整型数组
System.out.print("Integer Array: ");
printArray(intArray);
// 使用可变参数和泛型的方法打印双精度浮点型数组
System.out.print("Double Array: ");
printArray(doubleArray);
// 使用可变参数和泛型的方法打印字符串数组
System.out.print("String Array: ");
printArray("Hello", "World");
}
}
输出结果：
Integer Array: 1 2 3 4 5
Double Array: 1.1 2.2 3.3 4.4
String Array: Hello World
在上述代码中，printArray是一个泛型方法，使用可变参数来接收不定数量的元素。无论传入的是什么类型的数组或者一系列对象，该方法都能够打印出这些元素。
在main方法中，创建了一个整型数组、一个双精度浮点型数组，然后调用printArray方法分别打印了这两个数组的元素。另外，还传递了一系列字符串作为参数，同样可以成功打印出来。
通过使用可变参数和泛型结合的方法，我们可以灵活地处理不同类型的数据，并且无需在编写方法时预先确定参数的数量或者类型。
根据具体的需求，我们可以结合使用它们来设计更加灵活和强大的代码。
5.2 使用元组或列表进行参数传递
可变参数通常使用元组或列表来接收多个参数值。这样可以将所有参数打包成一个容器，方便进行操作和传递。
下面是一个案例程序，演示如何使用元组或列表进行可变参数传递：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ParameterPassingDemo {
// 使用元组作为参数
public static void processTuple(Object... params) {
System.out.println("传入的参数个数：" + params.length);
for (Object param : params) {
System.out.println("参数值：" + param);
}
}
// 使用列表作为参数
public static void processList(List<Object> params) {
System.out.println("传入的参数个数：" + params.size());
for (Object param : params) {
System.out.println("参数值：" + param);
}
}
public static void main(String[] args) {
// 使用元组传递参数
processTuple(10, "Hello", true);
// 使用列表传递参数
List<Object> listParams = new ArrayList<>(Arrays.asList(20, "World", false));
processList(listParams);
}
}
运行结果：
传入的参数个数：3
参数值：10
参数值：Hello
参数值：true
传入的参数个数：3
参数值：20
参数值：World
参数值：false
在上述示例中，定义了两个方法 processTuple 和 processList 来处理参数。processTuple 方法使用可变参数的形式接收多个参数，而 processList 方法则接收一个列表作为参数。
在main 方法中，我分别演示了使用元组和列表来传递参数。首先，在调用 processTuple 方法时直接传递了多个参数，它们会被打包成元组并作为参数传递给方法。然后，创建了一个列表 listParams，并将参数添加到该列表中，最后通过传递该列表来调用 processList 方法。
无论是使用元组还是使用列表，都可以方便地打包多个参数并进行传递。这样做的好处是可以灵活处理不同数量和类型的参数，并且可以在方法内部进行统一的操作。
5.3 使用默认值
可变参数通常与其他参数一起使用，为了提高可变参数的灵活性，在定义函数时可以为可变参数设置默认值。这样，在调用函数时可以选择性地传递额外的参数值，如果没有传递，则使用默认值。
下面是一个Java程序，演示了可变参数与其他参数一起使用时，使用默认值的情况：
public class DefaultValuesExample {
public static void main(String[] args) {
// 调用函数时选择性传递额外的参数值
printValues("Hello", "world");
printValues("Hello");
}
// 定义函数时为可变参数设置默认值
public static void printValues(String prefix, String... values) {
System.out.print(prefix + ": ");
if (values.length == 0) {
System.out.println("No values");
} else {
for (String value : values) {
System.out.print(value + " ");
}
System.out.println();
}
}
}
输出结果：
Hello: world
Hello: No values
在上面的例子中，定义了一个方法 printValues ，方法使用了可变参数和其他参数，并为可变参数设置了默认值。
首先，我们调用了 printValues 函数并选择性地传递了额外的参数值。第一次调用时，传递了两个参数 “Hello” 和 “world”，第二次调用时只传递了一个参数 “Hello”。在这两种情况下，函数都会按照传递的参数值进行输出。以上程序演示展示了如何使用默认值来增加可变参数的灵活性。
5.4 缓存计算结果
如果可变参数需要进行复杂的计算或查询操作，可以考虑在函数内部实现缓存机制，以避免重复计算相同的结果。例如，可以使用字典或缓存库来存储已计算的结果，并在每次函数调用时先检查缓存中是否存在对应的结果。
下面是一个使用可变参数时，实现缓存机制的Java示例程序：
import java.util.HashMap;
import java.util.Map;
public class CalculationCache {
private static Map<String, Integer> resultCache = new HashMap<>();
public static int calculate(int... numbers) {
String key = arrayToString(numbers);
// 检查缓存中是否存在结果
if (resultCache.containsKey(key)) {
System.out.println("从缓存中获取结果");
return resultCache.get(key);
}
// 计算结果
System.out.println("进行复杂计算...");
int result = 0;
for (int num : numbers) {
result += num;
}
// 将结果存入缓存
resultCache.put(key, result);
return result;
}
private static String arrayToString(int[] numbers) {
StringBuilder sb = new StringBuilder();
for (int num : numbers) {
sb.append(num).append(",");
}
return sb.toString();
}
public static void main(String[] args) {
System.out.println(calculate(1, 2, 3)); // 进行复杂计算...
// 输出：6
System.out.println(calculate(1, 2, 3)); // 从缓存中获取结果
// 输出：6
System.out.println(calculate(4, 5, 6)); // 进行复杂计算...
// 输出：15
}
}
运行结果：
进行复杂计算...
6
从缓存中获取结果
6
进行复杂计算...
15
在上述示例中，创建了一个名为CalculationCache的类，其中包含了一个静态的resultCache字典用于存储已计算结果。calculate方法接受可变参数，并将参数转化为一个唯一的字符串作为缓存的键。首先，检查该键是否存在于缓存中，如果存在，则直接返回缓存结果；否则，进行复杂计算，在计算完成后将结果存入缓存字典中。
通过运行main方法中的示例调用，我们可以观察到第一次调用时进行了复杂计算，并将结果存入缓存。而后续相同参数的调用直接从缓存中获取结果，避免了重复计算。
综上所述，以上提到的技巧是一些一般性的建议。具体使用时请根据编程语言和实际需求进行适当调整。
6️⃣ 实战：构建动态日志工具
下面是一个Java实战程序，演示了可变参数在构建动态日志工具中的作用，使用 log4j作为日志工具：
import org.apache.log4j.Logger;
public class DynamicLogger {
private final Logger logger;
public DynamicLogger(Class<?> clazz) {
logger = Logger.getLogger(clazz);
}
public void log(String message, Object... args) {
if (logger.isDebugEnabled()) {
String formattedMessage = formatMessage(message, args);
logger.debug(formattedMessage);
}
}
private String formatMessage(String message, Object... args) {
if (args.length > 0) {
return String.format(message, args);
}
return message;
}
public static void main(String[] args) {
DynamicLogger dynamicLogger = new DynamicLogger(DynamicLogger.class);
String name = "John";
int age = 28;
dynamicLogger.log("Hello, %s! Your age is %d.", name, age);
dynamicLogger.log("Logging without any arguments.");
}
}
运行结果：
[DEBUG] 2023-06-22 15:38:40,624 method:com.example.DynamicLogger.log(DynamicLogger.java:15)
Hello, John! Your age is 28.
[DEBUG] 2023-06-22 15:38:40,626 method:com.example.DynamicLogger.log(DynamicLogger.java:15)
Logging without any arguments.
在这个示例中，定义了一个DynamicLogger类来构建动态日志工具。在构造函数中，接收一个Class<?>类型的参数，用于指定将要被记录的类。然后，我们使用log4j的Logger.getLogger方法来创建一个logger实例。
DynamicLogger类中有一个log方法，它接收一个格式化的消息字符串和可变参数列表(args)。该方法首先检查是否启用了debug级别的日志记录，然后使用formatMessage方法对消息进行格式化，并最终调用logger实例的debug方法记录日志。
formatMessage方法用于将消息字符串格式化。如果参数列表(args)的长度大于0，则使用String.format方法对消息进行格式化，否则返回原始消息字符串。
在main方法中，我们创建了一个DynamicLogger对象，并使用不同的参数调用log方法来演示可变参数的用法。第一次调用时，我们传递了两个参数name和age来格式化日志消息。第二次调用时，我们没有传递任何参数，仅仅记录了静态消息。当然，你可以根据需要在程序中使用更多的日志记录。
* 总结
在Java中，可变参数是一项强大的特性，允许我们以更加灵活的方式处理方法参数。通过使用可变参数，我们可以传递任意数量的相同类型的参数给方法，而无需明确指定参数个数。本文探讨了可变参数的概念、优势和缺点、特征以及应用场景、使用方式及技巧以及在实际生产项目中的应用。
可变参数为处理不确定数量参数的场景提供了灵活、便捷而且易读的方式。在合适的地方使用可变参数可以提高代码的效率和可维护性。同时，也应当注意可变参数可能带来的性能损耗问题，并在实际使用中进行评估和权衡。
[
]nbsp_nbsp 1