我在编写旅行推销员计划时遇到过这种情况.对于内循环,我尝试了一个
for(Point x:ArrayList<Point>) {
// modify the iterator
}
但是当向该列表添加另一个点时会导致ConcurrentModicationException被抛出.
但是,当我将循环更改为
for(int x=0; x<ArrayList<Point>.size(); x++) {
// modify the array
}
循环运行良好,没有抛出异常.
两个for循环,那么为什么一个抛出异常而另一个没有呢？
C#Collections库中是否有任何数据结构,其中结构的修改不会使迭代器失效？
考虑以下:
List<int> myList = new List<int>();
myList.Add( 1 );
myList.Add( 2 );
List<int>.Enumerator myIter = myList.GetEnumerator();
myIter.MoveNext(); // myIter.Current == 1
myList.Add( 3 );
myIter.MoveNext(); // throws InvalidOperationException
我有人和地方数据如下:
Person 实体有
IList<DateRangePlaces> 每个人都有
IList<Place> 可能的地方 Schedule日模式为ie.10天可用4不可用在特定的DateRangePlaces日期范围内,人们必须遵守模仿Schedule人是否可以去某个特定的地方.
Place 实体有
IList<DateRangeTiming> 每个定义每个日期范围内的开/关时间重叠日期范围可用作LIFO.因此,对于之前已经定义的每一天,新的时间定义都会优先考虑.
现在我需要做这样的事情(在伪代码中):
for each Place
{
for each Day between minimum and maximum date in IList<DateRangeTiming>
{
get a set of People applicable for Place and on Day
}
}
这意味着执行我的任务的步骤数约为:
Σ (地方)(Σ (天) ×Σ (人))
这对我的理解是
O(x×y x ×z)
并且可能与此算法的复杂性近似:
O(n 3)
我不是理论专家,所以你可以自由地纠正我的假设.真实的是,这种复杂性绝对是不可接受的,特别是考虑到我将在很多地方和人的长日期范围内运作.
从公式近似中我们可以看到人集会被多次迭代.因此,我想至少优化这一部分.为了缓解事情,我改变了一点
Person.IList<DateRangePlaces>.IList<Place>
至
Person.IList<DateRangePlaces>.IDictionary<int, Place>
无论一个人是否可以在特定日期到某个地方,这会给我一个更快的结果,因为我只会检查是否Place.Id存在于字典中而不是IList.Where()每次都必须扫描整个列表的LINQ子句.
您是否可以建议我可以在算法中实现任何其他优化,以使其更快,甚至在大O符号方面使其更简单？
您将使用哪种内存结构类型(列表,字典,堆栈,队列......)来提高性能？
我希望扩展迭代器来创建一个新方法takeWhileInclusive,它将像takeWhile最后一个元素一样运行.
我的问题是扩展迭代器以返回一个我希望延迟评估的新迭代器的最佳实践.来自C#背景我正常使用IEnumerable并使用yield关键字,但这样的选项似乎不存在于Scala中.
例如,我可以
List(0,1,2,3,4,5,6,7).iterator.map(complex time consuming algorithm).takeWhileInclusive(_ < 6)
所以在这种情况下,takeWhileInclusive只有解析值的谓词,直到我得到大于6的结果,并且它将包括第一个结果
到目前为止我有:
object ImplicitIterator {
implicit def extendIterator(i : Iterator[Any]) = new IteratorExtension(i)
}
class IteratorExtension[T <: Any](i : Iterator[T]) {
def takeWhileInclusive(predicate:(T) => Boolean) = ?
}
在了解了迭代器类方法和生成器之后,我使用每个习语测试了简单的Fizz Buzz解决方案的性能特征:
>>> from timeit import timeit
>>> timeit('tuple(fizzbuzz.FizzBuzzIterator(10))', 'import fizzbuzz')
13.281935930252075
>>> timeit('tuple(fizzbuzz.fizz_buzz_generator(10))', 'import fizzbuzz')
7.619534015655518
根据timeit生成器函数比迭代器类快约1¾倍.
我的问题是:为什么这个Fizz Buzz生成器明显比这个Fizz Buzz Iterator类快？
class FizzBuzzIterator:
def __init__(self, low, high=None):
if high is None:
self.high = low
self.current = 1
else:
self.high = high
self.current = max(low, 1)
def __iter__(self):
return self
def next(self):
if self.current > self.high:
raise StopIteration
else:
c = self.current
self.current += 1
if (c % 5 + c % …任何人都可以让我知道在java中实时使用空Iterator是什么时候？我很想知道为什么需要它？像,
1. public static <T> Iterator<T> emptyIterator()
2. public static <T> ListIterator<T> emptyListIterator()
3. public static final <T> Set<T> emptySet(), etc..
来源:http://docs.oracle.com/javase/7/docs/api/java/util/Collections.html#emptyIterator()
当一个函数将一系列值作为参数时,它被认为是接受Iterator<T>而不是Vec<T>？的好风格？
这样,调用者可以自己决定如何存储系列(在a Vec,a [T; N]或其他任何内容中,实际上Option<T>应该是可能的!).此外,这消除了将所有内容转换为a的需要Vec,并且在应用一些Iterator修饰符后,.collect()不需要!所以它也应该更快!
我错过了什么或这是应该做的方式吗？
假设,我已经C++像这样声明了一个向量:
vector<int>numbers = {4,5,3,2,5,42};
我可以通过以下代码迭代它:
for (vector<int>::iterator it = numbers.begin(); it!=numbers.end(); it++){
// code goes here
}
现在,我将讨论块中的编码for loop.
我可以使用这个迭代器访问和更改任何值.比如,我想将每个值增加10和打印.所以,代码将是:
*it+=10;
cout << *it << endl;
我可以打印迭代器的地址和正在迭代的元素.
迭代器的地址可以通过以下方式打印:
cout << &it << endl;
迭代元素的地址可以通过以下方式打印:
cout << &(*it) << endl;
但是为什么迭代器本身不能通过执行以下操作来打印？
cout << it <<endl;
起初我认为会议来自于JAVA考虑安全目的.但如果是的话,为什么我可以打印它的地址呢？
但是,有没有其他方法可以做到这一点？如果没有,为什么？
根据文件:
一旦迭代器的
__next__()方法引发StopIteration,它必须继续在后续调用中这样做.不遵守此属性的实现被视为已损坏.
但是,对于文件对象:
>>> f = open('test.txt')
>>> list(f)
['a\n', 'b\n', 'c\n', '\n']
>>> next(f)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>> f.seek(0)
0
>>> next(f)
'a\n'
文件对象迭代器是否已损坏？这只是其中一个无法解决的问题,因为它会破坏过多依赖它的现有代码吗？