我可以将数组作为参数传递给 Java 中具有可变参数的方法吗？

Question

我希望能够创建一个如下函数：

class A {
  private String extraVar;
  public String myFormat(String format, Object ... args){
    return String.format(format, extraVar, args);
  }
}

这里的问题是 args 在方法 myFormat 中被视为 Object[] ，因此是 String.format 的单个参数，而我希望将 args 中的每个 Object 作为新参数传递。由于 String.format 也是一个带有可变参数的方法，所以这应该是可能的。

如果这是不可能的，是否有类似 String.format(String format, Object[] args) 的方法？在这种情况下，我可以使用新数组将 extraVar 附加到 args 并将其传递给该方法。

Answer 1

是的，T... 只是 T[] 的语法糖。

JLS 8.4.1 格式参数< /a>

列表中的最后一个形式参数是特殊的；它可能是一个变量数量参数，由类型后面的省略号指示。

如果最后一个形参是T类型的可变参数，则认为定义了T[]类型的形参。该方法是一个可变参数方法。否则，它是一个固定数量方法。变量数量方法的调用可能包含比形式参数更多的实际参数表达式。所有与变量参数前面的形式参数不对应的实际参数表达式都将被计算，并将结果存储到一个数组中，该数组将传递给方法调用。

下面是一个例子来说明：

public static String ezFormat(Object... args) {
    String format = new String(new char[args.length])
        .replace("\0", "[ %s ]");
    return String.format(format, args);
}
public static void main(String... args) {
    System.out.println(ezFormat("A", "B", "C"));
    // prints "[ A ][ B ][ C ]"
}

是的，上面的 main 方法是有效的，因为 String... 只是 String[]。此外，由于数组是协变的，String[] 是 Object[]，因此您也可以以任何一种方式调用 ezFormat(args)。

另请参阅

• Java 语言指南/varargs

---

#1: 传递 null

可变参数的解析是相当复杂的，有时它会做一些让你惊讶的事情。

考虑这个例子：

static void count(Object... objs) {
    System.out.println(objs.length);
}

count(null, null, null); // prints "3"
count(null, null); // prints "2"
count(null); // throws java.lang.NullPointerException!!!

由于可变参数的解析方式，最后一个语句使用 objs = null 进行调用，这当然会导致 NullPointerException 与 objs.length >。如果您想为 varargs 参数提供一个 null 参数，您可以执行以下任一操作：

count(new Object[] { null }); // prints "1"
count((Object) null); // prints "1"

相关问题

以下是人们在处理 varargs 时提出的一些问题的示例：

• 可变参数和重载的错误？
• 如何使用可变参数和反射
• 与固定/变量数量（可变参数）匹配的最具体方法

---

Vararg 陷阱 #2：添加额外参数

正如您所发现的出来，以下内容不起作用：

    String[] myArgs = { "A", "B", "C" };
    System.out.println(ezFormat(myArgs, "Z"));
    // prints "[ [Ljava.lang.String;@13c5982 ][ Z ]"

由于可变参数的工作方式，ezFormat 实际上获取 2 个参数，第一个是 String[]，第二个是字符串。如果您将数组传递给 varargs，并且希望其元素被识别为单独的参数，并且还需要添加额外的参数，那么您别无选择，只能创建另一个数组容纳额外的元素。

以下是一些有用的辅助方法：

static <T> T[] append(T[] arr, T lastElement) {
    final int N = arr.length;
    arr = java.util.Arrays.copyOf(arr, N+1);
    arr[N] = lastElement;
    return arr;
}
static <T> T[] prepend(T[] arr, T firstElement) {
    final int N = arr.length;
    arr = java.util.Arrays.copyOf(arr, N+1);
    System.arraycopy(arr, 0, arr, 1, N);
    arr[0] = firstElement;
    return arr;
}

现在您可以执行以下操作：

    String[] myArgs = { "A", "B", "C" };
    System.out.println(ezFormat(append(myArgs, "Z")));
    // prints "[ A ][ B ][ C ][ Z ]"

    System.out.println(ezFormat(prepend(myArgs, "Z")));
    // prints "[ Z ][ A ][ B ][ C ]"

---

Varargs 陷阱#3：传递基元数组

它不起作用：

    int[] myNumbers = { 1, 2, 3 };
    System.out.println(ezFormat(myNumbers));
    // prints "[ [I@13c5982 ]"

Varargs 仅适用于引用类型。自动装箱不适用于基元数组。以下作品：

    Integer[] myNumbers = { 1, 2, 3 };
    System.out.println(ezFormat(myNumbers));
    // prints "[ 1 ][ 2 ][ 3 ]"

Answer 2

可变参数方法的基础类型 function(Object... args) 是 函数(Object[] args)。 Sun 以这种方式添加可变参数以保持向后兼容性。

因此，您应该能够在 args 前面添加 extraVar 并调用 String.format(format, args)。

Answer 3

传递一个数组是可以的 - 事实上它相当于相同的东西

String.format("%s %s", "hello", "world!");

，

String.format("%s %s", new Object[] { "hello", "world!"});

它只是语法糖 - 编译器将第一个转换为第二个，因为底层方法需要 vararg 参数。

请参阅

• Varargs - J2SE 1.5 文档

Answer 4

jasonmp85 关于将不同的数组传递给 String.format 的说法是正确的。数组的大小一旦构造就无法更改，因此您必须传递一个新数组而不是修改现有数组。

Object newArgs = new Object[args.length+1];
System.arraycopy(args, 0, newArgs, 1, args.length);
newArgs[0] = extraVar; 
String.format(format, extraVar, args);

Answer 5

我有同样的问题。

String[] arr= new String[] { "A", "B", "C" };
Object obj = arr;

然后将 obj 作为 varargs 参数传递。
它起作用了。

Answer 6

除了 @genelubricant 的#2 - 如果只读就足够了，并且如果您想付出一些额外的努力来获得 List 的一些便利 - 不一定需要复制数组并包装它，加上在访问时在任意索引处注入所需的额外值，可以这样实现：

public static <T> List<Object> wrappedUnmodfiableListInsertion(final T insert, final Integer insertIdx, final T... source) {
  final boolean isInsertion = insertIdx != null;
  return new AbstractList<Object>() {
    @Override
    public int size() {
      return source != null ? isInsertion ? source.length + 1 : source.length : 0;
    }
    @Override
    public Object get(int index) {
      if (source == null) {
        if (isInsertion) {
          return index == insertIdx && index == 0 ? insert : null;
        }
        return EMPTY_LIST;
      } 
      if (isInsertion) {
        if (index == insertIdx) {
          return insert;
        } 
        return source[insertIdx > index ? index : index - 1];
      }
      return source[index];
    }
  };
}