Java 是否有相当于 C# 的“yield”？关键词？

Question

我知道 Java 本身没有直接的等价物，但也许有第三方？

真的很方便。目前我想实现一个迭代器，它生成树中的所有节点，大约有五行带有yield的代码。

Answer 1

我知道的两个选项是 Aviad Ben Dov 2007 年的 infomancers-collections 库 和 < a href="http://svn.jimblackler.net/jimblackler/trunk/IdeaProjects/YieldAdapter/" rel="noreferrer">Jim Blackler 2008 年的 YieldAdapter 库（另一个答案中也提到了）。

两者都允许您在 Java 中使用类似 yield return 的结构编写代码，因此两者都能满足您的要求。两者之间的显着差异是：

Mechanics

Aviad 的库使用字节码操作，而 Jim 的库使用多线程。根据您的需求，每种方法可能都有自己的优点和缺点。 Aviad 的解决方案可能更快，而 Jim 的解决方案更便携（例如，我认为 Aviad 的库不适用于 Android）。

Interface

Aviad 的库有一个更清晰的界面 - 这里有一个例子：

Iterable<Integer> it = new Yielder<Integer>() {
    @Override protected void yieldNextCore() {
        for (int i = 0; i < 10; i++) {
            yieldReturn(i);
            if (i == 5) yieldBreak();
        }
    }
};

而 Jim 的则复杂得多，需要您adept一个通用的Collector，它有一个 collect(ResultHandler) 方法...呃。但是，您可以使用类似于 Zoom Information 提供的 Jim 代码包装器，这大大简化了

Iterable<Integer> it = new Generator<Integer>() {
    @Override protected void run() {
        for (int i = 0; i < 10; i++) {
            yield(i);
            if (i == 5) return;
        }
    }
};

：

Aviad 的解决方案是 BSD。

Jim 的解决方案是公共领域的，上面提到的它的包装器也是公共领域的。

Answer 2

现在 Java 有了 Lambda，这两种方法都可以变得更加简洁。您可以执行类似

public Yielderable<Integer> oneToFive() {
    return yield -> {
        for (int i = 1; i < 10; i++) {
            if (i == 6) yield.breaking();
            yield.returning(i);
        }
    };
}

我在这里解释了更多内容的操作。

Answer 3

我知道这是一个非常老的问题，上面描述了两种方法：

• 移植时字节码操作并不那么容易；
• 基于线程的yield显然会产生资源成本。

然而，还有另一种（第三种，可能是最自然的）方法在 Java 中实现 yield 生成器，它是最接近 C# 2.0+ 编译器对 yield return/break< 的实现。 /code> 生成：lombok-pg。它完全基于状态机，需要与 javac 紧密配合来操作源代码 AST。不幸的是，lombok-pg 支持似乎已停止（超过一两年没有存储库活动），并且原始的 Project Lombok 遗憾的是缺少 yield 功能（不过它有更好的 IDE，如 Eclipse、IntelliJ IDEA 支持）。

Answer 4

我刚刚发布了另一个（麻省理工学院许可的）解决方案此处，它在单独的线程中启动生产者，并且在生产者和消费者之间设置一个有界队列，允许生产者和消费者之间进行缓冲、流量控制和并行流水线（以便消费者可以在生产者致力于生产下一个项目时消耗前一个项目） 。

您可以使用这个匿名内部类形式：

Iterable<T> iterable = new Producer<T>(queueSize) {
    @Override
    public void producer() {
        produce(someT);
    }
};

例如：

for (Integer item : new Producer<Integer>(/* queueSize = */ 5) {
    @Override
    public void producer() {
        for (int i = 0; i < 20; i++) {
            System.out.println("Producing " + i);
            produce(i);
        }
        System.out.println("Producer exiting");
    }
}) {
    System.out.println("  Consuming " + item);
    Thread.sleep(200);
}

或者您可以使用 lambda 表示法来减少样板代码：

for (Integer item : new Producer<Integer>(/* queueSize = */ 5, producer -> {
    for (int i = 0; i < 20; i++) {
        System.out.println("Producing " + i);
        producer.produce(i);
    }
    System.out.println("Producer exiting");
})) {
    System.out.println("  Consuming " + item);
    Thread.sleep(200);
}

Answer 5

Stream.iterate(seed, SeedOperator).limit(n).foreach(action) 与yield 运算符不同，但以这种方式编写自己的生成器可能很有用：

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 6

我还建议您是否已经在项目中使用 RXJava 将 Observable 用作“屈服者”。如果您制作自己的 Observable，则可以以类似的方式使用它。

public class Example extends Observable<String> {

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

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

可观察量可以转换为迭代器，因此您甚至可以在更传统的 for 循环中使用它们。 RXJava 还为您提供了非常强大的工具，但如果您只需要一些简单的东西，那么这可能有点过大了。

Answer 7

// Java code for Stream.generate()
// to generate an infinite sequential
// unordered stream
import java.util.*;
import java.util.stream.Stream;
  
class GFG {
      
    // Driver code
    public static void main(String[] args) {
      
    // using Stream.generate() method 
    // to generate 5 random Integer values
    Stream.generate(new Random()::nextInt)
      .limit(5).forEach(System.out::println); 
    }
}

从这里。

Answer 8

我编写了一个新的 库，它实现了 Java 生成器。它简单、无线程且快速。

下面是生成无限斐波那契数的示例：

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

Seq 接口就像 Java Stream 和 Kotlin Sequence 一样，但比它们都快。

在这里，让我们打印斐波那契数列的前 7 个元素

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

对于最初的问题，生成树的所有节点？一根线就够了。

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

Answer 9

是的，你可以在 Java 中使用类似 Yield Return 的语法！

在java中，要获得这样的语法：

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

创建一个这样的类：

public class Yielder {
    public List<String> l;
    
    public Yielder(List<String> l){
       this.l=l;
    }

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

其中f.accept() 履行yield return 的作用。

Answer 10

下面介绍了如何将具有 Yield 逻辑的代码转换为 Java 等效代码。它可能需要一些努力，但至少不需要第三方库（仍然需要对 lambda 的支持）：

C# :

public IEnumerable<int> Foo()
{
     for (int i = 0; i < 5; i++)
     { 
          yield return i;
     }
}

Java :

public static Iterable<Integer> foo() {
    return () -> new Iterator<>() {
        Integer counter = 0;

        @Override
        public boolean hasNext() {
            return counter < 5;
        }
        
        @Override
        public Integer next() {
            return counter++;
        }
    };
}