如何判断列表是否是java8流的另一个子序列？

Question

For example, I have a long list [1, 2, 3, ..., 10] , and a short one [1, 3, 6] , then I can tell that the short one is the subsequence of another. On the other hand, the list [1 6 3] is not because it against the order constraint.

Below is my java7 style code for this question:

List<Integer> sequence = Arrays.asList(1, 3, 6);
List<Integer> global = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Iterator<Integer> iterGlobal = global.iterator();
boolean allMatch = true;
for(Integer itemSequence: sequence) {
    boolean match = false;
    while(iterGlobal.hasNext()) {
        if(itemSequence.equals(iterGlobal.next())) {
            match = true;
            break;
        }
    }
    if(!match) {
        allMatch = false;
        break;
    }
}
System.out.println(allMatch); //=> true

And my wish is to find a java8 stream style to achieve the same result.

Answer 1

Real functional solutions, ie not incorporating mutable state, are hard to find. This is best illustrated by the fact that all answer so far incorporate mutable state.

Further, there is no List.indexOf(T object, int startIndex) operation. To illustrate, how useful it would be, let define it via helper method:

public static int indexOf(List<?> list, int startIndex, Object o) {
    if(startIndex!=0) list=list.subList(startIndex, list.size());
    int ix=list.indexOf(o);
    return ix<0? -1: ix+startIndex;
}

^{It would be easy to find an alternative implementation without a temporary object, if that's a concern}

Now, a simple solution using mutable state would be:

boolean allMatch = sequence.stream().allMatch(new Predicate<Integer>() {
    int index = 0;
    public boolean test(Integer t) {
        return (index = indexOf(global, index, t)) >=0;
    }
});

A functional solution without mutable state requires a value type holding two positions within the two lists. When we use an int[2] array for that, the solution would be:

boolean allMatch = Stream.iterate(
        new int[]{ 0, global.indexOf(sequence.get(0)) },
        a -> new int[] { a[0]+1, indexOf(global, a[1], sequence.get(a[0]+1)) }
    )
    .limit(sequence.size())
    .allMatch(a -> a[1]>=0);

Answer 2

I am the questioner and I answer my question firstly just for mark:

List<Integer> sequence = Arrays.asList(1, 3, 6);
List<Integer> global = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

Iterator<Integer> iter = global.iterator();
boolean subSequence = sequence.stream().allMatch(itemSequence -> {
    return Stream.generate(iter::next)
            .anyMatch(itemGlobal -> itemSequence.equals(itemGlobal));
});
System.out.println(subSequence);

It work well for sequence list [1, 3, 6], while for sequence [1, 6, 3] throwing a error java.util.NoSuchElementException. This is not what I finally want to reach.

Answer 3

I think that you got really close to the solution (I did not even think about a Iterator like this, so a plus one to you). The problem is that Stream.generate is an infinite stream.

I've changed your code just a bit.

    Iterator<Integer> iter = global.iterator();

    boolean subSequence = sequence.stream().allMatch(itemSequence -> {
        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iter, Spliterator.ORDERED), false)
                .anyMatch(itemGlobal -> itemSequence.equals(itemGlobal));
    });
    System.out.println(subSequence);

Answer 4

A variant of @Eugene's variant of @Run's answer would involve calling Iterable::spliterator on the global List<> value, then apply the result to StreamSupport::stream:

final Spliterator<Integer> spliterator = global.spliterator();

final boolean subSequence = sequence.stream().allMatch(
  itemSequence -> StreamSupport.stream(
    spliterator,
    false
  ).anyMatch(itemSequence::equals)
);

System.out.println(subSequence);

Answer 5

I'll add another option after seeing Holger answer; but this will only work with jdk-9 Stream.iterate .

I've defined a helper method in the same way, a tiny bit different:

private static int fits(List<Integer> global, int elementIndex, int element) {
    return global.indexOf(element) >= elementIndex ? global.indexOf(element) : -1;
}

And then just use an int[2] :

boolean allMatch = Stream.iterate(new int[] { 0, 0 },
            array -> array[0] < sequence.size() && array[1] >= 0,
            array -> new int[] { array[0] + 1, fits(global, array[1], sequence.get(a[0])) })
            .allMatch(array -> array[0] >= array[1]);

EDIT Holger is right, this will only work for non-duplicates.

I can write it for duplicates also, but then is suffers from the point that fits needs to be called twice now.

 boolean allMatch = Stream.iterate(new int[] { 0, 0 },
            a -> {
                return a[0] == sequence.size() ? false : fits(global, sequence.get(a[0])) >= a[1];
            },
            a -> {
                int nextFits = fits(global, sequence.get(a[0]));
                return new int[] { a[0] + 1, nextFits > a[1] ? nextFits + 1 : -1 };
            })
            .count() == sequence.size();