强制使用数组调用以解析为可变参数调用

Question

好的，所以我有一个类似的功能

public static UnorderedList newUnorderedList(Object... items) {
    return new UnorderedList(
        stream(items)
            .peek(e -> checkNotNull(e, "Cannot create null list item"))
            .map(e -> {
                if (e instanceof Component) return newListItem((Component) e);
                if (e instanceof String) return newListItem((String) e);
                throw new IllegalArgumentException("List item must be String or Component but is neither: " + e.getClass().getName());
            }).toArray(ListItem[]::new)
    );
}

（编辑：注意：这里的UnorderedList，是Vaadin 对html <ul> 标签的实现，我不是要获取java 列表。）

当你用一个数组调用它时，这会触发一个警告，说不清楚你是将数组本身视为单个元素还是元素的容器。

不要立即看到摆脱这种情况的优雅方法。这两个我都不喜欢：

• 始终转换为Object[]
• 把Object...变成Collection<Object>

是否有注释或其他东西可以让编译器知道始终将数组解析为对带注释的方法的可变参数调用？ （在方法声明上，而不是调用站点。）

Answer 1

你可以重载方法：

public static UnorderedList newUnorderedList(Object first, Object... other) {
    return newUnorderedListImpl(Stream.concat(Stream.of(first), Arrays.stream(other)));
}
public static UnorderedList newUnorderedList(Object[] items) {
    return newUnorderedListImpl(Arrays.stream(items));
}
private static UnorderedList newUnorderedListImpl(Stream<?> items) {
    return new UnorderedList(
        items
            .peek(e -> checkNotNull(e, "Cannot create null list item"))
            .map(e -> {
                if (e instanceof Component) return newListItem((Component) e);
                if (e instanceof String) return newListItem((String) e);
                throw new IllegalArgumentException("List item must be String or Component but is neither: " + e.getClass().getName());
            }).toArray(ListItem[]::new)
    );
}

然后，使用现有数组的调用将结束于newUnorderedList(Object[] items)，而实际的可变参数调用将结束于newUnorderedList(Object first, Object... other)，即使只指定了一个参数，只要该参数不是数组。由于单个参数应该是String 或Component，所以这不是问题。

这两种方法失去的唯一可能性是在没有参数的情况下调用方法的能力。如果这是一个问题，您需要添加另一个重载：

public static UnorderedList newUnorderedList() {
    return newUnorderedListImpl(Stream.empty());
}

Answer 2

您以错误的方式制作 UnorderedList。

假设它是一个集合：

    Object[] objects = new Object[]{1, "hello", "there", "george"};
    LinkedList<AtomicReference<?>> list = Arrays.stream(objects)
            .filter(Objects::nonNull)
            .map(e -> {
                if (e instanceof Integer) return new AtomicReference<>(e);
                if (e instanceof StringBuilder) return new AtomicReference<>(e);
                throw new IllegalArgumentException("PAIN");
            })
            .collect(Collectors.toCollection(LinkedList::new));

Answer 3

根据您的问题，我猜您想要执行以下操作：

Object [] items = new Object [x];
items [0] = new Object [] {"Object1", "Object2", "Object3"};
var result = newUnorderedList( items );

这会将带有String的数组视为单个项目，导致异常，同时调用

var result = newUnorderedList( items [0] );

将为result 返回 3 个元素。

没有注释强制将单个数组作为单个项目而不是项目列表进行处理。享受这样的签名：

Object function( Object [] ... );