Java accept different type of parameters without overloading

Question

Here is a very simple example:

private boolean f(List x) {
    return x != null && !x.isEmpty();
}

private boolean f(Map x) {
    return x != null && !x.isEmpty();
}

Code inside both function is same, they just operate on different objects. I want to merge them into one function to avoid code repeatation.

I tried something like:

private <T> boolean f(T x) {
    return x != null && !x.isEmpty();
}

But it gives error on x.isEmpty()

Answer 1

Where the parts of what you want to use are covered by an interface implemented by both classes, use that interface.

But in your case, List and Map don't share an interface that provides isEmpty, so your options are:

1. Overloading (the following is your code unchanged)

   private boolean f(List x) {
       return x != null && !x.isEmpty();
   }
   private boolean f(Map x) {
       return x != null && !x.isEmpty();
   }
   

2. Accepting Object and using instanceof branches

   private boolean f(Object x) {
       // (roughly)
       if (x == null) {
           return false;
       }
       if (x instanceof List) {
           return !((List)x).isEmpty();
       }
       if (x instanceof Map) {
           return !((Map)x).isEmpty();
       }
       throw new IllegalArgumentException(); // Or whatever
   }
   

3. Accepting Object and using reflection to get the isEmpty method (if any) and call it

   private boolean f(Object x) {
       // (roughly)
       try {
           return x != null && !(boolean)x.getClass().getMethod("isEmpty").invoke(x);
       } catch (Exception e) {
           throw new IllegalArgumentException(); // Or whatever
       }
   }
   

Of those, overloading seems the cleanest approach to me, not least because it gives you a compile-time error if you try to use f on a type it can't handle (whereas the others are runtime errors, blech), but it's (at least slightly) a matter of opinion.

Answer 2

You want to refer to both the List and the Map polymorphically using a common ancestor interface which sadly doesn't exist. Since Java is strictly typed the compiler is looking for a method definition which matches this signature which can't be found.

You can't do it precisely in the way you have asked.

Take a look at how Apache commons solved this issues with this method using instanceof to cast to a relevant type org.apache.commons.collections.CollectionUtils#sizeIsEmpty

public static boolean sizeIsEmpty(Object object) {
    if (object instanceof Collection) {
        return ((Collection) object).isEmpty();
    } else if (object instanceof Map) {
        return ((Map) object).isEmpty();
    } else if (object instanceof Object[]) {
        return ((Object[]) object).length == 0;
    } else if (object instanceof Iterator) {
        return ((Iterator) object).hasNext() == false;
    } else if (object instanceof Enumeration) {
        return ((Enumeration) object).hasMoreElements() == false;
    } else if (object == null) {
        throw new IllegalArgumentException("Unsupported object type: null");
    } else {
        try {
            return Array.getLength(object) == 0;
        } catch (IllegalArgumentException ex) {
            throw new IllegalArgumentException("Unsupported object type: " + object.getClass().getName());
        }
    }
}

Answer 3

You can try as follow:

private Object boolean f(Object x) {
    if (x instanceof List) {
        List l = (List)x;
        return !l.isEmpty();
    } else if (x instanceof Map) {
        Map m = (Map)x;
        return !m.isEmpty();
    }
    return false;
}

Answer 4

You can't really, since isEmpty() is not inherited from a common interface. One workaround is to accept a predicate that determines emptiness:

private static <T> boolean isNonEmpty(T value, Predicate<T> isEmpty) {
    return value != null && !isEmpty.test(value);
}

Sample use:

isNonEmpty(Arrays.asList(1, 2, 3), List::isEmpty)
isNonEmpty(new HashMap<>(), Map::isEmpty)
isNonEmpty("foo", String::isEmpty)

Arguably this helper method is not all that helpful.

Answer 5

Since you have tagged java-8 , you can make you of Optional class.

private static boolean isEmpty(Optional<Collection> collection){
    return collection.map(Collection::isEmpty).orElse(false);
}

---

Some example:

public static void main(String[] args) {
    ArrayList arrayList = null;
    System.out.println(isEmpty(Optional.ofNullable(arrayList)));

    Map map = null;
    //Convert Map entries to entryset (Collection) via Optional::map
    System.out.println(isEmpty(Optional.ofNullable(map).map(Map::entrySet)));
}

Output:

false
false

Answer 6

I love point 3 in T.J.Crowder's answer, but I would use a slightly different approach (and a bit faster):

private static boolean f(Object x) {
    MethodType methodType = MethodType.methodType(boolean.class);
    Lookup l = MethodHandles.lookup();
    try {
        MethodHandle handle = l.findVirtual(x.getClass(), "isEmpty", methodType);
        return (boolean) handle.invoke(x);
    } catch (Throwable e) {
        throw new RuntimeException(e);
    }
}