Y a-t-il un équivalent Java du mot-clé \'yield\' de C#?

Question

Je sais qu'il n'y a pas d'équivalent direct en Java lui-même, mais peut-être un tiers?

C'est vraiment pratique. Actuellement, j'aimerais implémenter un itérateur qui renvoie tous les nœuds dans un arbre, ce qui revient à environ cinq lignes de code avec yield.

Answer 1

Stream.iterate(seed, seedOperator).limit(n).foreach(action) n'est pas le même que l'opérateur yield, mais il peut être utile d'écrire vos propres générateurs de cette manière :

import java.util.stream.Stream;
public class Test01 {
    private static void myFoo(int someVar){
        //do some work
        System.out.println(someVar);
    }
    private static void myFoo2(){
        //do some work
        System.out.println("some work");
    }
    public static void main(String[] args) {
        Stream.iterate(1, x -> x + 1).limit(15).forEach(Test01::myFoo);     //var1
        Stream.iterate(1, x -> x + 1).limit(10).forEach(item -> myFoo2());  //var2
    }
}

Answer 2

Je suggérerais également si vous utilisez déjà RXJava dans votre projet d'utiliser un Observable comme "yielder". Il peut être utilisé de manière similaire si vous créez votre propre Observable.

public class Example extends Observable {

    public static void main(String[] args) {
        new Example().blockingSubscribe(System.out::println); // "a", "b", "c", "d"
    }

    @Override
    protected void subscribeActual(Observer observer) {
        observer.onNext("a"); // yield
        observer.onNext("b"); // yield
        observer.onNext("c"); // yield
        observer.onNext("d"); // yield
        observer.onComplete(); // finish
    }
}

Les Observables peuvent être transformés en iterateurs, vous permettant ainsi de les utiliser même dans des boucles for plus traditionnelles. RXJava vous offre des outils très puissants, mais si vous avez juste besoin de quelque chose de simple, cela pourrait être un peu trop.

Answer 3

// Code Java pour Stream.generate()
// pour générer un flux séquentiel infini
// non ordonné
import java.util.*;
import java.util.stream.Stream;

class GFG {

    // Code pilote
    public static void main(String[] args) {

    // en utilisant la méthode Stream.generate()
    // pour générer 5 valeurs entières aléatoires
    Stream.generate(new Random()::nextInt)
      .limit(5).forEach(System.out::println); 
    }
}

Ici.

Answer 4

J'ai écrit une nouvelle bibliothèque qui a implémenté un générateur pour Java. C'est simple, sans thread et rapide.

Voici un exemple de génération de nombres de Fibonacci infinis :

public static Seq fibonacci() {
    return c -> {
        int a = 1;
        int b = 1;
        c.accept(a);
        c.accept(b);
        while (true) {
            c.accept(b = a + (a = b));
        }
    };
}

L'interface Seq est similaire à Stream en Java et Sequence en Kotlin, mais plus rapide que tous les deux.

Ici, imprimons les 7 premiers éléments de la série de Fibonacci

Seq fib = fibonacci();
fib.take(7).printAll(","); // => 1,1,2,3,5,8,13

Pour le problème original, produire tous les nœuds d'un arbre ? Une seule ligne suffit.

Seq seq = Seq.ofTree(root, n -> Seq.of(n.left, n.right));

Answer 5

Oui, vous pouvez avoir une syntaxe similaire à yield return en Java!

En Java, pour obtenir une syntaxe comme:

Yielder(list).forEach(x->doSomething(x))

On crée une classe comme ceci:

public class Yielder {
    public List l;

    public Yielder(List l){
       this.l=l;
    }

    public void forEach(Consumer f){
        for(String s : l){
            f.accept(s);
        }
    }
}

Où f.accept() remplit le rôle de yield return.