迭代器和可迭代器之间的区别是什么?如何使用它们?

我是Java的新手，我真的很困惑迭代器和可迭代器。谁能给我解释一下并举几个例子吗?

175878 次浏览
小开

如果一个集合是可迭代的，那么它可以使用迭代器迭代(因此可以在for每个循环中使用)。迭代器是遍历集合的实际对象。

小开
最佳答案

Iterable是可以迭代的一系列元素的简单表示。它没有任何迭代状态，例如“当前元素”。相反，它有一个产生Iterator的方法。

Iterator是具有迭代状态的对象。它允许你使用hasNext()检查是否有更多的元素，并使用next()移动到下一个元素(如果有)。

通常，Iterable应该能够产生任意数量的有效__abc1。

小开

Iterable的实现提供了自己的Iterator:

public interface Iterable<T>
{
Iterator<T> iterator();
}

迭代器是一种简单的方法，允许一些人在没有赋值权限的情况下循环遍历数据集合(尽管有删除的能力)。

public interface Iterator<E>
{
boolean hasNext();
E next();
void remove();
}

看到Javadoc。

小开

实现Iterable接口允许一个对象作为foreach语句的目标。

class SomeClass implements Iterable<String> {}


class Main
{
public void method()
{
SomeClass someClass = new SomeClass();
.....


for(String s : someClass) {
//do something
}
}
}

Iterator是一个接口，它具有迭代元素的实现。Iterable是一个提供迭代器的接口。

小开

最重要的考虑是所讨论的项是否应该能够多次遍历。这是因为你总是可以通过再次调用iterator()来倒带一个Iterable，但是没有办法倒带一个iterator。

小开
问题:Iterable和Iterator之间的区别?< br > 答:< / p >

iterable:它与forEach循环
相关 iterator: Is与Collection

相关 forEach循环的目标元素应该是可迭代的。< br > 我们可以使用Iterator从

Collection中逐个获取对象

Iterable存在于java中。ḷang包< br > java中的迭代器。util包< / p >

只包含一个方法迭代器()
包含三个方法hasNext()， next()， remove()

1.5版本引入 在1.2版本引入

小开

除了ColinD和Seeker answers.

简单来说，可迭代的和迭代器都是Java的集合框架中提供的接口。

可迭代的

如果一个类想要有一个for - each循环来遍历它的集合，它必须实现Iterable接口。然而,for-each循环只能用于向前循环该集合，并且不能修改该集合中的元素。但是，如果您想要的只是读取元素数据，那么它就非常简单，并且由于Java lambda表达式，它通常是一行。例如:

iterableElements.forEach (x -> System.out.println(x) );

迭代器

此接口使您能够遍历集合，获取和删除其中的元素。每个集合类都提供一个迭代器()方法，该方法返回一个指向集合开头的迭代器。与iterable相比，该接口的优点是使用您可以在集合中添加、修改或删除元素. xml接口。但是，访问元素需要比iterable多一点的代码。例如:

for (Iterator i = c.iterator(); i.hasNext(); ) {
Element e = i.next();    //Get the element
System.out.println(e);    //access or modify the element
}

来源:

  1. Java Doc Iterable
  2. Java Doc Iterator
小开

基本上来说，这两者都是密切相关的。

考虑迭代器是一个接口，它帮助我们在一些未定义的方法(如hasNext()， next()和remove())的帮助下遍历一个集合

另一方面，可迭代的是另一个接口，如果由类实现，则强制该类为Iterable，并且是for - each构造的目标。 它只有一个名为iterator()的方法，该方法来自iterator接口本身

当一个集合是可迭代的，那么它可以使用迭代器迭代。

为了了解，请访问以下内容:

ITERABLE: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/lang/Iterable.java

迭代器 http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/Iterator.java

小开
考虑一个有10个苹果的例子。 当它实现Iterable时，就像把每个苹果放在从1到10的盒子里，并返回一个可用于导航的迭代器

通过实现迭代器，我们可以得到任何apple, apple in next boxes等等。

实现iterable提供了一个迭代器来导航它的元素，尽管要导航，迭代器需要被实现。

小开

正如在这里所解释的，“可迭代的”被引入是为了能够在foreach循环中使用。实现可迭代的接口的类可以迭代。

Iterator是在可迭代的上管理迭代的类。它维护当前迭代中我们所处的状态，并知道下一个元素是什么以及如何获取它。

小开

我将回答这个问题，特别是关于数组列表的例子，以便帮助你更好地理解。

  1. 可迭代接口强制其子类实现抽象方法'iterator()'。
public interface Iterable {
...
abstract Iterator<T> iterator(); //Returns an 'Iterator'(not iterator) over elements of type T.
...
}
  1. 迭代器接口强制其子类实现抽象方法“hasNext()”和“next()”。
public interface Iterator {
...
abstract boolean hasNext(); //Returns true if the iteration has more elements.
abstract E next();          //Returns the next element in the iteration.
...
}
    数组列表实现了列表，列表扩展了集合，集合扩展了Iterable.. 也就是说，你可以这样看待这种关系

    可迭代对象<-集合<-列表<-数组列表

    李< /引用> < / >
< p >。 而Iterable, Collection和List只声明了抽象方法'iterator()'，而ArrayList单独实现了它
  1. 我将用'iterator()'方法显示ArrayList源代码，如下所示，以获取更详细的信息。

'iterator()'方法返回'Itr'类的对象，该对象实现'iterator '。

public class ArrayList<E> ... implements List<E>, ...
{
...
public Iterator<E> iterator() {
return new Itr();
}




private class Itr implements Iterator<E> {
...


public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
...
}
}
  1. 其他一些方法或类将通过使用Iterator (Itr)迭代ArrayList等集合的元素。

这里有一个简单的例子。

public static void main(String[] args) {


List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");


Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String string = iterator.next();
System.out.println(string);
}
}

现在明白了吗?：）

小开

Iterable被引入到java中的每个循环中使用

public interface Collection<E> extends Iterable<E>

Iterator是在Iterable上管理迭代的类。它维护当前迭代中我们所处的状态，并知道下一个元素是什么以及如何获取它。

小开

我知道这是一个老问题了，但是对于任何读到这篇文章的人来说，如果他们被同样的问题所困扰，并且可能被所有的术语所淹没，这里有一个很好的，简单的类比来帮助你理解迭代对象和迭代器之间的区别:

想想公共图书馆。旧的学校。用纸质书。是的，就是那种图书馆。

满满一书架的书就像一个可迭代对象。你可以看到书架上有一长排的书。你可能不知道有多少本书，但你可以看到这是一本很长的书集。

图书管理员就像迭代器一样。他可以在任何时候指出一本书。他可以在他所指向的位置插入/删除/修改/阅读书籍。每次你喊出“下一本”的时候，他就按顺序指着每一本书。给他。所以，你通常会问他:“下一个呢?”，他会说“是”，而你会说“下一个!”他会指向下一本书。他也知道什么时候他已经到了书架的尽头，所以当你问:“下一个是什么?”他会说“不”。

我知道这有点傻，但我希望这能有所帮助。

小开

匿名类可以轻松地将Iterator转换为Iterable，并允许您使用Iterable语法(对于循环，forEach())。

示例:考虑Iterator<T> it

for (T element : new Iterable<T>() {


@Override
public Iterator<T> iterator() {
return it;
}


}) {
//do something with `T element`
}

抽象在函数中

static <T> Iterable<T> toIterable(Iterator<T> it) {
return new Iterable<T>() {


@Override
public Iterator<T> iterator() {
return it;
}


};
}

使用

for (T element: toIterable(it) {
...
}

提交答案