Make function generic for List and boolean[]

Question

I have two functions which check if all elements of an array or list are true. I'm having trouble combining the two. How can I make the functions into one generic Java function.

public static boolean allTrue(boolean[] booleans) {
    if (booleans == null) {
        return false;
    }

    for (boolean bool : booleans) {
        if (!bool) {
            return false;
        }
    }
    return true;
}

public static boolean allTrue(List<Boolean> booleans) {
    if (booleans == null) {
        return false;
    }

    for (boolean bool : booleans) {
        if (!bool) {
            return false;
        }
    }
    return true;
}

@shmosel No Java 8 as well, only backported Java 8 lambda expressions with Retrolambda — Kwoppy, Feb 10 '17 at 02:57
I think @shmosel's answer is pretty good, you can take a look at the `Booleans` class and replicate the `asList` method. — xiaofeng.li, Feb 10 '17 at 02:59
Without a third-party library, what you have is as good as it gets. (Though it's generally best policy to throw on `null` instead of trying to return an answer.) — Louis Wasserman, Feb 10 '17 at 03:11
And if you're treating `null` as an empty array, it should return `true` instead. — shmosel, Feb 10 '17 at 03:16

score 4 · Accepted Answer · answered Feb 10 '17 at 02:44

4

If you're using Guava, you can wrap the boolean array in Booleans.asList() and pass it as a list:

public static boolean allTrue(boolean[] booleans) {
    return booleans != null && allTrue(Booleans.asList(booleans));
}

answered Feb 10 '17 at 02:44

shmosel

49,289
6
73
138

Under the hood, this probably is not more efficient than the answer I gave. – Tim Biegeleisen Feb 10 '17 at 02:49
I don't see any indication OP was concerned about efficiency. – shmosel Feb 10 '17 at 02:49
Both answers are less efficient than the code posted in the question. – Winter Feb 10 '17 at 02:49
@Winter There is no requirement for efficiency improvement – Scary Wombat Feb 10 '17 at 02:50
Under the hood, it's returning a special wrapper around the boolean array: `BooleanArrayAsList`, no allocation and no copying of array elements. – xiaofeng.li Feb 10 '17 at 02:51
@ScaryWombat There's no requirement for efficiency decrement either. It's not even generic, just a different overload so it's not getting any closer to what OP asks anyway. – Winter Feb 10 '17 at 02:52
1

@Winter I'm pretty sure OP didn't mean generic in the technical sense. He just wants to unify the logic. – shmosel Feb 10 '17 at 02:54
@shmosel I'm pretty sure he mean "generic" (as stated in question) and need an explanation on why it's not possible to do it in only one generic function. – Winter Feb 10 '17 at 02:56
We'll have to agree to disagree. – shmosel Feb 10 '17 at 02:57

score 2 · Answer 2 · edited May 23 '17 at 12:17

2

As per https://stackoverflow.com/a/5606435/2310289

You could just accept an Object

public static boolean allTrue(Object booleans) {

and then check for instanceof boolean[] or instanceof List<Boolean> and then perform different code within the method.

Again, not really an improvement, but a bit closer to code unification

edited May 23 '17 at 12:17

Community

1
1

answered Feb 10 '17 at 02:53

Scary Wombat

44,617
6
35
64

score 1 · Answer 3 · answered Feb 10 '17 at 02:47

I think the answer given by @Joel was a good one, except for the issue pointed out in the comment. If we just convert boolean[] to Boolean[], we can try the following:

public static boolean allTrue(List<Boolean> booleans) {
    if (booleans == null) {
        return false;
    }

    for (boolean bool : booleans) {
        if (!bool) {
            return false;
        }
    }
    return true;
}

public static boolean allTrue(boolean[] booleans) {
    Boolean[] newArray = new Boolean[booleans.length];
    int i = 0;
    for (boolean value : booleans) {
        newArray[i++] = Boolean.valueOf(value);
    }

    return Arrays.asList(newArray);
}

How is that not an improvement? The logic of `allTrue` now only needs to be changed in one location if necessary. — Joel Christophel, Feb 10 '17 at 03:56

score 1 · Answer 4 · answered Feb 10 '17 at 03:14

The common ancestor for List<Boolean> and boolean[] is Object, so unless you are okay with allTrue(Object booleans), you cannot do it with one method.

If you change your method signature to allTrue(Iterable<Boolean> booleans), all you have to do is create a special Iterator<Boolean> to traverse the boolean array.

import java.util.Iterator;
import java.util.NoSuchElementException;

public class BooleanAllTrue {
    public static boolean allTrue(Iterable<Boolean> booleans) {
        if (booleans == null) return false;

        for (Boolean bool : booleans) {
            if (!bool) return false;
        }

        return true;
    }

    public static Iterable<Boolean> asIterable(final boolean[] booleens) {
        return new Iterable<Boolean>() {
            public Iterator<Boolean> iterator() {
                final boolean[] booleans = booleens;
                return new Iterator<Boolean>() {
                    private int i = 0;

                    public boolean hasNext() {
                        return i < booleans.length;
                    }

                    public Boolean next() {
                        if (!hasNext()) throw new NoSuchElementException();
                        return booleans[i++];
                    }

                    public void remove() {throw new UnsupportedOperationException("remove");}
                };
            }
        };
    }

    public static void main(String [] args) {
        System.out.println(allTrue(asIterable(new boolean[]{true, true})));
        System.out.println(allTrue(asIterable(new boolean[]{true, false})));
        try {
            asIterable(new boolean[0]).iterator().next();
        } catch (NoSuchElementException e) {
            // expected
        }
    }
}

And finally the allTrue(boolean[] booleans) method.

public static boolean allTrue(boolean[] booleans) {
    return allTrue(asIterable(booleans));
}

*The common ancestor for `List` and `boolean[]` is `Object`*. If you're counting interfaces, they both implement `Serializable`. Not that that's relevant to your point. — shmosel, Feb 10 '17 at 03:22

Make function generic for List and boolean[]

4 Answers4