《 Head First Design Patterns 》 독서 노트 의 교체 기 모드

교체 기 모드: 취 합 대상 의 각 요 소 를 순서대로 방문 하여 내부 의 전 시 를 드 러 내지 않 습 니 다.
    취 합 대상 은 무엇 입 니까?사실은 집합 (Collection) 입 니 다. 한 무리의 대상 을 포함 합 니 다. 이 대상 의 데이터 저장 방식 은 목록, 배열, 해시 표 등 일 수 있 습 니 다. 이런 대상 에 대해 데이터 구조 가 다 르 기 때문에 옮 겨 다 니 는 방식 도 다 릅 니 다.
    교체 기 모드 를 언제 사용 하 는 지 볼 수 있 습 니 다. 아래 세 가지 유형 은 세 개의 서로 다른 데이터 형식 을 포함 합 니 다. 배열, 목록, 산 목록 입 니 다.
   

/**
 * @author dean
 *     ArrayList     
 */
public class ListTest 
{	
	private ArrayList<String> items = new ArrayList<String>();
	
	public ListTest()
	{
		items.add("1");
		items.add("2");
		items.add("3");
		items.add("4");
		items.add("5");
		items.add("6");
	}

	public ArrayList<String> getItems() {
		return items;
	}
}

/**
 * @author dean
 *     String     
 */
public class ArrayTest
{
	private String[] items = new String[6];
	
	public ArrayTest()
	{
		items[1] = "1";
		items[2] = "2";
		items[3] = "3";
		items[4] = "4";
		items[5] = "5";
		items[0] = "6";
	}

	public String[] getItems() {
		return items;
	}
}

/**
 * @author dean
 *     HashTable     
 */
public class HashTableTest 
{
	private Hashtable<String, String> items = new Hashtable<String, String>();
	
	public HashTableTest()
	{
		items.put("1", "1");
		items.put("2", "2");
		items.put("3", "3");
		items.put("4", "4");
		items.put("5", "5");
		items.put("6", "6");
	}

	public Hashtable<String, String> getItems() {
		return items;
	}
}

    이제 이 데 이 터 를 옮 겨 다 니 세 요:

public class IteratorTest {

	public static void main(String[] args) {
		ArrayTest arrayTest = new ArrayTest();
		//     
		iterateArray(arrayTest.getItems());
		
		ListTest listTest = new ListTest();
		//     
		iterateList(listTest.getItems());
		
		HashTableTest hashTableTest = new HashTableTest();
		//     
		iterateHashTable(hashTableTest.getItems());
	}

	private static void iterateArray(String[] arrays) {
		for (int i = 0; i < arrays.length; i++) {
			System.out.print(arrays[i]);
		}
		System.out.println();
	}

	private static void iterateList(ArrayList<String> arrays) {
		for (int i = 0; i < arrays.size(); i++) {
			System.out.print(arrays.get(i));
		}
		System.out.println();
	}

	private static void iterateHashTable(Hashtable<String, String> arrays) {
		Enumeration<String> array = arrays.keys();
		while (array.hasMoreElements()) {
			String key = (String) array.nextElement();
			System.out.println(key + "---" + arrays.get(key));
		}

		System.out.println();
	}
}

    모든 데이터 형식 은 옮 겨 다 니 는 방법 이 있어 야 합 니 다. 너무 피곤 합 니 다!이제 교체 기 모드 로 나 오 세 요. String 형식의 데이터 형식 부터 시작 합 니 다.   

/**
 * @author dean
 *              ,         ,   Iterator   
 */
public class ArrayTestIterator implements Iterator<String>
{

	private String[] items;
	private int position = 0;
	
	public ArrayTestIterator(String[] items)
	{
		this.items = items;
	}
	
	@Override
	public boolean hasNext() {
		if(position <= items.length-1 && items[position]!=null)
			return true;
		return false;
	}

	@Override
	public String next() {
		String item = items[position];
		position++;
		return item;
	}

	@Override
	public void remove() {
		throw new UnsupportedOperationException();
	}

}

    그리고 List 와 hashtable 형식의 데 이 터 는 모두 자신의 교체 기 가 있 기 때문에 우 리 는 다시 하지 않 습 니 다.
  

public class IteratorTest {

	public static void main(String[] args) {
		ArrayTest arrayTest = new ArrayTest();
		//     
//		iterateArray(arrayTest.getItems());
		//      
		iterator(new ArrayTestIterator(arrayTest.getItems()));
		
		ListTest listTest = new ListTest();
		//     
//		iterateList(listTest.getItems());
		//      
		iterator(listTest.getItems().iterator());
		
		HashTableTest hashTableTest = new HashTableTest();
		//     
//		iterateHashTable(hashTableTest.getItems());
		//      
		iterator(hashTableTest.getItems().values().iterator());
	}
	
	private static void iterator(Iterator<String> it)
	{
		System.out.println(it.getClass());
		while(it.hasNext())
		{
			System.out.print(it.next());
		}
		System.out.println();
	}
}

    모든 것 을 옮 겨 다 니 는 방법 iterator () 를 사용 합 니 다. 많이 쉬 워 졌 죠?