컬렉션 프레임워크 (Collection Framework) - 2 (list, Iterator...)

List

List는 순서가 있는 자료 구조이다. 순서가 있기 때문에 중복을 허용하며 차례대로 저장되는 성격이 배열과 유사하다. 

 

List 인터페이스는 그 자체에서 기능이 오버라이딩 되어 있지 않기 때문에 단독으로 사용할 수 없다. 그래서 그 하위 클래스인 Vector, ArrayList 등을 다운캐스팅하여 할당해줘야 사용이 가능하다. 이러한 특성 때문에 List 인터페이스의 하위 클래스는 대부분의 메소드가 비슷하다.   

 

Vector

자바의 자료구조 기능을 제공하는 클래스들 중 가장 기본적인 클래스로 배열과 비슷하지만, 배열과 달리 다른 종류의 데이터형을 가진 데이터 요소를 가질 수 있으며, 데이터가 가득차면 자동으로 저장 영역을 확장시키게 된다.

 

또한, 객체 레퍼런스를 저장하기 때문에 JDK 1.5 이전에는 자바 기본형 데이터를 저장할 수 없었으나 JDK 1.5 이후부터는 오토박싱/오토언박싱 기능이 지원되면서 기본 데이터형도 저장이 가능하다.

 

벡터 클래스의 기본구조는 시퀀스(Sequence) 데이터 구조에 기반하며 시퀀스 데이터 접근을 순차적인 인덱스 값에 대한 위치로 접근하게 된다. 따라서 자료구조의 양 끝단에서만 접근이 가능한 큐나 한쪽 끝네서만 접근이 가능한 스택과 다르게 시퀀스 개념의 인덱스 값을 이용하여 자료 구조의 임의의 지점에서 저장 및 접근이 가능하다.

 

벡터의 시퀀스 구조는 List 인터페이스를 통해 제공받고 있기 때문에 List 인터페이스의 모든 메소드를 사용할 수 있다.

 

Vector 주요 메서드

 

void addElement(E obj)

boolean add(E e)

import java.util.Vector;

public class TEST
{
	// 정적 문자열 배열 선언 및 초기화                                   
	private static final String[] colors                                 
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};              
	                                                                     
	                                                                     
	public static void main(String[] args)                               
	{                                                                    
		int i;                                                           
        
		// Vector(벡터) 자료구조 v 생성                                  
		// 배열과 가장 유사한 자료구조                                   
		Vector<Object> v = new Vector<Object>();                         
		                                                                 
		// v 라는 벡터 자료구조에 colors 배열에 담겨있는 데이터 담아내기                                                           
		for(i = 0; i < colors.length; ++i)	// 0 ~ 5                     
		{                                                                
			v.add(colors[i]);
			// v.addElement(colors[i]);
		}
		
		System.out.println(v);
		//--==>> [검정, 노랑, 초록, 파랑, 빨강, 연두]
	}
}

add() 와 addElement() 메서드는 벡터에 원소를 추가해주는 기능을 한다. add() 메서드에서는 작업 성공 여부를 boolean 형태로 반환해준다.

 

void add(int index, E element)

void insertElementAt(E obj, int index)

import java.util.Vector;

public class TEST
{
	// 정적 문자열 배열 선언 및 초기화                                   
	private static final String[] colors                                 
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};              
	                                                                     
	                                                                     
	public static void main(String[] args)                               
	{                                                                    
		int i;                                                           
	                                                                     
		// Vector(벡터) 자료구조 v 생성                                  
		// 배열과 가장 유사한 자료구조                                   
		Vector<Object> v = new Vector<Object>();                         
	    
		// v 라는 벡터 자료구조에 colors 배열에 담겨있는 데이터 담아내기                                                           
		for(i = 0; i < colors.length; ++i)	// 0 ~ 5                     
		{                                                                
			v.add(colors[i]);
			// v.addElement(colors[i]);
		}
	    
		// 데이터 (요소) 추가   
		v.add(2, "하양");
		//v.addElementAt("하양", 2);
		
		System.out.println(v);
		//--==>> [검정, 노랑, 하양, 초록, 파랑, 빨강, 연두]
	}
}

add() 와 addElementAt() 메서드는 벡터의 주어진 위치에 원소를 추가해주는 기능을 한다. 해당 위치를 포함에 나머지 뒤에 있던 요소들을 오른쪽으로 한칸 씩 이동한다.

 

void removeElementAt(int index)

E remove(int index)

import java.util.Vector;

