Bibliothek

○ Enumeration 과 Iterator 인터페이스

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

  - java,util,Enumeration<E> 인터페이스
    : 이 인터페이스는 단지 두 개의 메소드만을 제공하며 『hasMoreElements()』메소드로 다음 요소를 꺼내어 사용하 되는 것이다.

   ex) v 라는 벡터 자료구조에 저장된 모든 요소 출력

for(Enumeration e = v.elements(); e.hasMoreElements(); ) 
{ 
	System,out,println(e,nextElement()); 
} 

   - java,util,Iterator<E> 인터페이스
     : Enumeration 과의 차이점은 단지 『remove()』 메소드가 추가된 것 뿐이다. Iterator 가 가지고 있는 『hasNext()』 와      『next()』 메소드는 이름만 약간 다를 뿐 Enumeration 인터페이스가 가지고 있는 『hasMoreElements()』 와 『nextElement()』와  정확히 일치하는 기능을 수행한다.
  

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

import java.util.Vector;
import java.util.Enumeration;
import java.util.Iterator;

public class Test169
{
	public static void main(String[] args)
	{
		// 벡터 자료구조 인스턴스 생성
		Vector<String> v = new Vector<String>();

		// 벡터 자료구조 v 에 요소 추가
		v.add("Java");
		v.add("Oracle");
		v.add("Jsp");
		v.add("Servlet");
		v.add("Spring");

		// ① Enumeration
		//	  - hasMoreElements()
		//    - nextElement()
		Enumeration<String> e = v.elements();
		while (e.hasMoreElements())	// true / false
		{
			System.out.println(e.nextElement());
		}
		System.out.println();
		//--==>> Java
		//	 Oracle
		//	 Jsp
		//	 Servlet
		//	 Spring

		System.out.println("----------------------------");

		// ② Iterator
		//    - hasNext()
		//    - next()
		Iterator<String> it = v.iterator();
		while (it.hasNext())	// true / false
		{
			System.out.println(it.next());
		}
		System.out.println();
		//--==>> Java
		//	 Oracle
		//	 Jsp
		//	 Servlet
		//	 Spring
	}
}

벡터 연습

※ 다음 주어진 Menus 클래스를 참고하여 Test168클래스를 완성하여 실행 예의 기능을 가진 프로그램을 구현한다.

class Menus	// → 완성
{
	public static final int E_ADD = 1;		//-- 요소 추가
	public static final int E_DISP = 2;		//-- 요소 출력
	public static final int E_FIND = 3;		//-- 요소 검색
	public static final int E_DEL = 4;		//-- 요소 삭제
	public static final int E_CHA = 5;		//-- 요소 변경
	public static final int E_EXIT = 6;		//-- 종료
}

