假设我有一个方法，它接受一个数组并使用 Java 内置的 for-each loop 处理其中的每个元素，如下所示：
public static void myFun(SomeClass[] arr) {
for (SomeClass sc : arr) {
// Stuff is processed here
}
}
这很好用，但现在我希望能够将相同的方法传递给 List<SomeClass>。我注定要使用Collection.toArray(T [])，还是有一个可以用于myFun() 的参数，它接受可以在for-each 构造中使用的任何类型？
澄清一下：我想要一个可以接受任何可迭代对象的方法签名，无论是原始数组还是集合。我可以很容易地编写两种方法，一种包装另一种，但我只是好奇是否有更好的方法。
【问题讨论】：
我建议使用Iterable、Collection 或List 作为参数类型。
IMO，集合应该优先于引用数组。如果您碰巧有一个数组Arrays.asList，则转换效果很好。 Arrays.asList 允许获取和设置回数组，但显然不允许更改数组长度的“结构”修改。
myFun(Arrays.asList(arr));
在极端/一般情况下，您可能必须使用通配符。
public static void myFun(Iterable<? extends SomeClass> somethings) {
for (SomeClass something : somethings) {
// something is processed here
}
}
值得注意的是Collections.toArray 和Arrays.asList 的工作方式略有不同。 asList 保留原始数组以支持集合，因此对集合的更改将反映在数组中。 Collections.toArray 制作收集数据的（浅）副本。如果您要返回一个数组，那么制作副本通常是您想要的。不对称地，如果您作为参数传递，则通常不会复制（除非存储为字段）。
【讨论】：
【讨论】：
你不能，java Arrays 没有实现 Iterable：
public static int sum(Iterable<Integer> elements) {
int s = 0;
for (int i : elements) {
s += i;
}
return s;
}
public static void main(String[] args) {
L1: System.out.println(sum(1,2,3));
L2: System.out.println(sum(Arrays.asList(1,2,3)));
L3: System.out.println(sum(new int[] { 1,2,3 }));
}
这会导致（L1 和 L3）出现两个编译时错误；所以你必须设计你的 方法来接受一个可迭代（集合）和/或数组，至少一个方法必须执行一些转换（到/从数组）
解决方法：
您可以尝试使用适配器：
public class ArrayIterator<T> implements Iterator<T> {
private final T[] array;
private int i;
public ArrayIterator(T[] anArray) {
array = anArray;
i = 0;
}
public boolean hasNext() {
return i < array.length;
}
public T next() {
return array[i++];
}
public void remove() {
throw new UnsupportedOperationException();
}
}
private static int sum(final Integer ... elements) {
return sum(new Iterable<Integer>() {
public Iterator<Integer> iterator() {
return new ArrayIterator<Integer>(elements);
}
});
}
只有在处理原始数组时才应注意；当你只使用 引用对象（你的情况）ArrayIterator + 匿名类很酷
希望对你有帮助
【讨论】：
简短的回答：不，没有一个方法签名可以安全地接受 Iterable 和数组。显然你可以接受Object，但这也是一种黑客攻击。
冗长的回答：由于增强的for-loop 被有效地定义了两次（一次用于数组，一次用于Iterable），您还需要提供两个重载方法：
public static void myFun(SomeClass[] array) {
for (SomeClass sc : array) {
doTheProcessing(sc);
}
}
public static void myFun(Iterable<? extends SomeClass> iterable) {
for (SomeClass sc : iterable) {
doTheProcessing(sc);
}
}
虽然这两种方法的来源看起来完全一样，但您需要定义两次（当然，除非您按照@dfa 的说明将数组包装在自己的Iterable 中）。
【讨论】：
在 Java 1.5+ 中有一个鲜为人知的 Java 泛型特性，您可以在方法调用和构造函数中使用 <? extends Subtype>。你可以使用<? extends Object>，然后任何处理这些的东西都只能访问对象上的方法。你可能真正想要的是更像这样的东西：
List<? extends MyCrustaceans> seaLife = new ArrayList<? extends MyCrustaceans>();
MyShrimp s = new MyShrimp("bubba");
seaLife.add(s);
DoStuff(seaLife);
...
public static void DoStuff(List<? extends MyCrustaceans> seaLife)
{
for (MyCrustaceans c : seaLife) {
System.out.println(c);
}
}
因此，如果您有一个基类（如 MyCrustaceans），则可以在 DoStuff 中使用该基类的任何方法（或 Object 类的任何方法，如果您的参数是 <? extends Object>）。 <? super MyType> 有一个类似的特性，它接受一个参数，该参数是给定类型的超类型，而不是子类型。以这种方式可以使用“extends”和“super”有一些限制。这是good place to find more info。
【讨论】：
public static void myFun(Collection<MyClass> collection) {
for (MyClass mc : collection) {
// Stuff is processed here
}
}
【讨论】：