Java 8 Collector that returns a value if there's only a single value

Question

I'm a little green on this functional programming and streams stuff, but what little I do know has been very useful!

I've had this situation come up several times:

List<SomeProperty> distinctProperties = someList.stream()
    .map(obj -> obj.getSomeProperty())
    .distinct()
    .collect(Collectors.toList());

if (distinctProperties.size() == 1) {
    SomeProperty commonProperty = distinctProperties.get(0);
    // take some action knowing that all share this common property
}

What I really want is:

Optional<SomeProperty> universalCommonProperty = someList.stream()
    .map(obj -> obj.getSomeProperty())
    .distinct()
    .collect(Collectors.singleOrEmpty());

I think the singleOrEmpty thing can be useful in other situations besides just in combination with distinct. When I was an uber n00b I spent a lot of time reinventing the Java Collections Framework because I didn't know it was there, so I'm trying not to repeat my mistakes. Does Java come with a good way to do this singleOrEmpty thing? Am I formulating it wrong?

Thanks!

EDIT: Here's some example data for the distinct case. If you ignore the map step:

Optional<SomeProperty> universalCommonProperty = someList.stream()
    .map(obj -> obj.getSomeProperty())
    .distinct()
    .collect(Collectors.singleOrEmpty());

[]     -> Optional.empty()
[1]    -> Optional.of(1)
[1, 1] -> Optional.of(1)
[2, 2] -> Optional.of(2)
[1, 2] -> Optional.empty()

I find I need this when I screw up my types, or have legacy code. It's really nice to be able to quickly say "All the elements of this collection share this property, so now I can take some action using this shared property." Another example is when a user multi-selects some diverse elements, and you're trying to see what stuff you can do (if anything) that's valid for all of them.

EDIT2: Sorry if my example is a misleading. The key is singleOrEmpty. I commonly find that I put a distinct in front, but it could just as easily be a filter of some other kind.

Optional<SomeProperty> loneSpecialItem = someList.stream()
    .filter(obj -> obj.isSpecial())
    .collect(Collectors.singleOrEmpty());

[special]           -> Optional.of(special)
[special, special]  -> Optional.empty()
[not]               -> Optional.empty()
[not, special]      -> Optional.of(special)
[not, special, not] -> Optional.of(special)

EDIT3: I think I screwed up by motivating the singleOrEmpty instead of just asking for it on its own.

Optional<Int> value = someList.stream().collect(Collectors.singleOrEmpty())
[]     -> Optional.empty()
[1]    -> Optional.of(1)
[1, 1] -> Optional.empty()

@Ned Twigg can you be kind and post up your somelist content so your issue can be reproduced? — Kick Buttowski, Nov 07 '14 at 21:44
It's worth mentioning that in C#'s LINQ this would be similar to `SingleOrDefault`. — Benjamin Gruenbaum, Nov 08 '14 at 12:48

Misha · Answer 1 · 2014-11-07T22:37:21.877

20

This will incur an overhead of creating a set but it's simple and will work correctly even if you forget to distinct() the stream first.

static<T> Collector<T,?,Optional<T>> singleOrEmpty() {
    return Collectors.collectingAndThen(
            Collectors.toSet(),
            set -> set.size() == 1 
                    ? set.stream().findAny() 
                    : Optional.empty()
    );
}

edited Nov 07 '14 at 22:37

answered Nov 07 '14 at 22:11

Misha

27,433
6
62
78

