C# Java中的收益率
我已经使用泛型在java中创建了一个链表，现在我希望能够遍历链表中的所有元素。在C#中，我将在链表中使用C# Java中的收益率,c#,java,linked-list,C#,Java,Linked List,我已经使用泛型在java中创建了一个链表，现在我希望能够遍历链表中的所有元素。在C#中，我将在链表中使用yield return，同时查看链表中包含的元素列表 我将如何创建上述内容的java版本，以便迭代链表中包含的所有项目 我希望能够写代码 LinkedList<something> authors = new LinkedList<something>(); for (Iterator<something> i = authors.Values ; i.H
yield returnLinkedList<something> authors = new LinkedList<something>();
for (Iterator<something> i = authors.Values ; i.HasNext())
doSomethingWith(i.Value);
LinkedList作者=新建LinkedList（）；
for（迭代器i=authors.Values；i.HasNext（））
具有（i.值）的dosomething；
LinkedListObject<something> current = first;
While (current != null){
yield return current.getValue();
current = current.getNext()
}
LinkedListObject当前=第一个；
While（当前！=null）{
产生返回电流。getValue（）；
current=current.getNext（）
}
收益返回的全部功能，您可能需要在两个线程中设置此功能，一个用于第一个方法，另一个用于第二个方法。然后，第一个线程应该等待
，直到第二个线程将其值放在可访问的位置，并通知它它已准备就绪。然后第一个线程将处理该值，等待下一个值，等等。我不明白人们为什么要谈论线程。。。关于收益率，有什么我不知道的吗
据我所知，yield-return只是保存方法堆栈，并在以后恢复它。要实现收益率回报，您只需手动保存状态。有关详细信息，请参阅Java迭代器类，不过对于链接列表，您可以保存当前项。对于数组，您只需要索引。只是为了帮助读者理解小细节
如果创建一个包含所有结果元素的新列表并返回该列表，那么这是一个很好的实现，非常简单，可以编写代码。您可以根据需要使用有趣的数据结构，在扫描它以查找正确的条目时，只需返回所有匹配项的列表，您的客户机就会在该列表上进行迭代
如果要保存一个状态，可能会更复杂。每次调用函数时，您都需要到达所处的位置。更不用说重新进入的问题了
带有线程的解决方案不会创建新列表。这和第一个解决方案一样简单。唯一的问题是，您涉及到一个线程同步，它的代码编写有点困难，并且有其性能损失
因此，是的，收益率非常高，Java中缺少了收益率。但也有解决办法。您可以返回Iterable的匿名实现。效果非常相似，只是这要详细得多
public Iterable<String> getStuff() {
return new Iterable<String>() {
@Override
public Iterator<String> iterator() {
return new Iterator<String>() {
@Override
public boolean hasNext() {
// TODO code to check next
}
@Override
public String next() {
// TODO code to go to next
}
@Override
public void remove() {
// TODO code to remove item or throw exception
}
};
}
};
}
public Iterable getStuff（）{
返回新的Iterable（）{
@凌驾
公共迭代器迭代器（）{
返回新的迭代器（）{
@凌驾
公共布尔hasNext（）{
//要检查下一步的TODO代码
}
@凌驾
公共字符串next（）{
//要转到下一步的TODO代码
}
@凌驾
公共空间删除（）{
//删除项或引发异常的TODO代码
}
};
}
};
}
“收益返回”是一个非常复杂的编译器技巧。它基本上允许您以声明方式实现IEnumerable，而不需要任何“弄清楚”如何构建迭代器的烦人细节。不幸的是，它不能很好地翻译成其他语言，因为很少有编译器具有这种能力。在某些方面，“收益回报”与革命一样可怕
基本上，在C#中，编译器将生成IEnumerable和IEnumerator（of T）的两个实现。它基本上是通过在生成的实现类中将“方法”的局部变量实现为实例字段，并检查包含“屈服-返回”工件的框架来实现的。一旦你知道了这一点，一个全面的开发人员应该可以明确地完成同样的事情。。。虽然不那么简洁。为了演示，我将演示
public static <T> Iterable<T> concat(Iterable<T> x, Iterable<T> y)
{
for(T e: x)
{
yield return e;
}
for(T e: y)
{
yield return e;
}
}
// becomes ....
public static <E> Iterator<E> concat_(Iterable<E> x, Iterator<E> y)
{
T e1, e2;
Iterator<E> i1, i2;
Iterator<E> s;
Iterator<E> s4 = new Iterator<E>()
{
public bool hasNext()
{
return false;
}
public E next()
{
throw ... ;
}
public void remove()
{
throw ... ;
}
}
Iterator<E> s3 = new Iterator<E>()
{
Iterator<E> act()
{
if(i2.hasNext())
{
return i2;
}
i2 = y.iterator();
return (s = s4);
}
public bool hasNext()
{
return act().hasNext();
}
public E next()
{
return act().next();
}
public void remove()
{
return i2.remove();
}
}
Iterator<E> s2 = new Iterator<E>()
{
Iterator<E> act()
{
if(i1.hasNext())
{
return i1;
}
i2 = y.iterator();
return (s = s3);
}
public bool hasNext()
{
return act().hasNext();
}
public E next()
{
return act().next();
}
public void remove()
{
return i1.remove();
}
};
Iterator<E> s1 = new Iterator<E>()
{
Iterator<E> act()
{
i1 = x.iterator();
return s = s2;
}
public bool hasNext()
{
return act().hasNext();
}
public E next()
{
return act().next();
}
public void remove()
{
return act().remove();
}
};
s = s1;
return new Iterator<T>()
{
public bool hasNext()
{
return s.hasNext();
}
public E next()
{
return s.next();
}
public void remove()
{
return s.remove();
}
};
}
public static <T> Iterable<T> concat(Iterable<T> x, Iterable<T> y)
{
return new Iterable<T>()
{
public Iterator<T> iterator()
{
return concat_(x, y)
}
};
}
// tada!
公共静态Iterable concat（Iterable x，Iterable y）
{
for（te:x）
{
收益率e；
}
for（te:y）
{
收益率e；
}
}
//变成。。。。
公共静态迭代器concat_（Iterable x，迭代器y）
{
t1，e2；
迭代器i1，i2；
迭代器s；
迭代器s4=新迭代器（）
{
公共图书馆
{
返回false；
}
公共教育
{
扔；
}
公共空间删除（）
{
扔；
}
}
迭代器s3=新迭代器（）
{
迭代器动作（）
{
if（i2.hasNext（））
{
返回i2；
}
i2=y.迭代器（）；
返回（s=s4）；
}
公共图书馆
{
return act（）.hasNext（）；
}
公共教育
{
返回act（）.next（）；
}
公共空间删除（）
{
返回i2.remove（）；
}
}
迭代器s2=新迭代器（）
{
迭代器动作（）
{
if（i1.hasNext（））
{
返回i1；
}
i2=y.迭代器（）；
回报率（s=s3）；
}
公共图书馆
{
return act（）.hasNext（）；
}
公共教育
{
返回act（）.next（）；
}
公共空间删除（）
{
返回i1.remove（）；
}
};
迭代器s1=新迭代器（）
{
迭代器动作（）
{
public class FibbonaciCoroutine implements Iterator<BigInteger> {
BigInteger[] bucket = { new BigInteger("1"), new BigInteger("1"), new BigInteger("0") };
int idx = 2;
Coroutine coroutine = new Coroutine((pthis) -> {
pthis.addInstruction("_label1", (me) -> {
int p1 = idx - 2;
int p2 = idx - 1;
if (p1 < 0)
p1 += 3;
if (p2 < 0)
p2 += 3;
bucket[idx] = bucket[p1].add(bucket[p2]);
idx = (idx + 1) % bucket.length;
me.yield(bucket[idx]);
});
// goto
pthis.addInstruction((me) -> {
me.jmp("_label1");
});
pthis.start();
});
@Override
public boolean hasNext() {
return !coroutine.isStopped();
}
@Override
public BigInteger next() {
while (coroutine.exec())
;
return coroutine.getYieldValue();
}
public static void main(String[] argv) {
FibbonaciCoroutine cor = new FibbonaciCoroutine();
for (int i = 0; i < 100 && cor.hasNext(); ++i) {
System.out.printf("%d ", cor.next());
}
}
}
@FunctionalInterface
public interface Looper<T> {
void each(T item);
}
public interface Loopable<T> {
void forEach(Looper<? super T> looper);
}
public class WhatEvs implements Loopable<WhatEvs> {
// ...
@Override
public void forEach(Looper<? super T> looper) {
while(your_condition) {
WhatEvs nextItem = getNextItem();
looper.each(nextItem);
}
}
}