Enquête sur la fonction Java 8, consommateur, fournisseur, prédicat

Motivation

En Java8, il y a lambda, Stream, classes supplémentaires, etc., mais je pense que la fonction, le consommateur, le fournisseur, le prédicat, etc. sont la base, donc je le comprends bien.

Function

Comment utiliser

Un mécanisme pour gérer le comportement des méthodes en Java avec des instances. La définition de méthode qui était classiquement faite comme suit,

MethodDefinition

R functionName(T arg) {
    return new R();
}

Il peut être remplacé par une définition d'instance sous la forme suivante.

ConventionalDefinition

Function<T, R> functionalInstance = new Function<T, R>() {
    @Override
    public R apply(T arg) {
        return new R();
    }
};

Ceci est gênant, vous pouvez donc utiliser l'expression lambda pour effectuer les opérations suivantes.

InstanceDefinition

Function<T, R> functionalInstance = arg -> new R();

Dans le cas de la définition de méthode, il a été appelé comme suit,

MethodCall

R returnValue = functionName((T) argument);

Si vous utilisez Function, utilisez la méthode apply,

InstanceCall

R returnValue = functionalInstance.apply((T) argument);

Et.

La méthode en Java n'est pas un objet de première classe, mais il semble que nous ayons créé un nouveau mécanisme pour faciliter l'introduction d'un tel style.

Consumer Une fois que vous connaissez la fonction, c'est facile et le consommateur est une interface pour définir des instances qui consomment des arguments. Puisque l'argument est pris mais que la valeur de retour n'existe pas, il n'y a qu'une seule spécification de type par les génériques côté argument.

En tant qu'image, une version d'instance de la méthode suivante.

void consumer(T arg) {
    something(arg);
}

La méthode de définition est la suivante. Remplacez la méthode appelée accept pour déterminer le comportement.

Consumer<T> consumer = new Consumer<T>() {
    @Override
    public void accept(T arg) {
        something(arg);
    }

Pour lambda, ci-dessous.

Consumer<T> consumer = arg -> something(arg);

L'appel est effectué comme suit.

consumer.accept((T) argument)

Supplier Le fournisseur est une interface pour définir un comportement qui ne prend aucun argument mais qui a une valeur de retour.

En tant qu'image, il s'agit de créer une version d'instance de la méthode suivante.

T consumer() {
    return new T();
}

Il est défini comme suit.

Supplier<T> supplier = new Supplier<T>() {
    @Override
    public T get() {
        return new T();
    }
}

Ci-dessous pour lambda.

Supplier<T> supplier = () -> new T();

Lors de son utilisation, procédez comme suit.

supplier.get();

Predicate Predicate est une interface qui reçoit un argument et renvoie une valeur booléenne.

//Vrai si l'argument est 1, faux sinon
Predicate<Integer> predicate = arg -> arg == 1;

Integer argument = 1;
if (predicate.test(argument)) {
    System.out.println("argument is 1");
} else {
    System.out.println("argument is not 1");
}

Je l'utilise comme ça.

Je pense que c'est proche de Function <T, Boolean>, mais dans ce cas, il y a unboxing de Boolean à Boolean, est-ce donc l'un des objectifs de l'éviter? Il semble y avoir une méthode appelée et ou ou, mais je vais l'omettre car elle semble être rarement utilisée.

Si vous voulez une compréhension complète de synchronisé

Explication de l'exemple d'erreur synchronisée et typique J'ai écrit, alors vérifiez-le également. Empiriquement, environ 70% des gens ont tort.