【Java高级语法】(十二)可变参数:Java中的“可变之美“,做好这些细节,你的程序强大又灵活~

Java高级语法详解之可变参数

  • 前言
  • 1️⃣ 概念
  • 2️⃣ 优势和缺点
  • 3️⃣ 特征和应用场景
    • 3.1 特征
    • 3.2 应用场景
  • 4️⃣ 使用和原理
  • 5️⃣ 使用技巧
    • 5.1 可变参数结合泛型
    • 5.2 使用元组或列表进行参数传递
    • 5.3 使用默认值
    • 5.4 缓存计算结果
  • 6️⃣ 实战:构建动态日志工具
  • 总结

【Java高级语法】(十二)可变参数:Java中的“可变之美“,做好这些细节,你的程序强大又灵活~_第1张图片

前言

你是不是曾经为了传递不确定数量的参数而纠结不已?在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

在上述示例中,定义了两个方法 processTupleprocessList 来处理参数。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中,可变参数是一项强大的特性,允许我们以更加灵活的方式处理方法参数。通过使用可变参数,我们可以传递任意数量的相同类型的参数给方法,而无需明确指定参数个数。本文探讨了可变参数的概念、优势和缺点、特征以及应用场景、使用方式及技巧以及在实际生产项目中的应用。

可以了解到,可变参数是Java提供的一项强大特性,它为处理不确定数量参数的场景提供了灵活、便捷而且易读的方式。在合适的地方使用可变参数可以提高代码的效率和可维护性。同时,也应当注意可变参数可能带来的性能损耗问题,并在实际使用中进行评估和权衡。


在这里插入图片描述

你可能感兴趣的:(Java,java,jvm,开发语言)