It is an elegant solution for the case that you're putting a distinct in front, but the root of my question is how to implement `singleOrEmpty`. – Ned Twigg Nov 07 '14 at 22:36
@NedTwigg I'm not sure I understand. This will pass all your unit tests. `Stream.of(1,2).collect(singleOrEmpty()) -> Optional.empty()` `Stream.of(1).collect(singleOrEmpty()) -> Optional.of(1)` etc – Misha Nov 07 '14 at 22:37
@NedTwigg it will do the distinct for you, because you collect all the stuff into a `Set`. – Thomas Jungblut Nov 07 '14 at 22:38
I did a bad job with my example, it emphasized the wrong part of my question. I don't want to always do `distinct`, sometimes I need other filters. – Ned Twigg Nov 07 '14 at 22:46
@NedTwigg That's fine. Let's say you want to get singleOrEmpty length of multiple strings. `Stream.of("one", "two").map(String::length).collect(singleOrEmpty()) -> Optional.of(3)` (all strings have length of 3) `Stream.of("one", "three").map(String::length).collect(singleOrEmpty()) -> Optional.empty()` because lengths are different – Misha Nov 07 '14 at 22:51
I think your Collector is an elegant solution to `singleDistinctOrEmpty()`. But it doesn't implement `singleOrEmpty()`. – Ned Twigg Nov 09 '14 at 01:52

Thomas Jungblut · Accepted Answer · 2014-11-07T23:14:37.103

13

"Hacky" solution that only evaluates the first two elements:

    .limit(2)
    .map(Optional::ofNullable)
    .reduce(Optional.empty(),
        (a, b) -> a.isPresent() ^ b.isPresent() ? b : Optional.empty());

Some basic explanation:

Single element [1] -> map to [Optional(1)] -> reduce does

"Empty XOR Present" yields Optional(1)

= Optional(1)

Two elements [1, 2] -> map to [Optional(1), Optional(2)] -> reduce does:

"Empty XOR Present" yields Optional(1)
"Optional(1) XOR Optional(2)" yields Optional.Empty

= Optional.Empty

Here is the complete testcase:

public static <T> Optional<T> singleOrEmpty(Stream<T> stream) {
    return stream.limit(2)
        .map(Optional::ofNullable)
        .reduce(Optional.empty(),
             (a, b) -> a.isPresent() ^ b.isPresent() ? b : Optional.empty());
}

@Test
public void test() {
    testCase(Optional.empty());
    testCase(Optional.of(1), 1);
    testCase(Optional.empty(), 1, 1);
    testCase(Optional.empty(), 1, 1, 1);
}

private void testCase(Optional<Integer> expected, Integer... values) {
    Assert.assertEquals(expected, singleOrEmpty(Arrays.stream(values)));
}

Kudos to Ned (the OP) who has contributed the XOR idea and the above testcase!

edited Nov 07 '14 at 23:14

answered Nov 07 '14 at 22:11

Thomas Jungblut

20,854
6
68
91

Is it possible to short-circuit terminate a stream rather than to collect a HashSet whose only valid contents will be a single element? – Ned Twigg Nov 07 '14 at 22:16
@NedTwigg this is certainly a question of your input, so I guess in the case you did a `#distinct` upfront? – Thomas Jungblut Nov 07 '14 at 22:18
2

@NedTwigg I was thinking about a `limit(2).reduce()` solution, but it seems like fitting it into reduce is wrong on every level. – Thomas Jungblut Nov 07 '14 at 22:30
I think limit(2) is a great idea! I'm gonna tinker from there... – Ned Twigg Nov 07 '14 at 22:37
I think you've got it actually! .limit(2).reduce(Optional.empty(), (a, b) -> (a.isPresent() ^ b.isPresent()) – Ned Twigg Nov 07 '14 at 22:41
Is that how reduce works? – Ned Twigg Nov 07 '14 at 22:41
You cracked it, it should be your answer. – Ned Twigg Nov 07 '14 at 22:41
@NedTwigg hmm wait, types seems to mismatch. – Thomas Jungblut Nov 07 '14 at 22:42
`.limit(2).map(Optional::ofNullable).reduce(XOR)` – Ned Twigg Nov 07 '14 at 22:44
@NedTwigg we are close, but still this `XOR` is not trivial to fit into the reduce ;D – Thomas Jungblut Nov 07 '14 at 22:49
2

@NedTwigg cracked it `.reduce(Optional.empty(), (a, b) -> a.isPresent() ^ b.isPresent() ? b : Optional.empty())` – Thomas Jungblut Nov 07 '14 at 22:53
1

