자바 Iterable 인터페이스 와 Iterator 교체 기

자바 Iterable 인터페이스 와 Iterator 교체 기
iterator
인터페이스 정 의 는 다음 과 같다.

public interface Iterator<E> {

    boolean hasNext();
    E next();
    void remove();
}

이 인 터 페 이 스 는 세 개의 함수 만 포함 하고 있 습 니 다. hasNext () 와 next () 방법 은 우리 가 자주 사용 하 는 집합 달력 에 나타 납 니 다.세 함수 의 역할:

next () 를 사용 하여 시퀀스 의 다음 요 소 를 얻 습 니 다.

hasNext () 를 사용 하여 시퀀스 에 요소 가 있 는 지 확인 합 니 다.

reove () 를 사용 하여 교체 기 가 새로 돌아 온 요 소 를 삭제 합 니 다.

iterator 인터페이스의 집합 을 실 현 했 습 니 다. 일반적으로 집합 을 옮 겨 다 니 는 쓰기 방법 은 예 를 들 어 우리 가 자주 사용 하 는 list 집합 입 니 다. list 집합 은 iterator 인터페이스 - 방법 1: for 를 실 현 했 습 니 다.

 list l = new ArrayList();
 l.add("aa");
 l.add("bb");
 l.add("cc");

  for (Iterator iter = l.iterator(); iter.hasNext();) {
  String str = (String)iter.next();
  System.out.println(str);
 }

방법 2: while

 Iterator iter = l.iterator();
 while(iter.hasNext()){
  String str = (String) iter.next();
  System.out.println(str);
 }

여기 서 우 리 는 Abstractlist 소스 코드 를 살 펴 보 았 습 니 다. 중간 에 iterator 실현 에 관 한 세부 사항 이 있 습 니 다. 위의 iter 는 실제 적 으로 다 형 이 고 호출 된 것 은 list 의 추상 적 인 Abstractlist 류 중의 iterator 방법 입 니 다.

 private class Itr implements Iterator<E> {

        int cursor = 0;
        int lastRet = -1;
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size();
        }

        public E next() {
            checkForComodification();
            try {
                int i = cursor;
                E next = get(i);
                lastRet = i;
                cursor = i + 1;
                return next;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

소스 코드 를 통 해 우 리 는 iterator 세 함수 의 실현 체 제 를 더욱 뚜렷하게 볼 수 있 고 세심 한 독자 들 은 move () 방법 에서 expected ModCount = modCount 를 발견 할 수 있 습 니 다.이런 표현 식 이 있 습 니 다.이것 은 사실 list 의 빠 른 실패 메커니즘 이다.modcount 는 array list 에서 삭제 하면 값 을 변화 시 킬 수 있 습 니 다. expected Modcount 는 옮 겨 다 니 면서 유지 하 는 값 입 니 다. 이 두 가지 가 같 지 않 으 면 옮 겨 다 닐 때 쓰기 동작 이 나타 납 니 다.데이터 가 일치 하지 않 게 만 들 었 습 니 다.구체 적 으로 블 로그 [ConcurrentModificationException] [1] 를 볼 수 있 습 니 다.
교체 기 iterator 를 사용 하 는 장점 은 다음 과 같다. * *
패키지 용기 의 내부 구현 디 테 일 은 서로 다른 집합 에 대해 같은 스 트 리밍 방식 을 제공 하여 클 라 이언 트 의 방문 을 간소화 하고 용기 안의 데 이 터 를 가 져 올 수 있 습 니 다.
**
Iterable
인터페이스 정 의 는 다음 과 같다.

public interface Iterable<T> {

    /** * Returns an iterator over a set of elements of type T. * * @return an Iterator. */
    Iterator<T> iterator();
}

자바 SE5 는 Iterable 인 터 페 이 스 를 도 입 했 습 니 다. 이 인 터 페 이 스 는 Iterator 를 만 들 수 있 는 iterator () 방법 을 포함 하고 Iterable 인 터 페 이 스 는 foreach 에 의 해 시퀀스 에서 이동 합 니 다.따라서 Iterable 을 실현 하 는 모든 사용자 정의 클래스 를 만 들 었 습 니 다. foreach 구문 에 사용 할 수 있 습 니 다.
Iterable 의 주요 역할 은 Iterable 인 터 페 이 스 를 실현 하여 foreach 가 옮 겨 다 니 는 사용자 정의 클래스 를 실현 하 는 것 입 니 다.
간단 한 예 를 보 자.

package com.andieguo.iterabledemo;

import java.util.Iterator;

public class IterablerClass<T> implements Iterable<T>{
    private T[] array = null;

    public IterablerClass(T[] t){
        this.array = t ;
    }
    @Override
    public Iterator<T> iterator() {
        // TODO Auto-generated method stub
        return new Iterator<T>() {
            private Integer index = 0;
            @Override
            public boolean hasNext() {
                // TODO Auto-generated method stub
                return index<array.length;
            }

            @Override
            public T next() {
                // TODO Auto-generated method stub
                return array[index++];
            }

            @Override
            public void remove() {
                // TODO Auto-generated method stub
            }
        };
    }
public static void main(String[] args) {
IterablerClass<String> iterablerClass = new IterablerClass<String>(new String[]{"hello","world","today","happy","sorrow"});
    for(String s:iterablerClass){
            System.out.print(s+" ");
        }

    }
}

[1]http://www.blogjava.net/EvanLiu/archive/2008/08/31/224453.html