使用流检查Java中列表是否仅具有特定元素排列

Question

I am trying to come up a solution using streams to solve this problem and I looked up if someone has came across this but couldn't find this. So I have a list of three elements, let call it list1 and another list say list2 which can have different elements and can also contain duplicate items from list1.

What I want to achieve :-

1. Check if the list2 has any element which isn't in list1.
2. Check if list2 has only 2 item from list1 at a time.

For 2 - I could use set, convert list2 to set and see if list1 containsAll the set.

But I wanted to know if I can use stream here!

Eg

list1 (1,2,3) and list2 (1,1,2,2) - returns true

list1 (1,2,3) and list2 (1,1,3,3) - returns true

list1 (1,2,3) and list2 (1,1,2,2,4) -return false

I hope this makes it little clear

Answer 1

  public static <T> boolean func(List<T> list1, List<T> list2) {
    return list2.stream()
        .distinct()
        .map(list1::contains)
        .reduce(0,
            (result, current) -> result < 0 ? -1 : (current ? result + 1 : -1),
            (a, b) -> a < 0 || b < 0 ? -1 : a + b) == 2;
  }

But suggest you don't use stream for such complex logic.

Answer 2

Streams are probably not the most efficient way to tackle this problem. Nonetheless, here is another approach that has the advantage of short-circuting as soon as we find the third element contained or the first element not contained in list1 :

public static <T> boolean func(List<T> list1, List<T> list2)
{
    AtomicLong count = new AtomicLong(0);
    return list2.stream()
                .distinct()
                .allMatch(element -> list1.contains(element) &&
                                     count.incrementAndGet() < 3)
           && count.get() == 2;
}

We have to "cheat" a bit, though: In order to not go through the complete stream, we have to limit the elements with the help of a counter.

The check && count.get() == 2 makes sure that you have exactly 2 elements that are contained in list1 . If 0 or 1 element are also acceptable, remove that check.

Answer 3

How about:

return Optional.of(list2)
        .filter(list -> list.stream().allMatch(list1::contains))
        .map(list -> list.stream().distinct().map(list1::contains))
        .map(stream -> stream.mapToInt(x -> x ? 1 : 0))
        .map(IntStream::sum)
        .filter(sum -> sum == 2)
        .isPresent();

Unfortunately, you're essentially performing the same stream operation twice. Alternatively, to avoid this, collect the stream and reconvert it:

List<Boolean> containedInFirst = list2.stream()
        .distinct()
        .map(list1::contains)
        .collect(Collectors.toList());
return Optional.of(containedInFirst)
        .filter(list -> list.stream().allMatch(x -> x))
        .map(list -> list.stream().mapToInt(x -> x ? 1 :0))
        .map(IntStream::sum)
        .map(sum -> sum == 2)
        .filter(sum -> sum == 2)
        .isPresent();

You're essentially creating two tracks with the optional: the one which matches your requirements and those that don't. Any time you find something that doesn't match up, you throw it out with a filter. Anything that is still in the pipeline by the isPresent matches your criteria.