Tjyylli

Regarding a condition to check if foo is either a collection or an array:

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. Having no particular context, I can come up with a simple idea of two subclasses, each of which defining how its source (either a collection or an array) should be iterated. Then, programming to an interface will help to manage them equally.

A very simplified example would be:

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

    }

}

I believe the approach above is pretty versatile. You don't depend on how a certain source is iterated, you may selectively modify them.

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.

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

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

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



}

Edit:

In terms of iterating over this foo object, there is no simple solution. However you could try something like this:

private void iterate(@NotNull Object foo) {

    if (foo instanceof Collection<?>) {

        for (Object o : ((Collection<?>) foo)) {

            chandleYourObject(o);

        }

    }



    if (foo.getClass().isArray()) {

        if (foo.getClass().isPrimitive()) {

            checkPrimitiveTypes(foo);

        }

        if (foo instanceof Object[]) {

            for (Object o : (Object[]) foo) {

                chandleYourObject(o);

            }

        }

    }

}



private void checkPrimitiveTypes(Object foo) {

    if (foo instanceof int[]) {

        for (int i : (int[]) foo) {



        }

    }

    //And the rest of primitive types

}



private void chandleYourObject(Object o ){

    //What you want to do with your object

}

Arrays are Objects:

https://docs.oracle.com/javase/specs/jls/se8/html/jls-10.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());