Uguaglianza di istanza dell'interfaccia funzionale in java

Question

Non sono sicuro di come sia possibile garantire l'uguaglianza/immutabilità dell'interfaccia funzionale. Immagino che non ci sia modo di assicurare l'uguaglianza quando uso questo zucchero sintattico in java 8, per favore fammi sapere qualsiasi suggerimento se ne hai.

Ho creato un breve snippet di codice per la mia domanda.

public interface Element { 
    void doSomething(int a); 
} 

e ho cercato di aggiungere un'istanza di questa interfaccia in modo funzionale

public class FunctionSet { 

    public void doubleUp(int a) { 
     System.out.println(a*2); 
    } 

    public void square(int a) { 
     System.out.println(a*a); 
    } 

    public static void main(String[] args) { 
     HashSet<Element> set = new HashSet<>(); 
     FunctionSet functionSet = new FunctionSet(); 

     set.add(functionSet::doubleUp); 
     set.add(functionSet::square); 

     System.out.println(set.add(functionSet::doubleUp)); 
    } 

} 

la stampa vera che significa che non ci fosse alcun controllo di uguaglianza e anche io non può rimuovere qualsiasi istanza da Set una volta che lo aggiungo.

nel caso in cui utilizzo l'interfaccia funzionale come argomento, esiste un modo per confrontare in qualche modo tali istanze?

apprezzeranno qualsiasi aiuto, grazie in anticipo!

Answer 1

È possibile memorizzare il vostro riferimento metodo in una variabile:

public static void main(String[] args) { 
    HashSet<Element> set = new HashSet<>(); 
    FunctionSet functionSet = new FunctionSet(); 

    Element fn = functionSet::doubleUp; 
    set.add(fn); 
    set.add(functionSet::square); 

    System.out.println(set.add(fn)); 
} 

In questo modo restituisce false.

Quando si crea lo stesso labmda o metodo di riferimento in diversi punti del codice, è più o meno lo stesso che è necessario creare una nuova classe anonima in entrambe le posizioni:

public static void main(String[] args) { 
    HashSet<Element> set = new HashSet<>(); 
    FunctionSet functionSet = new FunctionSet(); 

    set.add(new Element() { 
     @Override 
     public void doSomething(int a) { 
      functionSet.doubleUp(a); 
     } 
    }); 
    set.add(new Element() { 
     @Override 
     public void doSomething(int a) { 
      functionSet.square(a); 
     } 
    }); 

    System.out.println(set.add(new Element() { 
     @Override 
     public void doSomething(int a) { 
      functionSet.doubleUp(a); 
     } 
    })); 
} 

Così ogni volta che si tratta di un oggetto diverso, anche se potrebbe sembrare lo stesso. Per ogni riferimento metodo incontrato classe anonima viene creata in fase di esecuzione:

Element e1 = functionSet::doubleUp; 
Element e2 = functionSet::doubleUp; 

System.out.println(e1.getClass()); 
System.out.println(e2.getClass()); 

L'output sarà simile a questo:

class FunctionSet$$Lambda$1/918221580 
class FunctionSet$$Lambda$2/1554547125 

Quindi in pratica si tratta di due oggetti distinti di due classi distinte. Sarebbe abbastanza difficile concludere che facciano la stessa cosa senza paragonare il loro bytecode. Si noti inoltre che entrambi catturano la variabile functionSet, pertanto è necessario assicurarsi che non sia stata modificata tra due riferimenti al metodo.

L'unica soluzione che posso pensare a è quello di dichiarare tutti i riferimenti di metodo come costanti nel codice e poi li di riferimento invece di utilizzare direttamente il metodo riferimenti:

public static final Element FN_DOUBLE_UP = new FunctionSet()::doubleUp; 
public static final Element FN_SQUARE = new FunctionSet()::square; 

public static void main(String[] args) { 
    HashSet<Element> set = new HashSet<>(); 

    set.add(FN_DOUBLE_UP); 
    set.add(FN_SQUARE); 

    System.out.println(set.add(FN_DOUBLE_UP)); 
}