Gli equivalenti di Java di Func e Action

Quali sono gli equivalenti Java di Func e Action ?

Voglio dire, invece di scrivere questo da solo:

public interface Func<TInput, TResult>
{
    TResult call(TInput target) throws Exception;
}
public interface Action<T>
{
    void call(T target) throws Exception;
}

In Java 8, gli equivalenti sono rispettivamente le interfacce java.util.function.Function<T, R>e java.util.function.Consumer<T>. Allo stesso modo, java.util.function.Predicate<T>è equivalente a System.Predicate<T>. Come accennato altrove, si tratta di interfacce anziché di delegati.

Correlati a parte: attualmente mi sto appoggiando pesantemente alla seguente classe di utilità per fare cose sul metodo di estensione simile a LINQ:

abstract class IterableUtil {
  public static <T> Iterable<T> where(Iterable<T> items, Predicate<T> predicate) {
    ArrayList<T> result = new ArrayList<T>();
    for (T item : items) {
      if (predicate.test(item)) {
        result.add(item);
      }
    }
    return result;
  }

  public static <T, R> Iterable<R> select(Iterable<T> items, Function<T, R> func) {
    ArrayList<R> result = new ArrayList<R>();
    for (T item : items) {
      result.add(func.apply(item));
    }
    return result;
  }
}

A differenza System.Linq.Enumerable.Where<TSource>e System.Linq.Enumerable.Select<TSource, TResult>il LINQ come i metodi che presento qui non sono pigro e percorro pienamente le collezioni di origine prima di tornare alle collezioni di risultato al chiamante. Tuttavia, li trovo utili per scopi puramente sintattici e potrebbero essere resi pigri se necessario. Dato

class Widget {
  public String name() { /* ... */ }
}

Si può fare quanto segue:

List<Widget> widgets = /* ... */;
Iterable<Widget> filteredWidgets = IterableUtil.where(widgets, w -> w.name().startsWith("some-prefix"));

Quale preferisco al seguente:

List<Widget> widgets = /* ... */;
List<Widget> filteredWidgets = new ArrayList<Widget>();
for (Widget w : widgets) {
  if (w.name().startsWith("some-prefix")) {
    filteredWidgets.add(w);
  }
}

L' interfaccia richiamabile è simile a Func.

L' interfaccia eseguibile è simile ad Action.

In generale, Java utilizza classi interne anonime in sostituzione dei delegati C #. Ad esempio, questo è il modo in cui aggiungi il codice per reagire alla pressione del pulsante nella GUI:

button.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) { 
          ...//code that reacts to the action... 
      }
});

L'eleganza dei delegati Func overload (oltre il delegato vs questione di classe anonima) è che essi supportano da 0 a 16 argomenti ( Func<TResult>, Func<T, TResult>, Func<T1, T2, TResult>, etc.)

Sfortunatamente, questo è impossibile in Java a causa della cancellazione del tipo. Le classi non possono differire solo per parametri di tipo generico.

Java 8 ora porta in uno zoo di nomi come BiConsumerper Action<T, T2>e, perché Java non permette argomenti di tipo primitivo, BiIntConsumer. Lo "zoo", però, non è molto grande, e non sono a conoscenza di una biblioteca che lo amplia. C'era una meravigliosa proposta per i letterali di tipo funzione come (int, int) => voidma non è stata adottata.

Per l' Func<T>uso: java.util.function.Supplier http://docs.oracle.com/javase/8/docs/api/java/util/function/Supplier.html

Non ci sono davvero equivalenti per quelli. È possibile creare classi interne anonime in Java, ma tendono ad esserci interfacce specifiche piuttosto che quelle generiche come Func e Action.

Java non ha il concetto di delegati. Per un approccio alternativo, vedere un programmatore Java esamina i delegati C # :

Sebbene C # abbia una serie di funzionalità simili a Java, ha aggiunto diverse nuove e interessanti funzionalità. La delega è la capacità di trattare un metodo come un oggetto di prima classe. Il delegato AC # viene utilizzato quando gli sviluppatori Java utilizzano un'interfaccia con un unico metodo. In questo articolo viene discusso l'uso dei delegati in C # e viene presentato il codice per un oggetto Java Delegate che può eseguire una funzione simile. Scarica il codice sorgente qui.

Puoi usare java.util.Function in questo modo

Function<Employee, String> f0 = (e) -> e.toString();

Ma se devi usarlo con più di un argomento (come fa C # Func), allora devi definire la tua versione di FunctionalInterface come segue

@FunctionalInterface
public interface Func2Args<T, T1, R> {
    R apply(T t, T1 t1);
}

@FunctionalInterface
public interface Func3Args<T,T1,T2,R> {
    R apply(T t, T1 t1, T2 t2);
}

Quindi puoi usare con la variabile no di argomenti

Func2Args<Employee,Employee,String> f2 = (e, e2) -> e.toString() + 
e2.toString();

Func3Args<Employee,Employee,Employee,String> f3 = (e, e2, e3) -> 
e.toString() + e2.toString() + e3.toString();

Per versioni precedenti rispetto a Java 8

Per i callback dei metodi in C # che ho usato in questo modo:

public void MyMethod(string par1, string par2, Action<int> callback, Action<int, string> callback2)
{
    //Async Code 
        callback.invoke(1);
        callback2.invoke(4, "str");
}

e chiamandolo:

utils.MyMethod("par1", "par2", (i) =>
{
    //cb result
}, (i, str) =>
{
    //cb2 result
});

Ho creato piccole classi astratte in Java

package com.example.app.callbacks;
public abstract class Callback1<T> {
    public void invoke(T obj) {}
}

package com.example.app.callbacks;
public abstract class Callback2<T, T2> {
    public void invoke(T obj, T2 obj2) {}
}

package com.example.app.callbacks;
public abstract class Callback3<T, T2, T3> {
    public void invoke(T obj, T2 obj2, T3 obj3) {}
}

...ETC

Il metodo Java ha il seguente aspetto:

public void myMethod(String par1, String par2, final Callback1<int> callback, final Callback2<int, String> callback2) {
    //Async Code 
        callback.invoke(1);
        callback2.invoke(4, "str");
}

Ora, quando lo chiami in Java:

utils.myMethod("par1", "par2", new Callback<int>() {
    @Override
    public void invoke(int obj) {
        super.invoke(obj);
        //cb result
    }
}, new Callback2<int, String>() {
    @Override
    public void invoke(int obj, String obj2) {
        super.invoke(obj, obj2);
        //cb2 result
    }
});

Funziona anche passando / impostando i tuoi callback alle classi in cui vuoi chiamarli, lo stesso metodo può essere utilizzato anche per creare Interfacce:

package com.example.app.interfaces;
public interface MyInterface<T> {
    void makeDo(T obj);
    void makeAnotherDo();
}