java迭代器

前言

迭代器是一种模式、详细可见其设计模式，可以使得序列类型的数据结构的遍历行为与被遍历的对象分离，即我们无需关心该序列的底层结构是什么样子的。只要拿到这个对象,使用迭代器就可以遍历这个对象的内部

一、Iterable

实现这个接口允许一个对象成为“For-each”语句的目标。

public interface Iterable<T> {
	//执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。
	default void forEach(Consumer<? super T> action)
	Iterator<T> iterator()//返回类型 T元素的迭代器。
	default Spliterator<T> spliterator()//在这 Iterable创建描述元素的 Spliterator
}

二、Iterator

对 collection 进行迭代的迭代器。不包括Map

public interface Iterator<E>{
	//只能单向移动
	boolean hasNext()  如果仍有元素可以迭代，则返回 true。 
	E next()  //返回迭代的下一个元素。 
	void remove() //从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。在使用remove前必须要先调用next（）
}

注意：对于一个迭代器，如果已经迭代完了，就不能在取数据了

Iterator<Integer> it = set.iterator();

while(it.hasNext()){
      if(it.next()==5){
           it.remove();
       }           
}
       
while(it.hasNext()){          
        System.out.println(it.next());    //什么都不输出                    
}

三、ListIterator

public interface ListIterator extends Iterator

一个列表的迭代器，允许程序员在两个方向遍历列表

正向遍历列表

boolean hasNext()//返回 true如果列表迭代器具有更多的元素时，正向遍历列表。
E next()//返回列表中的下一个元素，并推进光标位置。
int nextIndex()//返回的元素的索引，将返回的后续调用 next()指数。

逆向遍历列表

boolean hasPrevious()//返回 true如果列表迭代器具有更多的元素时，逆向遍历列表。
E previous()//返回列表中的前一个元素，并向后移动光标位置。
int previousIndex() //返回的元素的索引，将返回的后续调用 previous()指数。

操作集合

void add(E e)//将指定的元素插入到列表中（可选操作）。
void remove()//从列表中删除最后一个元素是由 next()或 previous()返回（可选操作）。
void set(E e)//取代过去的元素返回 next()或 previous()与指定的元素（可选操作）。

四、Spliterator

public interface Spliterator<T> {
 //。。。。。
}

为什么有了Iterator还需要spliterator呢

从最早Java提供顺序遍历迭代器Iterator时，那个时候还是单核时代，但现在多核时代下，顺序遍历已经不能满足需求了，如何把多个任务分配到不同核上并行执行，才是能最大发挥多核的能力，所以Spliterator应运而生啦，Spliterator接口是Java为了并行遍历数据源中的元素而设计的迭代器

1、迭代

//如果剩下的元素存在，执行给定的操作，返回true ; 否则返回false 。
boolean	tryAdvance(Consumer<? super T> action)//进行一次iterate并且判断是否有元素还存在
//在当前线程中依次执行每个剩余元素的给定操作，直到所有元素都被处理或动作引发异常。
default void forEachRemaining(Consumer<? super T> action)

案例

List<String> list = Arrays.asList("Apple", "Banana", "Orange");
Spliterator<String> spliterator = list.spliterator();
spliterator.tryAdvance(System.out::println);//Apple
spliterator.forEachRemaining(System.out::println);//Banana  Orange
System.out.println(spliterator.tryAdvance(System.out::println));//false

2、分割迭代器

//如果此分割器可以被分区，返回一个包含元素的Spliter，当从该方法返回时，它不会被该Spliter所覆盖。
Spliterator<T>	trySplit()

案例

List<String> list = Arrays.asList("Apple", "Banana", "Orange");
Spliterator<String> s = list.spliterator();
Spliterator<String> s1 = s.trySplit();
s.forEachRemaining(System.out::println);//Banana Orange
s1.forEachRemaining(System.out::println);//Apple

3、返回迭代器准备迭代的次数

long	estimateSize()
//方便的方法返回 estimateSize()如果这个Spliterator是 SIZED ，否则 -1 。
default long	getExactSizeIfKnown()

4、对某种特性的集合是否拥有哪个特点进行判断

int	characteristics()//返回此Spliterator及其元素的一组特征。
//返回 true如果Spliterator的 characteristics()包含所有给定的特性。
default boolean	hasCharacteristics(int characteristics)

特点值如下

static int	CONCURRENT // (concurrent)集合是线程安全的

static int	DISTINCT // （distinct） 集合中元素都是不重复的

static int	IMMUTABLE //（immutable）集合是不能修改的

static int	NONNULL //（nonnull）集合是非null的

static int	ORDERED // （ordered）集合是排序的

static int	SORTED //（sorted）集合是排序的

static int	SUBSIZED //标志着其trySplit()产生的Spliterators将是既 SIZED和 SUBSIZED 。

static int	SIZED //estimateSize返回的是元素数量的精确计数的有限大小

5、返回比较器

//如果这个Spliterator的来源是SORTED由Comparator ，返回Comparator 。
default Comparator<? super T>	getComparator()

6、静态内部类

