番石榴连接器为什么要实现一个可迭代的私有方法（首先是最终对象，最后是最终对象，最后是Object []其余）？

Question

private static Iterable<Object> iterable(
        final Object first, final Object second, final Object[] rest) {
    checkNotNull(rest);
    return new AbstractList<Object>() {
        @Override
        public int size() {
            return rest.length + 2;
        }

        @Override
        public Object get(int index) {
            switch (index) {
                case 0:
                    return first;
                case 1:
                    return second;
                default:
                    return rest[index - 2];
            }
        }
    };
}

作者的目的是什么？

我猜他想利用编译器生成的数组，而不是新建一个ArrayList。

但仍然是一个令人困惑的问题，为什么不写如下呢？

private static Iterable<Object> iterable(final Object[] rest) {
    checkNotNull(rest);
    return new AbstractList<Object>() {
        @Override
        public int size() {
            return rest.length;
        }

        @Override
        public Object get(int index) {
            return rest[index];
        }
    };
}

Answer 1

这里的要点是从类似于（ source ）的公共方法中调用此方法：

  public final String join(
      @NullableDecl Object first, @NullableDecl Object second, Object... rest) {
    return join(iterable(first, second, rest));
  }

使用这样的签名是一种技巧，它迫使您至少传入两个参数-毕竟，如果您没有两个参数，则没有任何要加入的参数。

例如：

Joiner.on(':').join();  // Compiler error.
Joiner.on(':').join("A");  // Compiler error.
Joiner.on(':').join("A", "B");  // OK.
Joiner.on(':').join("A", "B", "C");  // OK.
// etc.

这种iterable方法只需创建一个Iterable而不必将所有内容都复制到新数组中。 这样做将使参数个数为O(n) ； 这里采用的方法是O(1) 。