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세
	
	}
}