filtro de estado para flujo ordenado

user3046582:

Tengo un problema y me pregunto si hay una solución utilizando corrientes.

Imagine que tiene una ordenada secuencia de objetos; Asumamos una corriente de números enteros.

 Stream<Integer> stream = Stream.of(2,20,18,17,4,11,13,6,3,19,4,10,13....)

Ahora quiero filtrar todos los valores en que la diferencia de un valor y el número anterior antes de que este valor es mayor que n .

stream.filter(magicalVoodoo(5))
// 2, 20, 4, 11, 3, 19, 4, 10 ...

I Hay alguna posibilidad de hacer esto?

Marcos Rotteveel:

Sí, esto es posible, pero se necesita un predicado de estado que realiza un seguimiento del valor anterior para hacer la comparación. Esto significa que sólo se puede utilizar para los flujos secuenciales: con corrientes paralelas se había encontrado con condiciones de carrera.

Afortunadamente, la mayoría de flujos predeterminado a secuencial, pero si lo que necesita hacer esto en las corrientes de origen desconocido, es posible que desee comprobar el uso isParallel()y, o bien una excepción, o convertirla en una corriente secuencial usando sequential().

Un ejemplo:

public class DistanceFilter implements IntPredicate {

    private final int distance;
    private int previousValue;

    public DistanceFilter(int distance) {
        this(distance, 0);
    }

    public DistanceFilter(int distance, int startValue) {
        this.distance = distance;
        this.previousValue = startValue;
    }

    @Override
    public boolean test(int value) {
        if (Math.abs(previousValue - value) > distance) {
            previousValue = value;
            return true;
        }
        return false;
    }

    // Just for simple demonstration
    public static void main(String[] args) {
        int[] ints = IntStream.of(2, 20, 18, 17, 4, 11, 13, 6, 3, 19, 4, 10, 13)
                .filter(new DistanceFilter(5))
                .toArray();

        System.out.println(Arrays.toString(ints));
    }
}

He utilizado IntStreamaquí, ya que es un mejor tipo para esto, pero el concepto sería similar a Stream<Integer>(u otros tipos de objetos).