标签: iterator

可能重复:
VB.NET中的产量

在C#中,当编写返回a的函数时IEnumerble<>,您可以使用yield return返回枚举的单个项目并yield break;表示没有剩余项目.做同样事情的VB.NET语法是什么？

NerdDinner代码中的一个示例:

public IEnumerable<RuleViolation> GetRuleViolations() {

   if (String.IsNullOrEmpty(Title))
       yield return new RuleViolation("Title required","Title");

   if (String.IsNullOrEmpty(Description))
       yield return new RuleViolation("Description required","Description");

   if (String.IsNullOrEmpty(HostedBy))
       yield return new RuleViolation("HostedBy required", "HostedBy");

   if (String.IsNullOrEmpty(Address))
       yield return new RuleViolation("Address required", "Address");

   if (String.IsNullOrEmpty(Country))
       yield return new RuleViolation("Country required", "Country");

   if (String.IsNullOrEmpty(ContactPhone))
       yield return new RuleViolation("Phone# required", "ContactPhone");

   if (!PhoneValidator.IsValidNumber(ContactPhone, Country))
       yield return new RuleViolation("Phone# does not match country", "ContactPhone");

   yield break;
}

这将C#转换为VB.NET工具 …

我通过文档(去http://java.sun.com/javase/6/docs/api/java/util/Iterator.html)的Iterator.remove() 存在remove()被描述成

void remove()

从底层集合中移除迭代器返回的最后一个元素(可选操作).每次调用next时,只能调用一次此方法.如果在迭代正在进行中以除调用此方法之外的任何方式修改基础集合,则未指定迭代器的行为.

1. 那么任何人都能说出"可选"意味着什么.
2. 这是否会影响操作的稳健性？(与c ++一样,它不能保证操作的稳健性.)
3. 为什么在这里明确指定了"可选".
4. "修改"在第二行文档中意味着什么

如果修改了基础集合,则未指定迭代器的行为

我是一个尝试使用地图的C++新手,所以我可以获得find()方法的恒定时间查找.

问题是,当我使用迭代器遍历地图中的元素时,元素的显示顺序与它们放置在地图中的顺序不同.

如果不维护另一个数据结构,是否有一种方法可以实现按顺序迭代,同时仍然保持恒定的时间查找能力？

请告诉我.

谢谢,jbu

编辑:感谢让我知道map :: find()不是常数时间.

在Python 2中,文件对象有一个xreadlines()方法,它返回一个迭代器,一次读取一行文件.在Python 3中,xreadlines()方法不再存在,而realines()仍然返回一个列表(不是迭代器).Python 3有类似于xreadlines()的东西吗？

我知道我能做到

for line in f:

代替

for line in f.xreadlines():

但我还想使用没有for循环的xreadlines():

print(f.xreadlines()[7]) #read lines 0 to 7 and prints line 7

如果我为myList设置了一个迭代器:

Iterator iter = myList.iterator();
while(iter.hasNext())
{
    MyObj myObj = (MyObj)iter.next();
    doPrint(myObj.toString());
}

我称之为第二次:

while(iter.hasNext())
{
    MyObj myObj = (MyObj)iter.next();
    doPrint(myObj.toString());
}

我第二次打电话给它时会回到收藏的开头吗？

g ++确实__restrict__为指针实现,但我找不到任何关于迭代器的东西.我的总体意图是鼓励编译器对stl循环进行矢量化.

编辑:

即使编译器无法进行向量化,__restrict__关键字也应该能够告诉编译器在循环内不需要不必要的重新加载.

我正在编写GC友好代码来读取并向用户返回一系列byte[]消息.在内部我重复使用ByteBuffer它,这意味着我将在大多数时间重复返回相同的byte[]实例.

我正在考虑编写警示javadoc并将其暴露给用户作为Iterator<byte[]>.AFAIK它不会违反Iterator合同,但如果他们这样做Lists.newArrayList(myIterator)并且在每个位置回到List人口中,那么用户肯定会感到惊讶byte[]!

问题:对于可能变异并返回相同对象来实现接口的类,这是不好的做法吗？Iterator

• 如果是这样,最好的选择是什么？"不要改变/重用你的对象"是一个简单的答案.但它没有解决重用非常需要的情况.

• 如果没有,你如何证明违反最不惊讶的原则？

两个小调:

• 我正在使用Guava,AbstractIterator因此remove()并不是真正值得关注的问题.

• 在我的用例中,用户就是我,这个类的可见性将受到限制,但我已经尝试过这个问题,通常可以更广泛地应用.

更新:我接受路易斯的答案,因为它的票数比基思多3倍,但请注意,在我的用例中,我打算采用我留下的代码来评论基思对生产的回答.

我有一份清单std::list<T *> *l;.此列表不为空且具有一些值.我的问题是如何正确访问项目？我不需要遍历列表.我只想要第一个项目.

std::list<T*>::iterator it = l->begin();

if (it != l->end())
{
    // accessing T
    int value = (*it)->value(); // Is this safe?
}

或者我也应该检查是否为空？

if (it != l->end() && (*it))
{
    // accessing T
    int value = (*it)->value();
}

我写了一个函数,使用流无限期地生成质数(维基百科:Erastothenes的增量筛).它返回一个流,但它也在内部合并素数倍流以标记即将到来的复合.如果我自己这样说,这个定义简洁,实用,优雅且易于理解:

def primes(): Stream[Int] = {
  def merge(a: Stream[Int], b: Stream[Int]): Stream[Int] = {
    def next = a.head min b.head
    Stream.cons(next, merge(if (a.head == next) a.tail else a,
                            if (b.head == next) b.tail else b))
  }
  def test(n: Int, compositeStream: Stream[Int]): Stream[Int] = {
    if (n == compositeStream.head) test(n+1, compositeStream.tail)
    else Stream.cons(n, test(n+1, merge(compositeStream, Stream.from(n*n, n))))
  }
  test(2, Stream.from(4, 2))
}

但是,当我尝试生成第1000个素数时,我得到了"java.lang.OutOfMemoryError:超出GC开销限制".

我有一个替代解决方案,它在primes上返回一个迭代器,并在内部使用元组的优先级队列(multiple,prime用于生成多个)来标记即将到来的复合.它运行良好,但它需要大约两倍的代码,我基本上不得不从头重新开始:

import scala.collection.mutable.PriorityQueue
def primes(): Iterator[Int] = {
  // Tuple (composite, prime) is used to generate …

Rust标准库是否有一个函数可以在给定种子和lambda的情况下生成无限迭代器,就像Java 8 Streams提供的那样？如果没有,Rust的类似替代品是什么？

Stream.iterate(1, x -> 2 * x);