Profundo comparar cada elemento de una matriz

novato:

Tengo los 3 archivos siguientes,

A.java:

class A {

    private float b;    

    public A(float b) {
        this.b = b;
    }

    public float getB() {
        return b;
    }

    public String toString() {
        return "A(b = " + b + ")";    
    }

}

C.java:

import java.util.Arrays;

class C {

    private A[] d;
    private int i = 0;

    public C() {
        d = new A[5];
    }

    public void addB(A b) {
        d[i++] = b;
    }

    public String toString() {
        return "C(b = " + Arrays.toString(d) + ")";    
    }

    public void duplicate() {
        A temp[] = Arrays.copyOf(d, d.length);
        for (int cur = 0; cur < d.length; cur++) {
            if (d[cur] == null) continue;
            float currB = d[cur].getB();
            for (int nxt = cur + 1; nxt < d.length; nxt++) {
                if(d[nxt] == null) continue;
                if(currB == d[nxt].getB()) {
                    temp[i++] = new A(currB * 0.5f);
                }
            }
        }
        d = temp;
    }
}

D.java:

class D {

    public static void main(String[] args) {
        C c = new C();
        c.addB(new A(3));
        c.addB(new A(5));
        c.addB(new A(3));
        System.out.println(c.toString()); // C(b = [A(b = 3.0), A(b = 5.0), A(b = 3.0), null, null])
        c.duplicate();
        System.out.println(c.toString()); // C(b = [A(b = 3.0), A(b = 5.0), A(b = 3.0), A(b = 1.5), null])

    }

}

Esto hace lo que yo esperaba que hiciera, que es añadir otro elemento a la matriz con el medio bsi dos de los elementos tienen el mismo flotador de regresar de A.getB(). Sin embargo, yo estaba tratando de poner en práctica este uso de la imaginación de Java 8 Métodos de flujo y lambda funciones, así:

Arrays.stream(d).anyMatch(cur -> {
    if (cur == null) return false;
    Arrays.stream(d).anyMatch(nxt -> {
        if (nxt == null) return false;
        System.out.println("Checking " + cur.getB() + " with " + nxt.getB());
        return false;
    });
    return false;
});

Y esto da salida:

Checking 3.0 with 3.0 Checking 3.0 with 5.0 Checking 3.0 with 3.0 Checking 5.0 with 3.0 Checking 5.0 with 5.0 Checking 5.0 with 3.0 Checking 3.0 with 3.0 Checking 3.0 with 5.0 Checking 3.0 with 3.0

Como se puede ver esto sigue la O (N ²) algoritmo que no es lo que voy a dar. En mi código original que estaba "saltando" elementos que ya he comprobado mediante el uso de los índices de la externa anidada para el bucle. Así que mi pregunta es, si hay una manera de poner en práctica alguna manera esta anidado en el <Stream>.anyMatch(...)que he tratado. ¿O hay una forma más limpia de hacer esto?

Ousmane D .:

Puede replicar el duplicatemétodo que utiliza la API de corriente de la siguiente manera:

Stream<A> result = 
       IntStream.range(0, d.length)
                .filter(cur -> d[cur] != null)
                .flatMap(cur -> IntStream.range(cur + 1, d.length)
                        .filter(nxt -> d[nxt] != null)
                        .filter(nxt -> d[cur].getB() == d[nxt].getB())
                        .map(i -> cur))
                .mapToObj(cur -> new A(d[cur].getB() * 0.5f));

d = Stream.concat(Arrays.stream(d), result)
          .toArray(A[]::new);