public class TEST
{
	// 정적 문자열 배열 선언 및 초기화                                   
	private static final String[] colors                                 
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};              
	                                                                     
	                                                                     
	public static void main(String[] args)                               
	{                                                                    
		int i;                                                                                                             
	                                                                     
		// Vector(벡터) 자료구조 v 생성                                  
		// 배열과 가장 유사한 자료구조                                   
		Vector<Object> v = new Vector<Object>();                         
	    
		// v 라는 벡터 자료구조에 colors 배열에 담겨있는 데이터 담아내기                                                           
		for(i = 0; i < colors.length; ++i)	// 0 ~ 5                     
		{                                                                
			v.add(colors[i]);
			// v.addElement(colors[i]);
		}
	    
		v.removeElementAt(0);
		//v.remove(0);
		
		System.out.println(v);
		//--==>> [노랑, 하양, 초록, 파랑, 빨강, 연두]
	}
}

removeElementAt() 과 remove() 메서드는 주어진 위치의 원소를 제거한다. 제거 후 주어진 위치 다음 원소들부터 하나씩 왼쪽으로 이동한다. remove() 메서드는 지우는 위치에 저장되었던(이제 지울) 객체를 반환한다. 

 

boolean removeElement(Object obj)

boolean remove(Object obj)

import java.util.Vector;

public class TEST
{
	// 정적 문자열 배열 선언 및 초기화                                   
	private static final String[] colors                                 
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};              
	                                                                     
	                                                                     
	public static void main(String[] args)                               
	{                                                                    
		int i;                                                                                                             
	                                                                     
		// Vector(벡터) 자료구조 v 생성                                  
		// 배열과 가장 유사한 자료구조                                   
		Vector<Object> v = new Vector<Object>();                         
	    
		// v 라는 벡터 자료구조에 colors 배열에 담겨있는 데이터 담아내기                                                           
		for(i = 0; i < colors.length; ++i)	// 0 ~ 5                     
		{                                                                
			v.add(colors[i]);
			// v.addElement(colors[i]);
		}
	    
		v.removeElement("검정");
		//v.remove("검정");
		
		System.out.println(v);
		//--==>> [노랑, 하양, 초록, 파랑, 빨강, 연두]
	}
}

removeElement() 와 remove() 메서드는 원소를 제거하는 기능하는 것은 위에서 봤던 메서드와 같지만, 다른점은 위치가 아닌 제거할 원소값을 매개변수로 받는다. 역시 제거 후 주어진 위치 다음의 객체부터 하나씩 왼쪽으로 이동한다. 또한 삭제가 되었다면 true, 삭제가 되지 않았다면 false를 반환한다. 

 

void removeAllElement()

void clear()

import java.util.Vector;

public class TEST
{
	// 정적 문자열 배열 선언 및 초기화                                   
	private static final String[] colors                                 
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};              
	                                                                     
	                                                                     
	public static void main(String[] args)                               
	{                                                                    
		int i;                                                                                                                
	                                                                     
		// Vector(벡터) 자료구조 v 생성                                  
		// 배열과 가장 유사한 자료구조                                   
		Vector<Object> v = new Vector<Object>();                         
	    
		// v 라는 벡터 자료구조에 colors 배열에 담겨있는 데이터 담아내기                                                           
		for(i = 0; i < colors.length; ++i)	// 0 ~ 5                     
		{                                                                
			v.add(colors[i]);
			// v.addElement(colors[i]);
		}
	    
		v.removeAllElement();
		//v.clear();
		
		System.out.println(v.isEmpty());
		//--==>> true
		System.out.println(v);
		//--==>> []
	}
}

removeAllElement() 와 clear() 메서드는 벡터에 저장된 모든 원소를 제거하는 기능을 한다. 

 

void setElementAt(E obj, int index)

E set(int index, E element)

import java.util.Vector;

public class TEST
{
	// 정적 문자열 배열 선언 및 초기화                                   
	private static final String[] colors                                 
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};              
	                                                                     
	                                                                     
	public static void main(String[] args)                               
	{                                                                    
		int i;                                                                                                                 
	                                                                     
		// Vector(벡터) 자료구조 v 생성                                  
		// 배열과 가장 유사한 자료구조                                   
		Vector<Object> v = new Vector<Object>();                         
	    
		// v 라는 벡터 자료구조에 colors 배열에 담겨있는 데이터 담아내기                                                           
		for(i = 0; i < colors.length; ++i)	// 0 ~ 5                     
		{                                                                
			v.add(colors[i]);
			// v.addElement(colors[i]);
		}
	    
		v.setElementAt("보라", 1);
		//v.set(1, "보라");
		
		System.out.println(v);
		//--==>> [검정, 보라, 초록, 파랑, 빨강, 연두]
	}
}

setElementAt() 과 set() 메서드는 원하는 위치에 주어진 원소 값을 저장한다. 주어진 위치에 저장되어 있던 원소는 소멸한다. (-> 덮어쓰기 개념과 같음) set() 메서드는 이 소멸된 원소 값을 반환해준다.

 