Gorgeous! Mind removing the Collector implementation? It doesn't actually answer the question, and your "hacky" answer is much more elegant and performant! – Ned Twigg Nov 07 '14 at 23:04
@NedTwigg sure, I don't mind. Thanks :) – Thomas Jungblut Nov 07 '14 at 23:06
Is there a way to put this at the end of a call? Works great, but it's a teensy bit tricky to read that it comes at the beginning, when the terminal operation would normally come at the end. Very minor gripe, just seeing if you've got more tricks up your sleeve :) – Ned Twigg Nov 07 '14 at 23:21
@NedTwigg I think this is only possible when implementing a `Spliterator`, in C# it would be an easy extension method- quite sad that Java didn't add this in version 8. – Thomas Jungblut Nov 07 '14 at 23:23
@NedTwigg but maybe you should formulate this as a different question, maybe someone else has a great idea to make this happen. – Thomas Jungblut Nov 07 '14 at 23:29
http://stackoverflow.com/questions/26812096/java-8-spliterator-or-similar-that-returns-a-value-iff-theres-only-a-single-v – Ned Twigg Nov 08 '14 at 00:02

S.D. · Answer 3 · 2016-10-18T18:30:29.010

7

If you don't mind using Guava, you can wrap your code with Iterables.getOnlyElement, so it would look something like that:

SomeProperty distinctProperty = Iterables.getOnlyElement(
        someList.stream()
                .map(obj -> obj.getSomeProperty())
                .distinct()
                .collect(Collectors.toList()));

IllegalArgumentException will be raised if there is more than one value or no value, there is also a version with default value.

edited Oct 18 '16 at 18:30

answered Nov 07 '14 at 22:07

S.D.

111
3

The link is broken – Pikachu Oct 03 '16 at 22:02

score 6 · Answer 4 · answered Feb 04 '16 at 16:15

A more concise way to build a Collector for this is as follows:

Collectors.reducing((a, b) -> null);

The reducing collector will store the first value, and then on successive passes, pass the current running value and the new value into the lambda expression. At this point, null can always be returned since this will not be called with the first value, which will simply be stored.

Plugging this into the code:

Optional<SomeProperty> universalCommonProperty = someList.stream()
    .map(obj -> obj.getSomeProperty())
    .distinct()
    .collect(Collectors.reducing((a, b) -> null));

score 4 · Answer 5 · answered Nov 07 '14 at 22:10

You can easily write your own Collector

public class AllOrNothing<T> implements Collector<T, Set<T>, Optional<T>>{



@Override
public Supplier<Set<T>> supplier() {
    return () -> new HashSet<>();
}



@Override
public BinaryOperator<Set<T>> combiner() {
    return (set1, set2)-> {
        set1.addAll(set2);
        return set1;
    };
}

@Override
public Function<Set<T>, Optional<T>> finisher() {
    return (set) -> {
        if(set.size() ==1){
            return Optional.of(set.iterator().next());
        }
        return Optional.empty();
    };
}

@Override
public Set<java.util.stream.Collector.Characteristics> characteristics() {
    return Collections.emptySet();
}

@Override
public BiConsumer<Set<T>, T> accumulator() {
    return Set::add;
}

}

Which you can use like this:

   Optional<T> result = myStream.collect( new AllOrNothing<>());

Here's your example test data

public static void main(String[] args) {
    System.out.println(run());

    System.out.println(run(1));
    System.out.println(run(1,1));
    System.out.println(run(2,2));
    System.out.println(run(1,2));
}

private static Optional<Integer> run(Integer...ints){

    List<Integer> asList = Arrays.asList(ints);
    System.out.println(asList);
    return asList
                .stream()
                .collect(new AllOrNothing<>());
}

which when run will print out

[]
Optional.empty
[1]
Optional[1]
[1, 1]
Optional[1]
[2, 2]
Optional[2]