Spliterator.OfDouble //A Spliterator专门为 double值。
Spliterator.OfInt//A Spliterator专门为 int值。
Spliterator.OfLong//A Spliterator专门为 long值。
Spliterator.OfPrimitive<T,T_CONS,T_SPLITR>> //专门针对原始价值观的Spliterator。

他们的方法都是如下格式，这里以Spliterator.OfDouble为例子

default void	forEachRemaining(Consumer<? super Double> action)

default void	forEachRemaining(DoubleConsumer action)

default boolean	tryAdvance(Consumer<? super Double> action)

boolean	tryAdvance(DoubleConsumer action)

Spliterator.OfDouble	trySplit()

五、Spliterators

用于上操作或创建的实例的方法Spliterator和其原始特Spliterator.OfInt ， Spliterator.OfLong和Spliterator.OfDouble 。

1、返回的是Spliterator.OfDouble

static Spliterator.OfDouble	emptyDoubleSpliterator() //创建一个空的 Spliterator.OfDouble
static Spliterator.OfDouble	spliterator(double[] array, int additionalCharacteristics)
//fromIndex包括，toIndex不包括
static Spliterator.OfDouble	spliterator(double[] array, int fromIndex, int toIndex, int additionalCharacteristics)
//创建一个 Spliterator.OfDouble使用给定的 DoubleStream.DoubleIterator作为元素的来源，并给定最初报告的大小。
static Spliterator.OfDouble	spliterator(PrimitiveIterator.OfDouble iterator, long size, int characteristics)
//创建一个 Spliterator.OfDouble使用给定的 DoubleStream.DoubleIterator作为元素的来源，没有初始大小估计。
static Spliterator.OfDouble	spliteratorUnknownSize(PrimitiveIterator.OfDouble iterator, int characteristics)

2、返回的是Spliterator.OfLong

static Spliterator.OfLong	emptyLongSpliterator()//创建一个空的 Spliterator.OfLong
static Spliterator.OfLong	spliterator(long[] array, int additionalCharacteristics)
static Spliterator.OfLong	spliterator(long[] array, int fromIndex, int toIndex, int additionalCharacteristics)
//使用给定的 LongStream.LongIterator创建一个 Spliterator.OfLong作为元素的来源，没有初始大小估计。
static Spliterator.OfLong	spliteratorUnknownSize(PrimitiveIterator.OfLong iterator, int characteristics)
//使用给定的 LongStream.LongIterator作为元素的来源创建一个 Spliterator.OfLong ，并给出最初报告的大小。
static Spliterator.OfLong	spliterator(PrimitiveIterator.OfLong iterator, long size, int characteristics)

3、返回的是Spliterator.OfInt

static Spliterator.OfInt	emptyIntSpliterator()//创建一个空的 Spliterator.OfInt
static Spliterator.OfInt	spliterator(int[] array, int additionalCharacteristics)
static Spliterator.OfInt	spliterator(int[] array, int fromIndex, int toIndex, int additionalCharacteristics)
//创建一个 Spliterator.OfInt使用给定的 IntStream.IntIterator作为元素的来源，没有初始大小估计。
static Spliterator.OfInt	spliteratorUnknownSize(PrimitiveIterator.OfInt iterator, int characteristics)
//使用给定的 IntStream.IntIterator作为元素的来源创建一个 Spliterator.OfInt ，并使用给定的最初报告的大小。
static Spliterator.OfInt	spliterator(PrimitiveIterator.OfInt iterator, long size, int characteristics)

4、返回的是Spliterator

static <T> Spliterator<T>	emptySpliterator() //创建一个空的 Spliterator
static <T> Spliterator<T>	spliterator(Collection<? extends T> c, int characteristics)
static <T> Spliterator<T>	spliterator(Iterator<? extends T> iterator, long size, int characteristics)
static <T> Spliterator<T>	spliterator(Object[] array, int additionalCharacteristics)
static <T> Spliterator<T>	spliterator(Object[] array, int fromIndex, int toIndex, int additionalCharacteristics)
//创建一个 Spliterator使用给定的 Iterator作为元素的来源，没有初始大小估计。
static <T> Spliterator<T>	spliteratorUnknownSize(Iterator<? extends T> iterator, int characteristics)

5、返回的是Iterator

static <T> Iterator<T>	iterator(Spliterator<? extends T> spliterator)//创建一个 Iterator从 Spliterator 。

6、返回的是PrimitiveIterator

//创建一个 PrimitiveIterator.OfDouble从 Spliterator.OfDouble 。
static PrimitiveIterator.OfDouble	iterator(Spliterator.OfDouble spliterator)
//创建一个 PrimitiveIterator.OfInt从 Spliterator.OfInt 。
static PrimitiveIterator.OfInt	iterator(Spliterator.OfInt spliterator)
//创建一个 PrimitiveIterator.OfLong从 Spliterator.OfLong 。
static PrimitiveIterator.OfLong	iterator(Spliterator.OfLong spliterator)

最后

以上就是紧张鸡为你收集整理的java迭代器的全部内容，希望文章能够帮你解决java迭代器所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。