關于檢查 foo 是集合還是數組的條件：
類#是可分配的可能派上用場。
Class<?> fooClass = foo.getClass();
boolean isArrayOrCollection = Collection.class.isAssignableFrom(fooClass) ||
Object[].class.isAssignableFrom(fooClass);
我合理地假設你不會在基元數組上測試它，因為你有只使用包裝類的集合。
我想你可以安全地替換為Object[].class.isAssignableFrom(fooClass)fooClass.isArray()
boolean isArrayOrCollection = Collection.class.isAssignableFrom(fooClass) ||
fooClass.isArray();
它也適用于基元數組類。
我運行了一個小的“測試”
class Test {
public static void main(String[] args) {
Predicate<Class<?>> p = c -> Collection.class.isAssignableFrom(c) ||
c.isArray();
System.out.println(p.test(new int[0].getClass()));
System.out.println(p.test(new Integer[0].getClass()));
System.out.println(p.test(Collections.emptyList().getClass()));
System.out.println(p.test(Collections.emptySet().getClass()));
System.out.println(p.test(Collections.emptyMap().getClass()));
}
}
這導致
true
true
true
true
false
關于將同時在數組和集合上運行的泛型循環：
你根本無法寫一個準確的構造來處理這個問題：（或）并且幾乎沒有共同點（因為一個共同的父級及其方法是不夠的）。CollectionIterableObject[]Object
我認為構建自己的抽象是明智的，它將以相同的方式處理集合和數組。由于沒有特定的上下文，我可以想出兩個子類的簡單想法，每個子類都定義了它的源代碼（集合或數組）應該如何迭代。然后，對接口進行編程將有助于平等地管理它們。
一個非常簡化的例子是：
interface Abstraction<T> {
void iterate(Consumer<? super T> action);
static <T> Abstraction<T> of(Collection<T> collection) {
return new CollectionAbstraction<>(collection);
}
static <T> Abstraction<T> of(T[] array) {
return new ArrayAbstraction<>(array);
}
static IntArrayAbstraction of(int[] array) {
return new IntArrayAbstraction(array);
}
}
class CollectionAbstraction<T> implements Abstraction<T> {
Collection<T> source;
public CollectionAbstraction(Collection<T> source) {
this.source = source;
}
@Override
public void iterate(Consumer<? super T> action) {
source.forEach(action);
}
}
class ArrayAbstraction<T> implements Abstraction<T> {
T[] source;
public ArrayAbstraction(T[] source) {
this.source = source;
}
@Override
public void iterate(Consumer<? super T> action) {
for (T t : source) {
action.accept(t);
}
}
}
class IntArrayAbstraction implements Abstraction<Integer> {
int[] source;
public IntArrayAbstraction(int[] source) {
this.source = source;
}
@Override
public void iterate(Consumer<? super Integer> action) {
for (int t : source) {
action.accept(t);
}
}
}
class Test {
public static void main(String[] args) {
Abstraction.of(new Integer[] {1, 2, 3}).iterate(System.out::println);
Abstraction.of(Arrays.asList(1, 2, 3)).iterate(System.out::println);
Abstraction.of(new int[] {1, 2, 3}).iterate(System.out::println);
}
}
我相信上面的方法非常通用。您不依賴于某個源的迭代方式，您可以有選擇地修改它們。
