una - tipos de datos en java ejemplos

Guarda un método en una variable, java 8

Question

¿Es posible guardar un método en una variable?
Tengo una clase que se llama MyFilter y filtra elementos en diferentes campos.
El constructor de MyFilter debería preguntar 2 cosas:

1. Cadena, por ejemplo, filtrar elementos por idioma, "inglés"
2. Esto debería ser un método.

por ejemplo:

Tengo un artículo y quiero verificar si el idioma == Cadena que se asignó al filtro
Así que necesito obtener el idioma de ese artículo, por lo que Item.getLanguage () ...
También lo necesito para Item.getTitle (), Item.getId () y así sucesivamente.

Creo que esto es posible con lambda, pero no sé cómo.

Answer 1

Puedes usar las referencias del método Java 8. Puede utilizar el :: ''operador'' para tomar una referencia de método de un objeto.

import java.util.function.IntConsumer;

class Test {
    private int i;
    public Test() { this.i = 0; }
    public void inc(int x) { this.i += x; }
    public int get() { return this.i; }

    public static void main(String[] args) {
        Test t = new Test();
        IntConsumer c = t::inc;
        c.accept(3);
        System.out.println(t.get());
        // prints 3
    }
}

Solo necesita un @FunctionalInterface que coincida con la firma del método que desea almacenar. java.util.function contiene una selección de los más utilizados.

Answer 2

Puedes usar referencia de método como -

System.out::println  

Que es equivalente a la expresión lambda -

x -> System.out.println(x).  

Además, puede utilizar el método de reflexión para almacenar y también funcionará para la versión anterior de java .

Answer 3

Sí, puedes tener una referencia variable a cualquier método. Para métodos simples generalmente es suficiente usar java.util.function. clases Para los métodos complejos, debe definir su @FunctionalInterface con este método. Aquí está trabajando ejemplo:

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class Main {

    public static void main(String[] args) {
        final Consumer<Integer> simpleReference = Main::someMethod;
        simpleReference.accept(1);
        simpleReference.accept(2);
        simpleReference.accept(3);

        final ComplexInterface complexReference = Main::complexMethod;
        final String complexResult = complexReference.someMethod("888", 321, new ArrayList<>());
        System.out.println(complexResult);
    }

    private static void someMethod(int value) {
        System.out.println(value);
    }

    private static String complexMethod(String stringValue, int intValue, List<Long> longList) {
        final StringBuilder builder = new StringBuilder();
        builder.append(stringValue).append(" : ").append(intValue);
        for (Long longValue : longList) {
            builder.append(longValue);
        }
        return builder.toString();
    }

    @FunctionalInterface
    public static interface ComplexInterface{
        String someMethod(String stringValue, int intValue, List<Long> longList);
    }
}