E elementAt(int index)

E get(int index)

import java.util.Vector;

public class TEST
{
	// 정적 문자열 배열 선언 및 초기화                                   
	private static final String[] colors                                 
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};              
	                                                                     
	                                                                     
	public static void main(String[] args)                               
	{                                                                    
		int i;                                                           
                                                    
		// Vector(벡터) 자료구조 v 생성                                  
		// 배열과 가장 유사한 자료구조                                   
		Vector<Object> v = new Vector<Object>();                         
		                                                                 
		// v 라는 벡터 자료구조에 colors 배열에 담겨있는 데이터 담아내기                                                           
		for(i = 0; i < colors.length; ++i)	// 0 ~ 5                     
		{                                                                
			v.add(colors[i]);
			// v.addElement(colors[i]);
		}
		
		Object e = v.elementAt(0);
		System.out.println(e);
		//--==>>검정

		e = v.get(5);
		System.out.println(e);
		//--==>>연두
	}
}

elementAt() 과 get() 메서드는 주어진 위치에 저장된 원소를 반환한다. 

 

int indexOf(Object o)

int indexOf(Object o, int index)

import java.util.Vector;

public class TEST
{
	// 정적 문자열 배열 선언 및 초기화                                   
	private static final String[] colors                                 
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};              
	                                                                     
	                                                                     
	public static void main(String[] args)                               
	{                                                                    
		int i;                                                           
                                                    
		// Vector(벡터) 자료구조 v 생성                                  
		// 배열과 가장 유사한 자료구조                                   
		Vector<Object> v = new Vector<Object>();                         
		                                                                 
		// v 라는 벡터 자료구조에 colors 배열에 담겨있는 데이터 담아내기                                                           
		for(i = 0; i < colors.length; ++i)	// 0 ~ 5                     
		{                                                                
			v.add(colors[i]);
			// v.addElement(colors[i]);
		}
		
		int pos = v.indexOf("검정");
		System.out.println(pos);
		//--==>> 0
		
		pos = v.indexOf("하양");
		System.out.println(pos);
		//--==>> -1
		}
}

indexof() 메서드는 벡터에 주어진 원소가 저장된 위치를 반환한다. 만약 원소가 벡터에 존재하지 않는 경우에는 음수 값을 반환한다. 매개변수로 index 를 추가로 받게되면 해당 index 위치부터 시작하여 원소가 저장된 위치를 찾아 반환한다.

 

boolean contains(Object o)

import java.util.Vector;

public class TEST
{
	// 정적 문자열 배열 선언 및 초기화                                   
	private static final String[] colors                                 
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};              
	                                                                     
	                                                                     
	public static void main(String[] args)                               
	{                                                                    
		int i;                                                           
                                                    
		// Vector(벡터) 자료구조 v 생성                                  
		// 배열과 가장 유사한 자료구조                                   
		Vector<Object> v = new Vector<Object>();                         
		                                                                 
		// v 라는 벡터 자료구조에 colors 배열에 담겨있는 데이터 담아내기                                                           
		for(i = 0; i < colors.length; ++i)	// 0 ~ 5                     
		{                                                                
			v.add(colors[i]);
			// v.addElement(colors[i]);
		}
		
		System.out.println(v.contains("검정"));
		//--==>> true

		System.out.println(v.contains("하양"));
		//--==>> false
	}
}

contains() 메서드는 벡터가 주어진 원소를 포함하고 있는지의 여부를 반환한다.

 

void ensureCapacity(int minCapacity)

ensureCapacity() 메서드는 벡터의 용량을 주어진 크기보다 크도록 조절한다.

 

E firstElement()

E lastElement()

import java.util.Vector;

public class TEST
{
	// 정적 문자열 배열 선언 및 초기화                                   
	private static final String[] colors                                 
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};              
	                                                                     
	                                                                     
	public static void main(String[] args)                               
	{                                                                    
		int i;                                                           
                                                    
		// Vector(벡터) 자료구조 v 생성                                  
		// 배열과 가장 유사한 자료구조                                   
		Vector<Object> v = new Vector<Object>();                         
		                                                                 
		// v 라는 벡터 자료구조에 colors 배열에 담겨있는 데이터 담아내기                                                           
		for(i = 0; i < colors.length; ++i)	// 0 ~ 5                     
		{                                                                
			v.add(colors[i]);
			// v.addElement(colors[i]);
		}
		
		System.out.println(v.firstElement());
		//--==>> 검정
		
		System.out.println(v.lastElement());
		//--==>> 연두
		}
}

