▼ Vector에 대한 설명 ①
/*
○ Vector (벡터)
자바의 자료구조 기능을 제공하는 클래스들 중 가장 기본적인 클래스로
배열과 비슷하지만, 배열과 달리 다른 종류의 데이터 형을 가진
데이터 요소들을 가질 수 있으며, 데이터가 가득 차면 자동으로 저장 영역을
확장시키게 된다.
또한, 객체 레퍼런스를 저장하기 때문에
JDK 1.5 이전에는 자바 기본형 데이터는 저장할 수 없었으나
JDK 1.5 이후부터는 오토박싱 / 오토언박싱 기능이 지원되면서
기본 데이터형도 저장할 수 있게 되었다.
벡터 클래스의 기본 구조는
시퀀스(Sequence) 데이터 구조에 기반하며
시퀀스 데이터 접근을 순차적인 인덱스 값에 대한 위치로 접근하게 된다.
따라서 자료구조의 양 끝단에서만 접근이 가능한 큐나
한쪽 끝에서만 접근이 가능한 스택과 달리
시퀀스 개념의 인덱스 값을 이용하여 자료구조의 임의의 지점에서
저장 및 접근이 가능하다.
벡터의 시퀀스 구조는
List 인터페이스를 통해 제공받고 있기 때문에
List 인터페이스의 모든 메소드를 사용할 수 있다.
- void add(int index, E element)
- void insertElementAt(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 firstElement()
벡터의 첫 번째 요소의 데이터를 반환한다.
- E lastElement()
벡터의 마지막 요소의 데이터를 반환한다.
- void setSize(int newSize)
벡터의 크기를 조절한다.
만약 주어진 크기가 현재 크기보다 작다면 나머지는 버린다.
반대로 주어진 크기가 현재 크기보다 크다면
빈 공간은 null 객체로 채우게 된다.
(객체를 참조하지 않음을 의미)
- int capacity()
현재 벡터의 용량을 반환한다.
- int size()
현재 벡터에 저장된 객체의 갯수(size)를 반환한다.
- trimToSize()
벡터의 용량을 저장된 객체의 갯수에 맞도록 최소화한다.
*/▼ Test158_Vector 기초 ① (Iterator, addElement, firstElement, get, elementAt, lastElement, hasNext, next)
import java.util.Vector;
import java.util.Iterator;
public class Test158
{
// 정적 문자열 배열 선언 및 초기화
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]);
// addElement()
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);
//--==>> 마지막 요소 : 연두
// ※ addElement 활용하여 요소 추가 후 다시 확인
//--==>> 마지막 요소 : 하양
// ※ 벡터 자료구조에 요소 추가 시(→ add() / addElement())
// 인덱스 마지막(가장 끝)의 위치에 추가되는 것을 확인할 수 있다.
// 전체 요소 출력
// 『Iterator(이터레이터 or 아이터레이터)』
// 『hasNext()』 : 다음 데이터 요소가 있는지 없는지의 여부를 확인
// 『next()』 : 다음 데이터 요소를 직접적으로 반환
Iterator<Object> it = v.iterator();
while (it.hasNext())
{
str = (String)it.next(); // true true ... true true false // str은 스트링, it는 오브젝트니까 String으로 형 변환
System.out.print(str + " "); // 검정 노랑 ... 연두 하양
}
System.out.println();
/*
▼
------------------------
검정 노랑 초록 파랑 연두 하양
------------------------
*/
}
}▼ Vector에 대한 설명 ② (Vector 자료구조 생성)
/*
Vector v = new Vector();
비어있는 Vector 자료구조 v 생성
Vector v = new Vector(8);
8개의 초기 elements를 가진 Vector 자료구조 v 생성
이 자료구조를 활용하는 과정에서
8개가 모두 채워지게 되면(모두 사용되어 모자라게 되면) 자동으로 확장된다.
Vector v = new Vector(3, 5);
3개의 초기 elements 를 가진 Vector 자료구조 v 생성
이 자료구조를 활용하는 과정에서
3개가 모두 채워지게 되면(모두 사용되어 모자라게 되면) 자동으로 5개 증가(확장)된다.
※ 벡터는 데이터 요소로 정수형, 실수형, 문자열... 등을
담아내는 것이 가능하다.(→ 가능해졌다.)
→ 데이터 안정성 확보 check~!!!!
*/▼ Test159_Vector 기초 ② (벡터 자료구조에 자료형 저장)
import java.util.Vector;
import java.util.Iterator;
// MyVector 클래스 설계 → Vector 클래스 상속
class MyVector extends Vector<Object>
{
// 생성자 → 사용자 정의 생성자
MyVector()
{
// Vector(슈퍼 클래스) 생성자 호출
// super();
// → Vector();
super(1, 1);
//-- 첫 번째 인자 : 주어진 용량
// 두 번째 인자 : 증가량
}
void addInt(int i)
{
addElement(new Integer(i));
}
void addFloat(float f)
{
addElement(new Float(f));
}
void addString(String s)
{
addElement(s);
}
void addCharArray(char[] a)
{
addElement(a);
}
void addObject(Record rec)
{
addElement(rec);
}
void write()
{
/*
Iterator<Object> it = iterator();
while (it.hasNext())
System.out.println(it.next());
//--==>> 5
// 3.14
// 안녕하세요
// [C@6b95977
*/
/*
Object o;
int length = size(); // super.size(), this.size() 다 된다!
System.out.println("벡터 요소의 갯수 : " + length);
//--==>> 벡터 요소의 갯수 : 4
for (int i=0; i<length; i++)
{
o = elementAt(i);
System.out.println(o);
}
//--==>> 5
// 3.14
// 안녕하세요
// [C@18b4aac2
*/
// 『instanceof』 연산자 check~!!!
//-- 처리해야 하는 대상의 객체 타입 확인
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("문자배열");
else
System.out.println("다른형태");
*/
if (o instanceof char[])
// System.out.println("문자배열");
System.out.println("문자배열 : " + String.copyValueOf((char[])o));
else if (o instanceof String)
System.out.println("문자열 : " +o.toString());
else if (o instanceof Integer)
System.out.println("정수형 : " + o);
else if (o instanceof Float)
System.out.println("실수형 : " + o);
else
System.out.println("타입 확인 요망~!!!");
}
}
}
public class Test159
{
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.addInt(digit); //-- 벡터 자료구조에 정수 저장
v.addFloat(real); //-- 벡터 자료구조에 실수 저장
v.addString(s); //-- 벡터 자료구조에 문자열 저장
v.addCharArray(letters); //-- 벡터 자료구조에 문자 배열 저장
v.write();
}
}
// 실행 결과
/*
정수형 : 5
실수형 : 3.14
문자열 : 안녕하세요
문자배열 : study
*/▼ Test160 (요소 변경(set), 오름차순 정렬(Collections.sort(), 검색(Collections.binarySearch), 내림차순 정렬(Coeections.srt(v, Collections.reverseOrder()))
import java.util.Vector;
import java.util.Collections;
public class Test160
{
// 정적 문자열 배열 선언 및 초기화
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.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);
//--==>> 파랑 : 5번째 인덱스에 위치하고 있다.
int idxPink = Collections.binarySearch(v, "분홍");
System.out.printf("분홍 : %d번째 인덱스에 위치하고 있다.\n", idxPink);
//--==>> 분홍 : -2번째 인덱스에 위치하고 있다.
// → 즉, 분홍은 v에 존재하지 않는다.
// ○ 내림차순 정렬
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);
//--==>> 파랑 : 1번째 인덱스에 위치하고 있다.
}
}▼ Test161_검색 및 삭제(indexOf(), remove())
// 검색 및 삭제
import java.util.Vector;
public class Test161 {
// 정적 문자열 배열 선언 및 초기화
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 의 전체 요소 출력
for (String str : v)
System.out.print(str + " ");
System.out.println();
//--==>> 검정 노랑 초록 파랑 빨강 연두
String s1 = "분홍";
// indexOf();
int i = v.indexOf(s1);
System.out.println(s1 + " → index 위치 : " + i);
System.out.println();
//--==>>분홍 → index 위치 : -1
String s2 = "노랑";
// 『v.contains(s)』
//-- 벡터 자료구조 v에 찾고자 하는 s가 포함되어 있는지의 여부
// → 포함되어 있다면 index 위치 확인
if (v.contains(s2))
{
i = v.indexOf(s2);
System.out.println(s2 + " → index 위치 : " + i);
// ① 존재하는지의 여부를 확인하고
// ② 존재한다면 어디에 있는지 확인하고
// ③ 확인한 위치의 요소를 제거해라 (삭제해라)
v.remove(i);
}
System.out.println();
//--==>> 노랑 → index 위치 : 1
// 찾아서 삭제한 후 전체 요소 출력
System.out.print("삭제 후 전체 요소 출력 : ");
for (String str : v)
System.out.print(str + " ");
System.out.println();
//--==>> 삭제 후 전체 요소 출력 : 검정 초록 파랑 빨강 연두
System.out.println(v);
//--==>> [검정, 초록, 파랑, 빨강, 연두]
// ※ 점검 확인용 더미 데이터는
// 실제 요소(데이터)가 아니기 떄문에
// 이를 활용하여 연산을 진행하고 처리해서는 안된다. check~!!!
}
}▼ Test162 (★★★★★★★중요★★★★★★★)
/*==================================
■■■ 컬렉션 (Collection) ■■■
===================================*/
//★★★★★★★★★★★★★★★Test162 중요!!!★★★★★★★★★★★★★★★★★★★★★★★★★★★
// 자료구조 객체 선언 및 생성 시
// 사용자 정의 클래스 활용
// → 자료형
import java.util.Vector;
// 클래스 → 사용자 정의 자료형으로 활용
class MyData
{
// 주요 속성 구성 → 주요 변수 선언(멤버 변수)
private String name; //-- 이름
private int age; //-- 나이
// getter → getXxx()
// setter → setXxx()
// getter → 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;
}
// ※ 사용자 정의 생성자가 구성될 경우
// default 생성자가 자동으로 삽입되지 않기 때문에
// default 생성자 형태의 생성자를 사용자 정의 생성자로
// 추가 구성하게 되는 것이 일반적인 클래스 설계 과정
// (반드시 설계해야 한다는 문법적인 규칙은 없다.)
// 생성자 → 사용자 정의 생성자(매개변수 없는 생성자)
public MyData()
{
// this("", 0); // 아래 2줄이랑 같은 코드
name = "";
age = 0;
}
}
public class Test162 {
public static void main(String[] args)
{
// 벡터 자료구조 생성
Vector<MyData> v = new Vector<MyData>(); // MyData 타입은 요소만 취할거야
// 벡터 자료구조 v에
// 홍길동 73세 / 김영희 7세 / 김철수 3세
// 담아내기
// ①
/*
MyData st1 = new MyData();
st1.setName("홍길동");
st1.setAge(73);
v.add(st1);
MyData st2 = new MyData();
st2.setName("김영희");
st2.setAge(7);
v.add(st2);
MyData st3 = new MyData();
st3.setName("김철수");
st3.setAge(3);
v.add(st3);
*/
// ②
/*
MyData st1 = new MyData("홍길동", 73);
v.add(st1);
MyData st2 = new MyData("김영희", 7);
v.add(st2);-
MyData st3 = new MyData("김철수", 3);
v.add(st3);
*/
// ③
v.add(new MyData("홍길동", 73));
v.add(new MyData("김영희", 7));
v.add(new MyData("김철수", 3));
// ①
for (MyData obj : v)
System.out.printf("이름 : %s, 나이 : %d세\n", obj.getName(), obj.getAge());
System.out.println();
//--==>> 이름 : 홍길동, 나이 : 73세
// 이름 : 김영희, 나이 : 7세
// 이름 : 김철수, 나이 : 3세
// ②
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();
// ③
for (int i = 0; i < v.size(); i++)
System.out.printf("이름 : %s, 나이 : %d세\n", v.get(i).getName(), v.get(i).getAge());
System.out.println();
// ④
for (Object obj : v)
System.out.printf("이름 : %s, 나이 : %d세\n", ((MyData)obj).getName(), ((MyData)obj).getAge());
System.out.println();
}
}