JAVA 교체 기와 교체 모드

jdk 에서 교체 기 와 관련 된 인 터 페 이 스 는 두 가지 가 있 습 니 다: Iterator 와 Iterable
Iterator: 교체 기, Iterator 와 그 하위 클래스 는 일반적으로 교체 기 자체 의 구조 와 방법 이다.
Iterable: 교체 가능, 교체 기 기능 을 사용 하고 싶 은 다른 종류, 예 를 들 어 AbstractList HashMap 등 은 이 인 터 페 이 스 를 실현 해 야 합 니 다.
다음은 두 개의 인터페이스 소스 코드 입 니 다.
Iterator 는 다음 과 같 습 니 다:

 
1.public interface Iterator<E> {  
2.    boolean hasNext();  
3.    E next();  
4.    void remove();  
5.}  

Iterable 는 다음 과 같 습 니 다:

1.public interface Iterable<T> {  
2.    Iterator<T> iterator();  
3.}  

원본 코드 를 보고 교체 기 를 어떻게 사용 하 는 지 봅 시다.
1. 클래스 A 가 교체 기 를 사용 하려 면 클래스 성명 부분 은 class A implement Iterable 입 니 다.
2. 클래스 A 구현 에서 Iterable 인터페이스 에서 유일한 방법: Iterator < T > iterator ();
   이 방법 은 Iterator 인터페이스 와 하위 클래스 를 되 돌려 주 는 데 사 용 됩 니 다.
3. 클래스 A 에서 내부 클래스 S 를 정의 하고 Iterator 인 터 페 이 스 를 실현 하 며 맞 춤 형 클래스 A 자체 의 교체 기 를 실현 합 니 다.
다음 과 같다.

1.class A implement Iterable  
2.{  
3.    Iterator<T> iterator() {...}  
4.    class S implement Iterator<E>   
5.    {  
6.        boolean hasNext() {....}  
7.        E next() {....}  
8.        void remove() {....}  
9.    }  
10.}  

추상 적 인 AbstractList 와 같은 jdk 에서 어떻게 사용 하 는 지 다시 한 번 살 펴 보 겠 습 니 다.

1.public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> { // List     Collection<E>, Iterable<E> 
2.  
3.    protected AbstractList() {  
4.    }  
5.    
6.    ...  
7.  
8.    public Iterator<E> iterator() {  
9.    return new Itr();  //          
10.    }  
11.  
12.    private class Itr implements Iterator<E> {  //    Itr     
13.       
14.    int cursor = 0;  
15.    int lastRet = -1;  
16.    int expectedModCount = modCount;  
17.  
18.    public boolean hasNext() {  //   hasNext  
19.            return cursor != size();  
20.    }  
21.  
22.    public E next() {  //   next  
23.            checkForComodification();  
24.        try {  
25.        E next = get(cursor);  
26.        lastRet = cursor++;  
27.        return next;  
28.        } catch (IndexOutOfBoundsException e) {  
29.        checkForComodification();  
30.        throw new NoSuchElementException();  
31.        }  
32.    }  
33.  
34.    public void remove() {  //   remove  
35.        if (lastRet == -1)  
36.        throw new IllegalStateException();  
37.            checkForComodification();  
38.  
39.        try {  
40.        AbstractList.this.remove(lastRet);  
41.        if (lastRet < cursor)  
42.            cursor--;  
43.        lastRet = -1;  
44.        expectedModCount = modCount;  
45.        } catch (IndexOutOfBoundsException e) {  
46.        throw new ConcurrentModificationException();  
47.        }  
48.    }  
49.  
50.    final void checkForComodification() {  
51.        if (modCount != expectedModCount)  
52.        throw new ConcurrentModificationException();  
53.    }  
54.    }  
55.}  

교체 기 를 보고 교체 기 모드 를 다시 봅 시다.
1. 질문: 교체 기 모드 가 무엇 입 니까?왜 교체 기 모드 가 있 습 니까?
   GOF 는 용기 (container) 대상 의 각 요소 에 접근 하 는 방법 을 제공 합 니 다.
                     이 대상 의 내부 세부 사항 을 폭로 해 야 한다.
    내 이해: 바로 스 트 리밍 알고리즘 을 용기 대상 에서 독립 시 키 는 것 이다. 왜 스 트 리밍 을 용기 대상 에서 독립 시 키 는 것 인가?
              나 오 네?대상 을 대상 으로 하 는 디자인 에서 어 려 운 점 은 대상 을 식별 하 는 직책 이기 때문이다.이상 적
              태 하 는 한 가지 유형 은 하나의 직책 만 있어 야 한다.직책 분 리 는 최대한 결합 할 수 있 지만
              직책 은 말 하기는 쉽 지만 실행 하기는 어렵다.구체 적 으로 본 모델 에 이 르 면 우 리 는 분명히 볼 수 있다.
              용기 대상 은 두 가지 직책 을 제공 합 니 다. 하 나 는 조직 관리 데이터 대상 이 고, 다른 하 나 는 스 트 리밍 알고리즘 을 제공 합 니 다.
    그래서 Iterator 모드 는 집합 대상 의 옮 겨 다 니 는 행 위 를 분리 하고 하나의 교체 기 류 를 추상 화하 여 책임 을 지 는 것 이다.
         집합 에 노출 되 지 않 는 내부 구 조 를 할 수 있 을 뿐만 아니 라 외부 코드 가 내부 의 데 이 터 를 투명 하 게 접근 할 수 있다.
2. 다음은 교체 기 모드 를 설명 합 니 다.
   교체 기 모드 는 다음 과 같은 캐릭터 로 구성 되 어 있 습 니 다.
1) 교체 기 역할 (Iterator): 교체 기 역할 은 접근 과 요 소 를 옮 겨 다 니 는 인 터 페 이 스 를 정의 합 니 다.
2) 구체 적 인 교체 기 역할 (Concrete Iterator): 구체 적 인 교체 기 역할 은 교체 기 인 터 페 이 스 를 실현 하고
        현재 위 치 를 기록 해 야 합 니 다.
    3) 용기 역할 (Container): 용기 역할 은 구체 적 인 교체 기 역할 을 만 드 는 인 터 페 이 스 를 제공 합 니 다.
4) 구체 적 인 용기 역할 (Concrete Container): 구체 적 인 용기 역할 구현 구체 적 인 교체 기 역할 생 성
        이 구체 적 인 교체 기 는 용기 의 구조 와 관련 이 있다.
    교체 기 모드 의 유 도 는 다음 과 같다.