firstElement() 와 lastElement() 메서드는 벡터의 양 끝에 원소 값을 반환한다. firstElement()는 맨 앞 원소, lastElement()는 맨 뒤 원소를 반환한다.

 

void setSize(int newSize)

setSize() 메서드는 벡터의 크기를 조절한다. 만약 주어진 크기가 현재 크기보다 작다면 나머지는 버린다. 반대로 주어진 크기가 현재 크기보다 크다면 빈 공간은 null 객체로 채워진다. (객체를 참조하지 않음을 의미) 

 

int capacity()

capacity() 메서드는 현재 벡터의 용량을 반환한다.

 

int size()

size() 메서드는 현재 벡터에 저장된 객체의 갯수(size)를 반환한다.

 

int trimToSize()

trimToSize() 메서드는 벡터의 용량을 저장된 객체의 갯수에 맞도록 최소화한다.

 

Enumeration, Iterator 인터페이스

Collection Framework에는 Enumeration과 Iterator라는 인터페이스가 있다. 사전적인 의미로는 반복, 순환이라는 의미를 가지고 있으며 어떤 객체들의 모임이 있을때, 이 객체들을 어떤 순서에 의해 하나씩 접근하여 사용하기 위한 인터페이스라고 할 수 있다. 

 

java.util.Enumeration<E> 인터페이스

이 인터페이스는 단지 두 개의 메소드만을 제공하며 hasMoreElements() 메소드를 통해 인터페이스 안에 다음 요소가 있는지에 대한 질의를 한다. 만약 true가 반환되었다면 다음 인덱스에 요소가 존재한다는 의미이며 nextElement() 메소드로 다음 요소를 꺼내어 사용하면 된다.

// Enumeration을 사용하여 v 벡터 자료구조에 저장된 모든 요소 출력
for(Enumeration e = v.elements(); e.hasMoreElements(); )
{
    System.out.println(e.nextElement());
}

 

java.util.Iterator<E> 인터페이스

Iterator<E>가 Enumeration과 가지는 차이점은 단지 remove() 메소드가 추가된 것 뿐이다. Iterator가 가지고 있는 hasNext()와 next() 메소드는 이름만 다를 뿐 기능적인 면에서 Enumeration 인터페이스에 hasMoreElements()와 nextElement() 메소드와 정확히 일치한다. 

 

JDK 1.2부터 Enumeration 대신 Iterator를 추가하여 사용하게 된 이유는 Enumeration 인터페이스 집합 내에서 요소를 제거할 방법이 없기 때문에 이를 보완하기 위한 것이다.

// Iterator를 사용하여 v 벡터 자료구조에 저장된 모든 요소 출력
for(Iterator it = v.iterator(); it.hasNext(); )
{
    System.out.println(it.next());
}

Iterator 인터페이스 외에 ListIterator 인터페이스도 존재하는데, 이 인터페이스에 hasPrevious()와 previous() 메소드를 사용하면 역순 출력을 쉽게 구현할 수 있다.  

// 리스트 역순 출력
ListIterator<String> li = list.listIterator();
while(li.hasPrevious())
{
    System.out.println(li.previous());
}

 

ArrayList

ArrayList는 Vector과 같이 List를 크기 변경이 가능한 배열로 구현한 것으로 Vector와의 차이점은 객체가 비동기 컬렉션이라는 점이다. 비동기화 컬렉션은 동기화된 컬렉션보다 더 나은 성능을 제공한다. 때문에 스레드들이 컬렉션을 공유하지 않는 프로그램에서는 일반적으로 ArrayList를 Vector보다 더 선호한다. ArrayList는 동기화를 고려하지 않기 때문에 스레드 동기화에 따르는 부담을 가지지 않아 Vector보다 빠르다.

 

기본적으로 null을 포함한 모든 요소를 허용하며, List 인터페이스를 구현하는 것 외에 리스트를 격납하기 위해 내부적으로 사용되는 배열의 사이즈를 조작하는 메소드를 제공한다. (ArrayList 메소드는 기본적으로 Vector 메소드와 거의 비슷하다)

 

배열과 리스트의 형변환

기본적으로 List 인터페이스와 Arrays 클래스는 상호간의 형변환을 제공한다. 리스트에서 배열로 형변환 하고 싶을 때는 List의 toArray() 메소드를 사용하면 되고, 반대로 배열에서 리스트로 형변환을 하고 싶을 때는 Arrays의 asList() 메소드를 사용하면 된다. 

List<String> mList = new ArrayList<String>();

// add를 이용해 리스트에 데이터를 담는 작업...

// 리스트 -> 배열 형변환
String[] sArrays = mList.toArray(new String[mList.size()]);

// 배열 -> 리스트 형변환
List<String> mNewList = Arrays.asList(sArrays);