streams - ¿Equivalente a los métodos anónimos de C#en Java?

streams lambda java

Question

En C # puede definir delegados de forma anónima (aunque no son más que azúcar sintáctica). Por ejemplo, puedo hacer esto:

public string DoSomething(Func<string, string> someDelegate)
{
     // Do something involving someDelegate(string s)
} 

DoSomething(delegate(string s){ return s += "asd"; });
DoSomething(delegate(string s){ return s.Reverse(); });

¿Es posible pasar código como este en Java? Estoy usando el marco de procesamiento, que tiene una versión bastante antigua de Java (no tiene genéricos).

Answer 1

¿Es posible pasar código como este en Java? Estoy usando el marco de procesamiento, que tiene una versión bastante antigua de Java (no tiene genéricos).

Dado que la pregunta formulada sobre la respuesta específica del Procesamiento, no hay un equivalente directo. Pero Processing utiliza el nivel de lenguaje Java 1.4, y Java 1.1 introdujo clases internas anónimas, que son una aproximación aproximada.

Answer 2

No exactamente así, pero Java tiene algo similar.

Se llama clases internas anónimas.

Dejame darte un ejemplo:

DoSomething(new Runnable() {
   public void run() {
       // "delegate" body
   }
});

Es un poco más detallado y requiere una interfaz para implementar, pero aparte de eso, es prácticamente lo mismo

Answer 3

Por ejemplo :

public class Delegate
{
    interface Func
    {
        void execute(String s);
    }

    public static void doSomething(Func someDelegate) {
        someDelegate.execute("123");
    }

    public static void main(String [] args)
    {

        Func someFuncImplementation = new Func() 
        {
            @Override
            public void execute(String s) {
                System.out.println("Bla Bla :"  + s);
            }
        };

        Func someOtherFuncImplementation = new Func() 
        {
            @Override
            public void execute(String s) {
                System.out.println("Foo Bar:"  + s);
            }
        };


        doSomething(someFuncImplementation);
        doSomething(someOtherFuncImplementation);
    }
}

Salida:

Bla Bla: 123

Foo Bar: 123

Answer 4

Su ejemplo se vería así en Java, usando clases internas anómimas:

interface Func {
    String execute(String s);
}

public String doSomething(Func someDelegate) {
    // Do something involving someDelegate.execute(String s)
}

doSomething(new Func() { public String execute(String s) { return s + "asd"; } });
doSomething(new Func() { public String execute(String s) { return new StringBuilder(s).reverse().toString(); } } });

Answer 5

Todos ustedes han olvidado aquí que un delegado de C #, en primer lugar, es seguro para subprocesos . Estos ejemplos son solo para una aplicación de un solo hilo.

La mayoría de las aplicaciones contemporáneas están escritas en un concepto multiproceso. Así que ninguna respuesta es la respuesta.

No hay un equivalente en Java

Answer 6

Pre Java 8:

Lo más cercano de Java a los delegados son las interfaces de un solo método. Podrías usar una clase interna anónima.

interface StringFunc {
   String func(String s);
}

void doSomething(StringFunc funk) {
   System.out.println(funk.func("whatever"));
}

doSomething(new StringFunc() {
      public String func(String s) {
           return s + "asd";
      }
   });


doSomething(new StringFunc() {
      public String func(String s) {
           return new StringBuffer(s).reverse().toString();
      }
   });

Java 8 y superior:

Java 8 agrega expresiones lambda al lenguaje.

    doSomething((t) -> t + "asd");
    doSomething((t) -> new StringBuilder(t).reverse().toString());