Deuxième décoction: essayez une expression If en Java

La deuxième décoction de "Try If expression en Java".

Ce qui peut être réalisé

Par exemple, vous pouvez écrire FizzBuzz comme suit:

    public static void main(String... args) {
        for (int i = 1; i <= 100; ++i) {
            int count = i;
            String fizzBuzzed = 
                    If.<String>test(() -> count % 15 == 0).then(() -> "FizzBuzz")
                    .elif(() -> count % 3 == 0).then(() -> "Fizz")
                    .elif(() -> count % 5 == 0).then(() -> "Buzz")
                    .el(() -> Integer.toString(count));
            System.out.println(fizzBuzzed);
        }
    }

Préparation

Parce qu'il gère une valeur Nullable comme valeur de l'expression if Créez la classe générique suivante.

import java.util.function.Supplier;

/**
 *null peut également être considéré comme une valeur{@link java.util.Optional}。
 * 
 *Les méthodes non utilisées cette fois sont omises.
 */
public class MayBe<T> {

    /**
     *Créez une instance où la valeur existe.
     */
    public static <R> MayBe<R> of(R result) {
        return new MayBe<>(true, result);
    }

    /**
     *Créez une instance sans valeur.
     */
    public static <R> MayBe<R> empty() {
        return new MayBe<>(false, null);
    }

    private final boolean isPresent;
    private final T value;

    private MayBe(boolean isPresent, T value) {
        this.isPresent = isPresent;
        this.value = value;
    }

    /**
     *Renvoie si la valeur existe.
     */
    public boolean isPresent() {
        return this.isPresent;
    }

    /**
     *Si la valeur existe, il la renvoie, sinon elle renvoie la valeur obtenue à partir de l'argument autre.
     */
    public T orElseGet(Supplier<T> other) {
        return isPresent() ? this.value : other.get();
    }
}

Production

import java.util.function.BooleanSupplier;
import java.util.function.Supplier;

public class If<R> {

    public static <R> If<R> test(BooleanSupplier predicate) {
        return new If<>(predicate, null);
    }

    private final If<R> prev;
    private final BooleanSupplier predicate;

    private Then<R> then = null;

    /**
     * @prédicat param Prédicat de ce si.
     * @param prev Si this if est else if, le if précédent.
     *Sinon, nul.
     */
    private If(BooleanSupplier predicate, If<R> prev) {
        this.prev = prev;
        this.predicate = predicate;
    }

    public Then<R> then(Supplier<R> valueSupplier) {
        if (this.then != null) {
            throw new IllegalStateException("`then`A déjà été appelé.");
        }

        return this.then = new Then<>(this, valueSupplier);
    }

    /**
     *Évaluez jusqu'à cela si.
     * 
     * @return La valeur du résultat de l'évaluation.
     */
    private MayBe<R> eval() {
        if (this.then == null) {
            throw new IllegalStateException("`then`N'a pas encore été appelé.");
        }

        if (this.prev != null) {
            MayBe<R> prevValue = this.prev.eval();
            if (prevValue.isPresent()) {
                return prevValue;
            }
        }

        return this.predicate.getAsBoolean()
                ? MayBe.of(this.then.getThenValue())
                : MayBe.empty();
    }

    /**
     * {@link If#then}La classe d'objets renvoyée par.
     */
    public static class Then<R> {
        private final If<R> relatedIf;
        private final Supplier<R> thenValueSupplier;

        /**
         * @param relatedIf Ceci alors si.
         * @param valueSupplier La valeur à renvoyer si this then if est vrai.
         */
        Then(If<R> relatedIf, Supplier<R> valueSupplier) {
            this.relatedIf = relatedIf;
            this.thenValueSupplier = valueSupplier;
        }

        public If<R> elif(BooleanSupplier predicate) {
            return new If<>(predicate, this.relatedIf);
        }

        public R el(Supplier<R> valueSupplier) {
            return this.relatedIf.eval().orElseGet(valueSupplier);
        }

        /**
         *Renvoie la valeur si this then if est vrai.
         */
        R getThenValue() {
            return this.thenValueSupplier.get();
        }
    }
}

traits

--Seuls les prédicats if sont évalués. --Seules ceux qui ont besoin d'obtenir la valeur sont évalués.

• Vous pouvez utiliser else if (ʻelif`), pour ne pas avoir à imbriquer profondément.

Impressions

C'est plus facile à lire si c'est comme une fonction immédiate en JavaScript.

    public static void main(String... args) {
        for (int i = 1; i <= 100; ++i) {
            int count = i;
            String fizzBuzzed = ((Supplier<String>) () -> {
                if (count % 15 == 0) return "FizzBuzz";
                else if (count % 3 == 0) return "Fizz";
                else if (count % 5 == 0) return "Buzz";
                else return Integer.toString(count);
            }).get();
            System.out.println(fizzBuzzed);
        }
    }

/c'est tout