실행 예)
[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 1

1번째 요소 입력 : 허수민
1번째 요소 입력 성공~!!!
요소 입력 계속(Y/N)? : y

2번째 요소 입력 : 진영은
2번째 요소 입력 성공~!!!
요소 입력 계속(Y/N)? : N

[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 2

[벡터 전체 출력]
허수민
진영은
벡터 전체 출력 완료~!!!

[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 3

검색할 요소 입력 : 진영은

[검색 결과 출력]
항목이 존재합니다.

[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 3

검색할 요소 입력 : 주재완

[검색 결과 출력]
항목이 존재하지 않습니다.

[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 4

삭제할 요소 입력 : 조인경

[삭제 결과 출력]
항목이 존재하지 않아 삭제할 수 없습니다.

[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 4

삭제할 요소 입력 : 허수민

[삭제 결과 출력]
허수민 항목이 삭제되었습니다.

[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 5

변경할 요소 입력 : 조윤상

[변경 결과 출력]
변경할 대상이 존재하지 않습니다.

[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 5

변경할 요소 입력 : 진영은
수정할 내용 입력 : 조영욱

[변경 결과 출력]
변경이 완료되었습니다.

[메뉴 선택]
1. 요소 추가
2. 요소 출력
3. 요소 검색
4. 요소 삭제
5. 요소 변경
6. 종료
>> 메뉴 선택(1~6) : 6

프로그램 종료
계속하려면 아무 키나 누르세요...

import java.util.Vector;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Enumeration;

class Menus	// → 완성
{
	public static final int E_ADD = 1;		//-- 요소 추가
	public static final int E_DISP = 2;		//-- 요소 출력
	public static final int E_FIND = 3;		//-- 요소 검색
	public static final int E_DEL = 4;		//-- 요소 삭제
	public static final int E_CHA = 5;		//-- 요소 변경
	public static final int E_EXIT = 6;		//-- 종료
}

public class Test168
{
	// 주요 속성 구성	→ 완성
	private static final Vector<Object> vt;
	private static BufferedReader br;
	private static Integer sel;			//-- 선택값
	private static String con;			//-- 계속 여부

	// static 초기화 블럭
	static
	{
		// Vector 자료구조 생성
		vt = new Vector<Object>();

		// BufferedReader 클래스 인스턴스 생성
		br = new BufferedReader(new InputStreamReader(System.in));

		// 사용자 입력값 초기화
		sel = 1;
		con = "Y";
	}

	// 메뉴 출력 메소드
	public static void menuDisp()
	{
		// 사용자에게 안내하기 위한 메세지만을 출력하는 기능
		// 메뉴를 선택하는 기능의 메소드를 별도로 정의했기 때문에
		// 이 과정에서는 사용자의 선택값을 받아오지 않아도 무방함.

		System.out.printf("\n\n\t[메뉴 선택]\n");
		System.out.printf("\t1.요소 추가\n");
		System.out.printf("\t2.요소 출력\n");
		System.out.printf("\t3.요소 검색\n");
		System.out.printf("\t4.요소 삭제\n");
		System.out.printf("\t5.요소 변경\n");
		System.out.printf("\t6.종료\n");
		System.out.printf("\n\t>> 메뉴 선택(1~6) : ");
	}

	// 메뉴 선택 메소드
	public static void menuSelect() throws IOException
	{
		// 선택한 메뉴에 따른 기능 분기는
		// menuRun() 에서 처리하기 때문에 입력값을
		// 받아오는 기능만 정의
		sel = Integer.parseInt(br.readLine());
	}

	// 선택된 메뉴 실행에 따른 기능 호출 메소드
	public static void menuRun() throws IOException
	{
		// Menus 클래스를 활용하여 처리
		switch(sel)
		{
			case Menus.E_ADD : addElement(); break;	//ok
			case Menus.E_DISP : dispElement(); break;	//ok
			case Menus.E_FIND : findElement(); break;	//ok
			case Menus.E_DEL : delElement(); break;
			case Menus.E_CHA : chaElement(); break;
			case Menus.E_EXIT : exit(); break;			//ok
			default : 
			{
				System.out.println("\t선택한 메뉴가 존재하지 않습니다.");
				menuSelect();
			} break;
		}
	}

	// 요소 추가(입력) 메소드
	public static void addElement() throws IOException
	{
/*
		do
		{
			System.out.printf("\n\t%d 번째 요소 입력 : ", vt.size() + 1);
			String element = br.readLine();
			boolean b = vt.add(element);
			if (b)
			{
				System.out.printf("\t%d 번째 요소 입력 성공 !!! ", vt.size());
				con = br.readLine().toUpperCase();
			}
		}
		while (con.equals("Y"));

*/
		do
		{
			System.out.print("\n\t"+(vt.size()+1) +"번째 요소 입력 : ");
			String str = br.readLine();
			System.out.printf("\n\t%d 번째 요소 입력 성공 !!! \n", vt.size()+1);
			vt.addElement(str);
			// 추가 입력 유무 처리
			System.out.print("\t요소 입력 계속(Y/N)? : ");
			con = br.readLine().toUpperCase();
		}
		while (con.equals("Y"));
	}

	// 요소 출력 메소드
	public static void dispElement()
	{
		System.out.printf("\n\t[벡터 전체 출력]\n");
		for (Enumeration e = vt.elements(); e.hasMoreElements() ;)
		{
			System.out.printf("\t%10s \n", e.nextElement());
		}
		System.out.printf("\t벡터 전체 출력 완료~!!!\n");
		/*
		System.out.println("\n[벡터 전체 출력]");
		for (int i = 0; i < vt.size(); i++)
			System.out.println(vt.elementAt(i));
		System.out.println("벡터 전체 출력 완료~!!!");
		*/
	}

	// 요소 검색 메소드
	public static void findElement() throws IOException
	{
		System.out.print("\n\t검색할 요소 입력 : ");
		String str = br.readLine();

		System.out.println("\n\t[검색 결과 출력]");
		if (vt.contains(str))
			System.out.println("\t항목이 존재합니다.");
		else
			System.out.println("\t항목이 존재하지 않습니다.");
	}

	// 요소 삭제 메소드
	public static void delElement() throws IOException
	{
		System.out.print("\n\t삭제할 요소 입력 : ");
		String str = br.readLine();
		int idx = vt.indexOf(str);
		System.out.println("\n\t[삭제 결과 출력]");
		if(idx > -1)
		{
			vt.removeElementAt(idx);
			System.out.println("\t" + str + " 항목이 삭제되었습니다.");
		}
		else
			System.out.println("\t항목이 존재하지 않아 삭제할 수 없습니다.");
	}

	// 요소 수정(변경) 메소드
	public static void chaElement() throws IOException
	{
		System.out.print("\n\t변경할 요소 입력 : ");
		String str = br.readLine();
		int idx = vt.indexOf(str);

		if (idx>-1)
		{
			System.out.print("\t수정할 내용 입력 : ");
			String str2 = br.readLine();
			vt.setElementAt(str2,idx);
			System.out.println("\n\t[변경 결과 출력]");
			System.out.println("\t변경이 완료되었습니다.");

		}
		else
		{
			System.out.println("\n\t[변경 결과 출력]");
			System.out.println("\t변경할 대상이 존재하지 않습니다.");
		}


	}

	// 프로그램 종료 메소드 → 완성
	public static void exit()
	{
		System.out.println("\n\t프로그램 종료~!!!");
		System.exit(-1);
	}
	
	// main() 메소드 → 완성
	public static void main(String[] args) throws IOException
	{
		do
		{
			menuDisp();
			menuSelect();
			menuRun();
		}
		while (true);
	}
}

실행 결과

// 실행 결과
/*
[메뉴 선택] 
1. 요소 추가 
2. 요소 출력 
3. 요소 검색 
4. 요소 삭제 
5. 요소 변경 
6. 종료 
>> 메뉴 선택(1~6) : 1 

1번째 요소 입력 : 허수민 
1번째 요소 입력 성공~!!! 
요소 입력 계속(Y/N)? : y 

2번째 요소 입력 : 진영은 
2번째 요소 입력 성공~!!! 
요소 입력 계속(Y/N)? : N 

[메뉴 선택] 
1. 요소 추가 
2. 요소 출력 
3. 요소 검색 
4. 요소 삭제 
5. 요소 변경 
6. 종료 
>> 메뉴 선택(1~6) : 2 

[벡터 전체 출력] 
허수민 
진영은 
벡터 전체 출력 완료~!!! 

[메뉴 선택] 
1. 요소 추가 
2. 요소 출력 
3. 요소 검색 
4. 요소 삭제 
5. 요소 변경 
6. 종료 
>> 메뉴 선택(1~6) : 3 

검색할 요소 입력 : 진영은 

[검색 결과 출력] 
항목이 존재합니다. 

[메뉴 선택] 
1. 요소 추가 
2. 요소 출력 
3. 요소 검색 
4. 요소 삭제 
5. 요소 변경 
6. 종료 
>> 메뉴 선택(1~6) : 3 

검색할 요소 입력 : 주재완 

[검색 결과 출력] 
항목이 존재하지 않습니다. 

[메뉴 선택] 
1. 요소 추가 
2. 요소 출력 
3. 요소 검색 
4. 요소 삭제 
5. 요소 변경 
6. 종료 
>> 메뉴 선택(1~6) : 4 

삭제할 요소 입력 : 조인경 

[삭제 결과 출력] 
항목이 존재하지 않아 삭제할 수 없습니다. 

[메뉴 선택] 
1. 요소 추가 
2. 요소 출력 
3. 요소 검색 
4. 요소 삭제 
5. 요소 변경 
6. 종료 
>> 메뉴 선택(1~6) : 4 

삭제할 요소 입력 : 허수민 

[삭제 결과 출력] 
허수민 항목이 삭제되었습니다. 

[메뉴 선택] 
1. 요소 추가 
2. 요소 출력 
3. 요소 검색 
4. 요소 삭제 
5. 요소 변경 
6. 종료 
>> 메뉴 선택(1~6) : 5 

변경할 요소 입력 : 조윤상 

[변경 결과 출력] 
변경할 대상이 존재하지 않습니다. 

[메뉴 선택] 
1. 요소 추가 
2. 요소 출력 
3. 요소 검색 
4. 요소 삭제 
5. 요소 변경 
6. 종료 
>> 메뉴 선택(1~6) : 5 

변경할 요소 입력 : 진영은 
수정할 내용 입력 : 조영욱 

[변경 결과 출력] 
변경이 완료되었습니다. 

[메뉴 선택] 
1. 요소 추가 
2. 요소 출력 
3. 요소 검색 
4. 요소 삭제 
5. 요소 변경 
6. 종료 
>> 메뉴 선택(1~6) : 6 

프로그램 종료 
계속하려면 아무 키나 누르세요...
*/

○ Vector(벡터)

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

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

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

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

○ 주요 메소드

  - void add(int index, E element)
  - void insertElement(E Obj, int index)
    주어진 위치에 객체를 저장한다.

    주어진 위치의 객체부터 오른쪽으로 하나씩 이동한다.

  - void addElement(E obj)
  - boolean add(E e)
    객체를 벡터 끝에 추가한다.

  - void removeElementAt(int index)
  - E remove(int index)
    주어진 위치의 객체를 제거한다.

    제거 후 주어진 위치 다음의 객체부터 하나씩 왼쪽으로 이동한다.
    E remove(int index) 메소드는 저장 되었던 객체를 반환한다.

  - boolean removeElement(Object obj)
  - boolean remove(Object obj)
    대상 객체를 제거한다.
    제거 후 주어진 위치 다음의 객체부터 하나씩 왼쪽으로 이동한다.
    객체가 정상적으로 제거되었으면 true 를 반환한다. 
  
  - void removeAllElement()
  - void clear()
    벡터의 모든 요소를 제거한다.

  - void setElementAt(E obj, int index)
  - E set(int index, E element)
    벡터의 index 위치에 주어진 객체를 저장한다.
    주어진 위치에 저장되어 있던 객체는 소멸한다. (→ 덮어쓰기의 개념)

  - E elementAt(int index)
  - E get(int index)
    주어진 위치에 저장된 객체를 반환한다.

  - Enumeration<E> elements()
    벡터의 모든 요소를 반환한다.

  - int indexOf(Object o)
    주어진 객체가 저장된 위치를 반환한다.
    존재하지 않을 경우 『음수』를 반환한다.

  - int indexOf(Object o, int index)
    주어진 객체가 저장된 위치를 index 위치부터 찾아서 반환한다.
    index 위치는 스캔을 시작하는 위치.

  - boolean contains(Object o)
    벡터가 주어진 객체를 포함하고 있는지의 여부를 반환한다.

  - void ensureCapacity(int minCapacity)
    벡터의 용량을 주어진 크기보다 크도록 조절한다.

  - E firsrElement()
    벡터의 첫 번째 요소의 데이터를 반환한다.

  - E lastElement()
    벡터의 마지막 요소의 데이터를 반환한다.

  - void setSize(int newSize)
    벡터의 크기를 조절한다.
    만약 주어진 크기가 현재 크기보다 작다면 나머지는 버린다.
    반대로 주어진 크기가 현재 크기보다 크다면
    빈 공간을 null 객체로 채우게 된다.
    (객체를 참조하지 않음을 의미)
  
  - int capacity()
    현재 벡터의 용량을 반환한다.

  - int size()
    현재 벡터에 저장된 객체의 갯수(size)를 반환한다.

  - int trimSize()
    벡터의 용량을 저장된 객체의 갯수에 맞도록 최소화한다.

벡터 자료구조에 요소 추가 및 요소 출력

import java.util.Vector;
import java.util.Iterator;

public class Test163
{
	// 정적 문자열 배열 선언 및 초기화
	private static final String[] colors
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};
	
	public static void main(String[] args)
	{
		int i;
		String str;

		// Vector(벡터) 자료구조 v 생성
		Vector<Object> v = new Vector<Object>();

		// v 라는 벡터 자료구조에 colors 배열에 담겨있는 데이터 담아내기
		// add()
		for (i=0; i<colors.length; i++)
		{
			v.add(colors[i]);	// v.add("검정");
								// v.add("노랑");
								//     :
								// v.add("연두");
		}

		// 요소 추가
		v.addElement("하양");

		// firstElement()
		str = (String)v.firstElement();
		System.out.println("첫 번째 요소 : " + str);
		//--==>> 첫 번째 요소 : 검정

		// get()
		str = (String)v.get(1);
		System.out.println("두 번째 요소 : " + str);
		//--==>> 두 번째 요소 : 노랑

		// get()
		str = (String)v.get(0);
		System.out.println("첫 번째 요소 : " + str);
		//--==>> 첫 번째 요소 : 검정

		// elementAt()
		str = (String)v.elementAt(1);
		System.out.println("두 번째 요소 : " + str);
		//--==>> 첫 번째 요소 : 노랑

		// lastElement()
		str = (String)v.lastElement();
		System.out.println("마지막 요소 : " + str);
		//--==>> 마지막 요소 : 연두
		
		// 데이터 추가후
		//--==>> 마지막 요소 : 하양

		// get()
		str = (String)v.get(5);
		System.out.println("마지막 요소 : " + str);
		//--==>> 마지막 요소 : 연두
	
		// 데이터 추가후
		//--==>> 마지막 요소 : 연두

		// elementAt()
		str = (String)v.elementAt(5);
		System.out.println("마지막 요소 : " + str);
		//--==>> 마지막 요소 : 연두

		// 데이터 추가후
		//--==>> 마지막 요소 : 연두

		// ※ 벡터 자료구조에서 요소 추가 시(→ add() / addElement())
		//   인덱스 마지막(가장 끝)의 위치에 추가되는 것을 확인할 수 있다.

		// 전체 요소 출력
		// 『Iterator(이터레이터 or 아이터레이터)』 를 통해 전체 출력
		// 『hasNext()』: 다음 데이터 요소가 있는지의 여부 반환
		// 『next()』   : 다음 데이터 요소를 직접적으로 반환

		Iterator<Object> it = v.iterator();

		// "검정", "노랑", "초록", "파랑", "빨강", "연두", "하양"

		while(it.hasNext())
		{
			str = (String)it.next();
			System.out.print(str + " ");
		}
		System.out.println();
		//--==>> 검정 노랑 초록 파랑 빨강 연두 하양


	}
}

 Vector v = new Vector();
 -- 비어있는 Vector 자료구조 생성

 Vector v = new Vector(8)
 -- 8개의 초기 element를 가진 Vector 자료구조 생성
    8개가 모두 채워지게 되면(모자라게 되면) 자동으로 확장된다.

 Vector v = new Vector(3, 5);
 -- 3개의 초기 elements 를 가진 Vector 자료구조 생성
    3개가 모두 채워지게 되면(모자라게 되면) 자동으로 5개 증가(확장)하게 된다.

 ※ 벡터는 데이터 요소로서 정수형, 실수형, 문자열... 등을
    담아내는 것이 가능하다.
    → 데이터 안정성 확보 check~!!!

import java.util.Vector;
import java.util.Iterator;

// MyVector 클래스 설계 → Vector 클래스 상속
class MyVector extends Vector<Object>
{
	// 생성자
	MyVector()
	{
		// Vector(슈퍼 클래스) 생성자 호출
		super(1,1);		// Vector(1, 1);
		//-- 첫 번째 인자 : 주어진 용량
		//   두 번째 인자 : 증가량
	}

	void addInt(int i)
	{
		addElement(new Integer(i));
	}

	void addFloat(float f)
	{
		addElement(new Float(f));
	}

	void addString(String s)
	{
		addElement(new String(s));
	}

	void addCharArray(char[] a)
	{
		addElement(a);
	}

	void write()
	{
		Object o;
		int length = size();

		System.out.println("벡터 요소 갯수 : " + length);

		for (int i = 0; i < length; i++)
		{
			o = elementAt(i);

			if (o instanceof char[])
			{
				//System.out.println("문자 배열 : " + o);
				//System.out.println("문자 배열 : " + o.toString());
				System.out.println("문자 배열 : " + String.copyValueOf((char[])o));
			}
			else if (o instanceof String)
			{
				System.out.println("문자열 : " + o);				
			}

			else if (o instanceof Integer)
			{
				System.out.println("정수형 : " + o);
			}

			else if (o instanceof Float)
			{
				System.out.println("실수형 : " + o);
			}
			else
			{
				System.out.println("타입 확인 불가~!!!");				
			}

		}


		//Iterator<Object> it = this.iterator();
		//while (it.hasNext())
		//{
		//	System.out.println(it.next());
		//}
	}

}

public class Test164
{
	public static void main(String[] args)
	{
		// MyVector 클래스 기반 인스턴스 생성
		MyVector v = new MyVector();

		// 주요 변수 선언 및 초기화
		int digit = 5;
		float real = 3.14f;
		String s = new String("안녕하세요");
		char[] letters = {'s', 't', 'u', 'd', 'y'};

		// 벡터 자료구조 v 에 요소 추가
		v.addInt(digit);		//-- 벡터 자료구조에 정수 저장
		v.addFloat(real);		//-- 벡터 자료구조에 실수 저장
		v.addString(s);			//-- 벡터 자료구조에 문자열 저장
		v.addCharArray(letters);//-- 벡터 자료구조에 문자 배열 저장

		v.write();
		//--==>>
		/*
		벡터 요소 갯수 : 4
		정수형 : 5
		실수형 : 3.14
		문자열 : 안녕하세요
		문자 배열 : study
		*/
	}
}

벡터 자료구조에 요소 추가 후 Collections 클래스를 이용한 정렬

import java.util.Vector;
import java.util.Collections;

public class Test165
{
	// 정적 문자열 배열 선언 및 초기화
	private static final String[] colors
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};
	

	public static void main(String[] args)
	{
		// 벡터 자료구조 생성
		Vector<String> v = new Vector<String>();

		// 벡터 자료구조 v 에 colors 데이터를 요소로 추가
		for (String color : colors)
			v.add(color);

		System.out.println("첫 번째 요소 : " + v.firstElement());
		System.out.println("두 번째 요소 : " + v.get(1));
		System.out.println("마지막 요소 : " + v.lastElement());
		System.out.println("요소의 갯수 : " + v.size());
		//--==>> 첫 번째 요소 : 검정
		//		 두 번째 요소 : 노랑
		//		 마지막 요소 : 연두
		//		 요소의 갯수 : 6

		// ○ 첫 번째 요소를 "하양" 으로 변.경. → set()
		v.set(0, "하양");

		System.out.println("첫 번째 요소 : " + v.firstElement());
		//--==>> 첫 번째 요소 : 하양
		System.out.println("두 번째 요소 : " + v.get(1));
		//--==>> 두 번째 요소 : 노랑
		System.out.println("요소의 갯수 : " + v.size());
		//		 요소의 갯수 : 6

		// ○ 첫 번째 요소에 "주황" 추.가		→ insertElementAt()
		v.insertElementAt("주황", 0);

		System.out.println("첫 번째 요소 : " + v.firstElement());
		//--==>> 첫 번째 요소 : 주황
		System.out.println("두 번째 요소 : " + v.get(1));
		//--==>> 두 번째 요소 : 하양
		System.out.println("요소의 갯수 : " + v.size());
		//		 요소의 갯수 : 7
		
		// ○ 전체 출력
		System.out.print("전체 출력 : ");
		for(String str : v)
			System.out.print(str + " ");
		System.out.println();
		//--==>> 전체 출력 : 주황 하양 노랑 초록 파랑 빨강 연두


		// ○ 오름차순 정렬
		Collections.sort(v);

		// ○ 전체 출력
		System.out.print("오름차순 정렬 후 전체 출력 : ");
		for(String str : v)
			System.out.print(str + " ");
		System.out.println();
		//--==>> 전체 출력 : 주황 하양 노랑 초록 파랑 빨강 연두

		// ○ 검색
		// Collections.binarySearch()
		// 검색 기능 수행.
		// 단, 오름차순 정렬이 수행되어 있는 자료에 대해서만 사용이 가능하다. check~!!!
		// 검색 결과가 존재하지 않을 경우 음수를 반환한다.

		int idxBlue = Collections.binarySearch(v, "파랑");
		System.out.printf("파랑 : %d번째 인덱스에 위치하고 있다.\n", idxBlue);
		System.out.println();
		//--==>> 파랑 : 5번째 인덱스에 위치하고 있다.

		int idxNavi =  Collections.binarySearch(v, "남색");
		System.out.printf("남색 : %d번째 인덱스에 위치하고 있다.\n", idxNavi);
		System.out.println();
		//--==>> 남색 : -1번째 인덱스에 위치하고 있다.
		//		→ 검색결과 없음


		// ○ 내림차순 정렬
		Collections.sort(v, Collections.reverseOrder());

		// ○ 전체 출력
		System.out.print("내림차순 정렬 후 전체 출력 : ");
		for(String str : v)
			System.out.print(str + " ");
		System.out.println();
		//--==>> 내림차순 정렬 후 전체 출력 : 하양 파랑 초록 주황 연두 빨강 노랑

		// ○ 내림차순 정렬 후 검색
		idxBlue = Collections.binarySearch(v, "파랑");
		System.out.printf("파랑 : %d번째 인덱스에 위치하고 있다.\n", idxBlue);
		System.out.println();
		//--==>> 파랑 : -8번째 인덱스에 위치하고 있다.

		idxBlue = Collections.binarySearch(v, "파랑", Collections.reverseOrder());
		System.out.printf("파랑 : %d번째 인덱스에 위치하고 있다.\n", idxBlue);
		System.out.println();
		//--==>> 파랑 : 1번째 인덱스에 위치하고 있다.
		// → 현재 데이터 구조
		// 하양 파랑 초록 주황 연두 빨강 노랑

java.util.Collections에 대해 더 알아보고 싶다면 

codevang.tistory.com/139

이분의 블로그를 참고하면 되겠다.

벡터 자료구조에 담긴 내용(요소) 검색 및 삭제

// 검색 및 삭제

import java.util.Vector;

public class Test166
{
	// 정적 문자열 배열 선언 및 초기화
	private static final String[] colors
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};

	public static void main(String[] args)
	{
		// 벡터 자료구조 생성
		Vector<String> v = new Vector<String>();

		// 벡터 자료구조 v 에 colors 데이터를 요소로 추가
		for (String color : colors)
			v.add(color);

		// 벡터 자료구조 v 의 전체 요소 출력
		System.out.print("전체 요소 출력 : ");
		for (String str : v)
			System.out.print(str + " ");
		System.out.println();
		//--==>> 전체 요소 출력 : 검정 노랑 초록 파랑 빨강 연두

		String s1 = "분홍";

		int i = v.indexOf(s1);
		System.out.println(s1 + " → index 위치 : " + i);
		System.out.println();
		//--==>> 분홍 → index 위치 : -1

		String s2 = "노랑";

		int j = v.indexOf(s2);
		System.out.println(s2 + " → index 위치 : " + j);
		System.out.println();
		//--==>> 노랑 → index 위치 : 1
		
		// 『v.contains(s)』
		// 벡터 자료구조 v 에 찾고자하는 s 가 포함되어 있다면...
		// → index 위치 확인
		if (v.contains(s2))
		{
			// 『v.contains(s)』
			// 벡터 자료구조 v 에서 s 의 인덱스 위치 반환
			i = v.indexOf(s2);
			System.out.println(s2 + " → index 위치 : " + i);

			// 우선 위의 코드를 통해 찾고...
			// 찾았으면 삭제해라~!!!
			v.remove(i);
		}

		// 찾아서 삭제한 후 전체 요소 출력
		System.out.print("삭제 후 전체 요소 출력");
		for (String str : v)
			System.out.print(str + " ");
		System.out.println();
		//--==>> 삭제 후 전체 요소 출력검정 초록 파랑 빨강 연두

		
		// 추가 테스트(주의사항)
		System.out.println(colors);
		//--==>> [Ljava.lang.String;@119d7047

		System.out.println(v);
		//--==>> [검정, 초록, 파랑, 빨강, 연두]

		// ※ 확인용 더미 데이터는 
		//   실제 요소(데이터)가 아니기 때문에
		//   이를 활용하여 연산을 진행하고 처리해서는 안된다.
		//   check~!!!

	}
}

벡터 자료구조에 사용자가 정의한 클래스의 인스턴스 담기 및 출력

// 벡터 자료구조 객체 선언 및 생성 시
// 사용자 정의 클래스 활용 → 자료형

import java.util.Vector;

// 사용자 정의 클래스 설계 → 자료형처럼 활용
class MyData
{
	// 주요 속성 구성 → 주요 변수 선언(멤버 변수)
	private String name;	//-- 이름
	private int age;		//-- 나이

	// getXxx() → getter
	// setXxx() → setter

	public String getName()
	{
		return name;
	}

	public void setName(String name)
	{
		this.name = name;
	}

	public int getAge()
	{
		return age;
	}

	public void setAge(int age)
	{
		this.age = age;
	}

	// 생성자(매개변수 2개인 생성자) → 사용자 정의 생성자
	public MyData(String name, int age)
	{
		this.name = name;
		this.age = age;
	}

	// 생성자(매개변수 없는 생성자) → 사용자 정의 생성자
	public MyData()
	{
		name = "";
		age = 0;
	}

}

public class Test167
{
	public static void main(String[] args)
	{
		// 벡터 자료구조 v 생성
		Vector<MyData> v = new Vector<MyData>();

		// 벡터 자료구조 v 에
		// 박다빈 13세 / 박민하 7세 / 박해진 58세
		// 담아내기

		// ①
		/*
		MyData st1 = new MyData();
		st1.setName("박다빈");
		st1.setAge(13);
		v.add(st1);
		
		MyData st2 = new MyData();
		st1.setName("박민하");
		st1.setAge(7);
		v.add(st2);

		MyData st3 = new MyData();
		st1.setName("박혜진");
		st1.setAge(58);
		v.add(st3);
		*/
		// ②
		/*
		MyData st1 = new MyData("박다빈", 13);
		v.add(st1);
		MyData st2 = new MyData("박민하", 7);
		v.add(st2);
		MyData st3 = new MyData("박혜진", 58);
		v.add(st3);
		*/

		// ③
		v.add(new MyData("박다빈", 13));
		v.add(new MyData("박민하", 7));
		v.add(new MyData("박혜진", 58));
		

		// 벡터 자료구조 v 에 담긴 내용(요소) 전체 출력하기
		// 실행 예)
		// 이름 : 박다빈, 나이 : 13세
		// 이름 : 박민하, 나이 : 7세
		// 이름 : 박해진, 나이 : 58세

		// ①
		for (MyData obj: v)
			System.out.printf("이름 : %s, 나이 : %d세\n", obj.getName(), obj.getAge());
		System.out.println();
		//--==>> 이름 : 박다빈, 나이 : 13세
		//		 이름 : 박민하, 나이 : 7세
		//		 이름 : 박혜진, 나이 : 58세

		// ②
		for (int i = 0; i < v.size(); i++)
			System.out.printf("이름 : %s, 나이 : %d세\n", v.elementAt(i).getName(), v.elementAt(i).getAge());
		System.out.println();
		//--==>> 이름 : 박다빈, 나이 : 13세
		//		 이름 : 박민하, 나이 : 7세
		//		 이름 : 박혜진, 나이 : 58세

		// ③
		for (Object temp : v)
		{
			System.out.printf("이름 : %s, 나이 : %d세\n"
				, ((MyData)temp).getName(), ((MyData)temp).getAge());
		}
		System.out.println();
		//--==>> 이름 : 박다빈, 나이 : 13세
		//		 이름 : 박민하, 나이 : 7세
		//		 이름 : 박혜진, 나이 : 58세
	
	}
}

○ 큐(Queue)

  큐(Queue)는 FIFO(Firsr Input First Output) 구조로 먼저 입력된 자료를 먼저 출력하며
  Queue 인터페이스를 구현한 클래스는 큐와 관련된 다양한 기능을 제공한다.

  ※ queue 인터페이스 인스턴스를 생성하기 위해서는 new 연산자를 이요하여 Queue 인터페이스를 구현한(implements) 클래스의 생성자를 호출한다.

ex) Queue ob = new LinkedList();

○ 주요 메소드

  - E element()
    큐의 head 요소를 반환하며 삭제하지 않는다.

  - boolean offer(E o)
    지정된 요소를 큐에 삽입한다.
  
  - E peek()
    큐의 head 요소를 반환하고 삭제하지 않으며 큐 자료구조가 empty 인 경우 null 을 반환한다

  - E poll()
    큐의 head 요소를 반환하고 삭제하며 큐 자료구조가 empty인 경우 null 을 반환한다. 

  - E remove()
    큐의 head 요소를 반환하고 삭제한다.

import java.util.Queue;
import java.util.LinkedList;

public class Test161
{
	public static void main(String[] args)
	{
		// Queue 자료구조 생성
		//Queue myQueue = new Queue();
		Queue<Object> myQueue = new LinkedList<Object>();

		// 데이터 준비
		String str1 = "이준구";
		String str2 = "한은영";
		String str3 = "정의진";
		String str4 = "조영욱";

		// myQueue 라는 Queue 자료구조에 데이터 추가
		myQueue.offer(str1);
		myQueue.offer(str2);
		myQueue.offer(str3);
		myQueue.offer(str4);

		// Queue 자료구조에서 요소를 제거하지 않고 head 요소 반환
		System.out.println("값1 : " + (String)myQueue.element());
		System.out.println("값1 : " + (String)myQueue.element());
		//--==>> 값1 : 이준구
		//       값2 : 이준구

		System.out.println();

		String val;

		// ①
		// peek()
		//-- 큐의 head 요소 반환. 제거 안함.
		//   큐가 empty 일 경우. null 반환.

		while (myQueue.peek() != null)
		{
			// poll()
			//-- 큐의 head 요소 반환. 제거 함/
			//   큐가 empty 일 경우. null 반환.
			val = (String)myQueue.poll();
			System.out.println("요소 : " + val);
		}
		//--==>> 요소 : 이준구
		//		 요소 : 이진주
		//		 요소 : 정의진
		//		 요소 : 조영욱
		
		// (X)
		//while (myQueue.poll() != null)
		//{
		//	// poll()
		//	//-- 큐의 head 요소 반환. 제거 함/
		//	//   큐가 empty 일 경우. null 반환.
		//	val = (String)myQueue.poll();
		//	System.out.println("요소 : " + val);
		//}
		//--==>> 요소 : 이진주
		//		 요소 : 조영욱

		// ②
		while (true)
		{
			val = (String)myQueue.poll();

			if (val == null)
				break;
			else
				System.out.println("요소 : " + val);

		}
		
		System.out.println();
		//--==>> 요소 : 이준구
		//		 요소 : 이진주
		//		 요소 : 정의진
		//		 요소 : 조영욱

		// ③
		while (!myQueue.isEmpty())
		{
			val = (String)myQueue.poll();
			System.out.println("요소 : " + val);
		}

		System.out.println();
		//--==>> 요소 : 이준구
		//		 요소 : 이진주
		//		 요소 : 정의진
		//		 요소 : 조영욱		
	}
}

import java.util.Queue;
import java.util.LinkedList;

public class Test162
{
	// 정적 문자열 배열 선언 및 초기화
	private static final String[] colors
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};
	
	public static void main(String[] args)
	{
		// Queue 자료구조 생성
		Queue<String> qu = new LinkedList<String>();
		//-- Queue 인터페이스 기반의 인스턴스를 생성하기 위해서는
		//   new 연산자를 이용하여 Queue 인터페이스를 implements 한
		//   하위 클래스의 생성자를 호출해야 한다.

		// qu 라는 Queue 자료구조에
		// colors 배열의 데이터 입력
		for (String color : colors)
			qu.offer(color);

		// qu 라는 Queue 자료구조의 모든 데이터 전체 출력

		while (qu.peek() != null)
			System.out.print(qu.poll() + " ");
		System.out.println();
		//--==>> 검정 노랑 초록 파랑 빨강 연두

	}
}

○ 스택(Stack)

1. Stack 클래스는 오브젝트 후입선출(LIPO) 구조의 Stack 을 나타낸다.
   이는 벡터(Vector)를 스택으로 처리하는 5개의 메소드로 벡터(Vector) 클래스를 확장하게 된다.

2. 통상의 push() 메소드와 pop() 메소드가 제공되는 것 외에 스택의 선두 항목으로 peek() 을 실시하는 메소드,
스택이 비어있는지의 여부를 확인하는 메소드 isEmpty(), 스택으로 항목을 찾아서 선두로부터 몇 번째인지를 찾아내는 메소드 등이 제공된다.

3. 스택이 처음으로 작성되었을 떄, 항목은 존재하지 않는다.

○ 주요 메소드

   - boolean empty()
     스택이 비어있는지 확인한다.

   - E Object peek()
     스택이 맨 위의 객체를 스택에서 제거하지 않고 반환한다.

   - E Object pop()
     스택의 맨 위의 객체를 반환하고 스택에서 제거한다.

   - E Object push(E item)
     객체를 스택 자료구조에 저장한다.

   - int search(Object o)
     스택의 맨 위에서부터 파라미터 값으로 넘겨받은 객체까지의 거리를 반환한다.

     맨 위의 객체의 경우 1을 반환하고 그 아래는 2를 반환하는 형식.

import java.util.Stack;

public class Test159		
{
	public static void main(String[]args)
	{
		// Stack 자료구조 생성
		Stack<Object> myStack = new Stack<Object>();

		String str1 = "이준구";
		String str2 = "이진주";
		String str3 = "정의진";
		String str4 = "조영욱";
		
		// myStack 이라는 Stack 자료구조 안에 str1 ~ str4 까지 담아내기
		// add(), push(),
		myStack.add(str1);
		myStack.add(str2);
		myStack.push(str3);
		myStack.push(str4);

		// peek() : 스택 맨 위의 객체 반환. 제거하지 않는다.
		String val1 = (String)myStack.peek();	//-- 형 변환 check~!!!
		System.out.println("val1" + val1);
		//--==>> 조영욱

		String val2 = (String)myStack.peek();
		System.out.println("val2" + val2);
		//--==>> 조영욱

		String val3 = (String)myStack.peek();
		System.out.println("val3" + val3);
		//--==>> 조영욱

		String value = "";

		while(!myStack.isEmpty())
		{
			value = (String)myStack.pop();
			System.out.println("value : " + value);
		}

		// myStack 이라는 이름을 가진 Stack 자료구조에
		// 데이터가 비어있지 않은 상태라면...
		// (즉, 채워져 있는 상태라면...)
		// 『isEmpty()』			// 준구 진주 의진 영욱
									// 준구 진주 의진
									// 준구 진주
									// 준구
									// x
		while(!myStack.isEmpty())	// true → true → true → true → false
		{
			value = (String)myStack.pop();
			System.out.println("value : " + value);
		}
		//--==>> value : 조영욱
		//		 value : 정의진
		//		 value : 이진주
		//		 value : 이준구

	}
}

import java.util.Stack;

public class Test160
{
	// 정적 문자열 배열 선언 및 초기화
	private static final String[] colors
		= {"검정", "노랑", "초록", "파랑", "빨강", "연두"};

	// 생성자
	public Test160()
	{
		// st 라는 Stack 자료구조 생성
		// 제네릭을 활용하여 자료구조에 담기는 데이터 표현 → <String>
		Stack<String> st = new Stack<String>();

		// st 라는 Stack 자료구조에 데이터 담기
		// colors 에 담겨있는 데이터...
		// st = colors; // (X)
		for (String color : colors)
		{
			st.push(color);
		}

		st.push("흰색");

		//st.push(10);
		//st.push(10.0);
		//--==>> 에러 발생(컴파일 에러)
		//-- 제네릭 표현식을 통해 선언하고 있는
		//   String 이 아닌 다른 자료형(int 나 double)을
		//   스택 st 에 push() 하려고 했기 때문에...

		// 출력 메소드 호출
		popStack(st);
	}
	
	// 출력 메소드
	private void popStack(Stack<String> st)
	{
		System.out.print("pop : ");
		while (!st.empty())
			System.out.print(st.pop() + " ");
		System.out.println();

	}


	public static void main(String[] args)
	{
		new Test160();

	}
}

자료

    현실 세계로부터 단순한 관찰이나 측정을 통해서 수집된 사실이나 개념의 값들 또는 값들의 집합.

       ↓

자료 구조

    자료 처리를 위한 자료의 표현, 저장, 관계, 관리 및 이용에 관한 방법 등의 개념을 이용하여 프로그램에 사용하고 컴퓨터에 의해 처리되는 과정에서 적절한 자료의 표현, 구성, 저장 및 처리를 위한 알고리즘 작성 및 선택과 이용 방법을 연구하는 분야.

       ↓

컬렉션 프레임워크(Collection Framework)   

   컬렉션(모아놓은 데이터들)의 표현과 조작을 위한 통일된 아키텍처로 컬렉션 프레임워크를 구성하는 요소는 다음과 같다.

1. 인터페이스(Interface)
   기본적으로 컬렉션에 필요한 데이터 관리 기능을 제공한다.

   예를 들어, list는 추가, 삭제, 검색 기능을 제공하는 컬렉션 인터페이스가 존재하며 각 컬렉션마다 고유의 인터페이스가 정의되어 있다.

2. 구현(Implementation)
  인터페이스를 구현한 클래스로 각 컬렉션을 실제 어떤 자료구조를 이용하여 표현했느냐에 따라 컬렉션의 종류가 달라지게 된다.

3. 알고리즘(Algorithms)
  각 컬렉션들마다 유용하게 사용할 수 있는 메소드를 의미한다.

※ 자바 컬렉션을 견고한 컬렉션 프레임워크 기반 위에 정의되어 있으므로 각 컬렉션 종류마다 제공되는 메소드의 일관성이 있기 때문에 한 가지 컬렉션을 익혀두면 다른 컬렉션을 사용하는데 용이하다.

컬렉션 프레임워크의 종류

이러한 컬렉션 프레임워크들은 어떠한 인터페이스를 구현하였는지에 따라서 기본적인 성격이 달라진다. 우선 List를 구현하는 클래스들은 인덱스 순서에 따라 데이터가 저장되고 데이터의 중복 저장이 가능하다. Set을 구현하는 클래스들은 순서를 유지하지 않고 데이터를 저장하며 중복된 데이터의 저장이 불가능하다. Map을 구현하는 클래스들은 키(key)와 값(value)을 동시에 저장한다.(즉, 키(key)를 통해 값을 불러온다.) 이때 키는 중복 저장이 불가능하다.

 해당 인터페이스를 구현하는 클래스들은 동일한 조작법(메소드)을 갖고 있지만 동작하는 내용들은 조금씩 다르다. 이들이 어떠한 동작을 하는지는 다음 포스팅부터 종류별로 하나씩 알아보도록 하겠다.