Xrhrft

Class#isAssignableFrom may come in handy.

Class<?> fooClass = foo.getClass();

boolean isArrayOrCollection = Collection.class.isAssignableFrom(fooClass) ||

                              Object.class.isAssignableFrom(fooClass);

I reasonably assume you won't test it on primitive arrays since you have collections which work only with the wrapper classes.

I guess you can safely replace Object.class.isAssignableFrom(fooClass) with fooClass.isArray()

boolean isArrayOrCollection = Collection.class.isAssignableFrom(fooClass) ||

                              fooClass.isArray();

and it would also work for a primitive array class.

I've run a small "test"

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()));

    }

}

which results in

true

true

true

true

false

Regarding a generic loop that would run over both arrays and collections:

You simply can't write an accurate construction to handle this: Collection (or Iterable) and Object have little in common (Object as a common parent and its methods are not enough).

I think it's sensible to build own abstraction which would treat collections and arrays in the same manner.

You can check if object is array by using isArray() method from Class

if (foo != null && (foo.getClass().isArray() || foo instanceof Collection<?>)){



}

Arrays extend Object:

https://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html

AbstractCollections also extend Object:

https://docs.oracle.com/javase/8/docs/api/java/util/AbstractCollection.html

So yes there is a common superclass, but unfortunately this isn't really going to help you.

I would suggest your best bet is to use:

List<> someList = Arrays.asList(sourceArray)

This will convert your array into a collection that implements Iterable. You will of course need to work out if the initial object is an Array or a Collection in advance and only call the above if it is an array, here are some options for doing that:

boolean isArray = myArray.getClass().isArray();

boolean isCollection = Collection.class.isAssignableFrom(myList.getClass());

You could write a helper method for this:

@SuppressWarnings("unchecked")

public static <E> void forEach(Object arrayOrIterable, Consumer<? super E> action) {

    Objects.requireNonNull(arrayOrIterable);

    if (arrayOrIterable instanceof Iterable) {

        for (Object o : (Iterable<?>) arrayOrIterable) {

            action.accept((E) o);

        }

    } else if (arrayOrIterable.getClass().isArray()) {

        int length = Array.getLength(arrayOrIterable);

        for (int i = 0; i < length; i++) {

            action.accept((E) Array.get(arrayOrIterable, i));

        }

    } else {

        throw new IllegalArgumentException("not an array nor iterable: " + arrayOrIterable.getClass());

    }

}

The second branch makes use of the java.reflect.Array class which provides helper methods (may be slow), to get the length of an array and the element at a given index.

You may call it like this:

int ints = {1, 2, 3, 4};

forEach(ints, (Integer i) -> System.out.println(i));



List<Integer> ints = Arrays.asList(1, 2, 3, 4);

forEach(ints, (Integer i) -> System.out.println(i));

Due to the nature of generics, this method may throw a ClassCastException, e.g. this call:

int ints = {1, 2, 3, 4};

forEach(ints, (String s) -> System.out.println(s));

Would result in:

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

Depending on what you are trying to do, you might want to implement two similar methods:

public <T> void iterateOver(List<T> list) {

    // do whatever you want to do with your list

}



public <T> void iterateOver(T array) {

    this.iterateOver(Arrays.asList(array));

}

Or maybe even have an interface for this:

interface ExtendedIterableConsumer<T> {



    public void iterateOver(List<T> list);



    public default void iterateOver(T array) {

        this.iterateOver(Arrays.asList(array));



}

I am not sure if that helps you, because you seem to already have the object in question in a variable somewhere. But if you can address that problem one level higher, it might be useful.

The other answers are all trying hard to answer the title question, but your real question is in the body. The answer is: No, there's no way to write a single for loop that iterates over both collections and arrays.

You could jump through a bunch of hoops to turn the arrays into lists, but you'll almost certainly end up with a bigger mess than if you just wrote two (or more) loops. Calling getClass().isArray() tells you what you have but you still can't work with it without some sort of cast. Arrays.asList() doesn't work for arrays of primitives.