Is it possible to short-circuit terminate a stream rather than to collect a HashSet whose only valid contents will be a single element? — Ned Twigg, Nov 07 '14 at 22:16
@NedTwigg yes, but you would have to write your own `spliterator` which kept track of it. — dkatzel, Nov 07 '14 at 22:19

score 3 · Answer 6 · answered Nov 07 '14 at 22:12

It seems RxJava has similar functionality in its single() operator.

single( ) and singleOrDefault( )

if the Observable completes after emitting a single item, return that item, otherwise throw an exception (or return a default item)

I'd rather just have an Optional, and I'd rather it be a Collector.

score 2 · Answer 7 · answered Jan 24 '17 at 20:15

2

Guava has a collector for this called MoreCollectors.toOptional()

https://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/MoreCollectors.html#toOptional--

answered Jan 24 '17 at 20:15

Hans

2,230
23
23

weston · Answer 8 · 2017-01-03T23:10:30.003

Another collector approach:

Collectors:

public final class SingleCollector<T> extends SingleCollectorBase<T> {
    @Override
    public Function<Single<T>, T> finisher() {
        return a -> a.getItem();
    }
}

public final class SingleOrNullCollector<T> extends SingleCollectorBase<T> {
    @Override
    public Function<Single<T>, T> finisher() {
        return a -> a.getItemOrNull();
    }
}

SingleCollectorBase:

public abstract class SingleCollectorBase<T> implements Collector<T, Single<T>, T> {
    @Override
    public Supplier<Single<T>> supplier() {
        return () -> new Single<>();
    }

    @Override
    public BiConsumer<Single<T>, T> accumulator() {
        return (list, item) -> list.set(item);
    }

    @Override
    public BinaryOperator<Single<T>> combiner() {
        return (s1, s2) -> {
            s1.set(s2);
            return s1;
        };
    }

    @Override
    public Set<Characteristics> characteristics() {
        return EnumSet.of(Characteristics.UNORDERED);
    }
}

Single:

public final class Single<T> {

    private T item;
    private boolean set;

    public void set(T item) {
        if (set) throw new SingleException("More than one item in collection");
        this.item = item;
        set = true;
    }

    public T getItem() {
        if (!set) throw new SingleException("No item in collection");
        return item;
    }

    public void set(Single<T> other) {
        if (!other.set) return;
        set(other.item);
    }

    public T getItemOrNull() {
        return set ? item : null;
    }
}

public class SingleException extends RuntimeException {
    public SingleException(String message) {
        super(message);
    }
}

Tests and example usages, albeit lacking parallel tests.

public final class SingleTests {

    @Test
    public void collect_single() {
        ArrayList<String> list = new ArrayList<>();
        list.add("ABC");

        String collect = list.stream().collect(new SingleCollector<>());
        assertEquals("ABC", collect);
    }

    @Test(expected = SingleException.class)
    public void collect_multiple_entries() {
        ArrayList<String> list = new ArrayList<>();
        list.add("ABC");
        list.add("ABCD");

        list.stream().collect(new SingleCollector<>());
    }

    @Test(expected = SingleException.class)
    public void collect_no_entries() {
        ArrayList<String> list = new ArrayList<>();

        list.stream().collect(new SingleCollector<>());
    }

    @Test
    public void collect_single_or_null() {
        ArrayList<String> list = new ArrayList<>();
        list.add("ABC");

        String collect = list.stream().collect(new SingleOrNullCollector<>());
        assertEquals("ABC", collect);
    }

    @Test(expected = SingleException.class)
    public void collect_multiple_entries_or_null() {
        ArrayList<String> list = new ArrayList<>();
        list.add("ABC");
        list.add("ABCD");

        list.stream().collect(new SingleOrNullCollector<>());
    }

    @Test
    public void collect_no_entries_or_null() {
        ArrayList<String> list = new ArrayList<>();

        assertNull(list.stream().collect(new SingleOrNullCollector<>()));
    }

}

Java 8 Collector that returns a value if there's only a single value

8 Answers8

Linked