Cómo aunque el acceso al elemento anterior de una corriente ordenada java 8?

BetaRide:

En un flujo ordenado, me gustaría tener acceso al elemento anterior.

Estoy buscando algo como esto:

class Main {
  public static void main(String[] args) {
    List<String> stringList = Arrays.asList("1: First", "2: Second", "3: Third", "4: Fourth");

    List<String> resultList = stringList.stream()
      .sorted()
      .filter(s -> s.contains("Second") && s.previous().contains("First"))
                                           ^^^^^^^^^^^^ doesn't compile
      .collect(Collectors.toList());

    System.out.println(resultList);
  }
}

Resultados esperados en este caso es

Second

Importante: Me gustaría factor de la lambda en el filter()método para reutilizarla en diferentes lugares.

yelliver:

Puede guardar la prev cada paso:

class Main {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("1: First", "2: Second", "3: Third", "4: Fourth");
        List<String> resultList = stringList.stream()
                .sorted()
                .filter(new Predicate<String>() {
                    private String prev = null;

                    @Override
                    public boolean test(String s) {
                        boolean result = s.contains("Second") && prev != null && prev.contains("First");
                        prev = s;
                        return result;
                    }
                })
                .collect(Collectors.toList());
        System.out.println(resultList);
    }
}

Y se puede definir a medida separada clase de predicados de reutilización:

class Main {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("1: First", "2: Second", "3: Third", "4: Fourth");
        List<String> resultList = stringList.stream()
                .sorted()
                .filter(new WithPrevPredicate() {
                    @Override
                    public boolean test(String prev, String current) {
                        return current.contains("Second") && prev != null && prev.contains("First");
                    }
                })
                .collect(Collectors.toList());
        System.out.println(resultList);
    }

    private static abstract class WithPrevPredicate<T> implements Predicate<T> {
        private T prev = null;

        @Override
        public boolean test(T current) {
            boolean test = test(prev, current);
            prev = current;
            return test;
        }

        public abstract boolean test(T prev, T current);
    }
}