8. Java 유용한 API

**iterator(enumeration, cursor, 반복자)

=>컬렉션(데이터의 모임)에서 저장되는 데이터 크기에 상관없이 다음 데이터를 가리킬 수 있도록 해주는 포인터

=>배열은 인덱스를 이용해서 다음 데이터로 진행하지만 배열을 제외한 컬렉션들은 인덱스를 이용해도 되고 반복자의 next를 이용해서 다음 데이터를 가리키게 됩니다.

=>반복자 때문에 개발자는 컬렉션에 저장되는 요소의 크기에 상관없이 다음 데이터를 접근할 수 있게 됩니다.

=>데이터베이스에서 이러한 기능을 수행하는 것을 cursor라고 합니다.

java에서는 예전에 만들어진 Collection 들은 Enumeration을 이용하고 최근에 만들어진 Collection 들은 Iterator를 이용합니다.

1.Enumeration

=>boolean hasMoreElements() : 다음 데이터의 존재여부를 리턴해주는 메소드

=>E nextElement() : 다음 데이터를 리턴해주는 메소드

//Vector는 Enumeration 인터페이스를 implements

Vector<String> vector = new Vector<String>();

//vector의 모든 요소를 순차적으로 접근

while(true){

//다음 데이터가 없을 때까지

if(vector.enumerable().hasMoreElements() == false){

break;

}

String imsi = vector.enumerable().nextElement();

}

2.Iterator

=>boolean hasNext(): 다음 데이터의 존재 여부를 리턴

=>E next(): 다음 데이터를 리턴 - 없으면 예외 발생

=>iterator()라는 메소드를 만들 수 있습니다.

ArrayList<Integer>list = new ArrayList<Integer>();

//Iterator를 이용해서 list의 모든 데이터 접근

=>hasNext가 false를 리턴할 때 까지 next()를 호출

while(true){

if(list.iterator().hasNext() == false){

break;

}

Integer imsi = list.iterator().next();

}

**List 인터페이스

=>데이터를 순서대로 저장하는 자료구조

메소드

boolean add(E e): 데이터를 마지막 위치에 삽입하고 성공하면 true 실패하면 false를 리턴

void add(int index, E e): index 번째에 데이터를 끼워넣는 메소드

E get(int index): index 번째에 해당하는 데이터를 리턴해주는 메소드

E remove(int index): index 번째의 데이터를 삭제하고 리턴해주는 메소드

int size(): 데이터 개수를 리턴해주는 메소드

1.Vector 클래스

=>데이터를 입력한 순서대로 연속해서 저장하는 가변배열

=>처음 설정한 크기보다 더 많은 데이터가 삽입되면 자동으로 크기를 늘려서저장합니다.

=>빠른 열거를 사용할 수 있습니다.

=>제너릭을 적용

=>toString 이 재정의 되어 있어서 모든 데이터의 toString을 호출한 결과를 리턴합니다.

생성자

Vector()

Vector(int 초기사이즈)

Vector(int 초기사이즈, int 한 번에 늘려줄 크기) 

Vector(Collection 다른 리스트)

문자열을 저장하는 벡터를 생성하고 데이터를 삽입한 후 벡터에 저장된 모든 데이터를 출력

import java.util.Vector;

public class VectorMain {

public static void main(String[] args) {

//문자열을 여러 개 묶어서 저장할 수 있는 Vector를 생성

Vector<String>vec = new Vector<String>();

//데이터를 삽입

vec.add("데이터 수집 - 프로그래밍 언어");

vec.add("데이터 저장 - 하둡,데이터베이스,파일");

vec.add("데이터 전처리 - 프로그래밍 언어");

vec.add("데이터 저장 - 하둡,데이터베이스,파일");

vec.add("데이터 분석 - 프로그래밍 언어");

vec.add("데이터 저장 - 하둡,데이터베이스,파일");

vec.add("데이터 시각화 - 프로그래밍언어");

//Vector의 모든 내용을 출력

//일반 for를 이용해서

int size = vec.size();

for(int i=0; i<size; i++){

String imsi = vec.get(i);

System.out.println(imsi);

}

//빠른 열거를 이용

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

for(String imsi : vec){

System.out.println(imsi);

}

//값만 확인

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

System.out.println(vec);

}

}

=>Vector는 기본적으로 멀티스레드에 동기화가 되어 있습니다.

=>데이터를 사용할 때 마다 다른 스레드가 사용 중인지 확인해가면서 데이터를 사용합니다.

=>멀티스레드 프로그램이 아닌 경우에는 시간낭비가 발생하게 됩니다.

=>이러한 문제를 해결해서 나온 클래스가 ArrayList입니다.

2.ArrayList

=>구조가 Vector 와 같음

=>Vector와 동일하게 사용

=>데이터베이스의 데이터를 읽어서 저장할 때 가장 많이 사용

=>데이터를 순서대로 연속해서 저장하기 때문에 연속된 빈 공간이 없으면 데이터를 저장할 수 없고 중간에 데이터를 추가하게 되면 다른 데이터들의 이동이 발생하게 되기 때문에 중간에 데이터를 삽입하면 느려집니다.

=>중간에 위치한 데이터를 삭제하게 되면 뒤에 있는 데이터들이 이동을 해야 합니다.

3.LinkedList

=>데이터를 논리적인 순서대로 연속해서 저장하는 자료구조

=>다음 데이터가 실제 물리적인 다음이 아닌 포인터를 이용해서 가리키는 구조

=>데이터를 삽입하거나 삭제할 때 물리적인 이동이 발생하지 않기 때문에 삽입이나 삭제가 빈번한 경우에는 유리한 자료구조

=>데이터를 순서대로 접근해가면서 읽기 때문에 읽는 속도가 느립니다.

=>응용프로그램의 데이터를 저장할 때 주로 이용

=>운영체제의 파일 시스템도 이 자료구조를 이용합니다.

=>사용법은 ArrayList와 동일합니다.

정수를 저장할 수 있는 ArrayList 와 LinkedList를 만들어서 중간에 데이터를 100000개 삽입하는 시간 비교

import java.util.ArrayList;

import java.util.LinkedList;

public class ArrayListMain1 {

public static void main(String [] args){

//정수를 저장할 수 있는 ArrayList를 만들고

//3개의 저장

//정수를 저장할 때 자료형은 int 가 아니고 Integer

//제너릭은 참조형만 가능:<>안에는 참조형만 가능

ArrayList<Integer> al = 

new ArrayList<Integer>();

al.add(1);

al.add(3);

al.add(9);

//정수 3개 저장한 LinkedList 생성

LinkedList<Integer> li = 

new LinkedList<Integer>();

li.add(1);

li.add(3);

li.add(9);

//ArrayList에 2를 1번째 위치에 100000개 넣는데 

//걸리는 시간 측정

long start = System.currentTimeMillis();

for(int i=0; i<1000000; i++){

al.add(1, 2);

}

long end = System.currentTimeMillis();

System.out.println("ArrayList:" + (end-start));

//LinkedList에 2를 1번째 위치에 100000개 넣는데

//걸리는 시간 측정

start = System.currentTimeMillis();

for(int i=0; i<1000000; i++){

li.add(1, 2);

}

end = System.currentTimeMillis();

System.out.println("LinkedList:" + (end-start));

}

}

=>데이터를 중간에 빈번히 추가하거나 삭제하는 경우는 LinkedList가 좋고 데이터를 마지막에만 추가하거나 읽기만 하는 경우에는 ArrayList가 좋습니다.

=>ArrayList 나 LinkedList에 사용자가 만든 클래스의 객체도 저장 가능

4.Stack

=>마지막에 삽입된 데이터가 먼저 출력되는 자료구조

=>LIFO(Last In First Out)

=>복귀 주소 저장에 이용 : 모바일에서 화면 전환을 할 때 각각의 화면을 Stack에 저장해서 현재 화면에서 뒤로를 할 때 이전 화면으로 넘어갈 수 있도록 해줍니다.

=>웹 브라우저에서 주소 창에 입력한 주소도 스택에 저장됩니다.

E push(E e): 데이터 저장

E pop(): 마지막에 저장된 데이터를 리턴하고 삭제

E peek(): 마지막에 저장된 데이터를 리턴하고 삭제하지 않음

int size(): 저장된 데이터 개수

데이터가 없는데 pop 을 하는 경우를 Underflow

스택에 데이터가 차서 더 이상 삽입할 수 없는데 삽입하는 경우를 Overflow

import java.util.Stack;

public class StackMain {

public static void main(String[] args) {

//실수를 저장하는 Stack 을 생성

Stack<Double>stack = new Stack<Double>();

//Stack에 데이터를 삽입할 때는 push를 이용

stack.push(1.9);

stack.push(2.8);

stack.push(9.8);

//Stack의 모든 데이터 출력하기

//pop을 이용하면 마지막 데이터를 삭제하고 리턴받을 수 

//있습니다.

int size = stack.size();

for(int i=0; i<size; i++){

Double d = stack.pop();

System.out.println(d);

}

}

}

스택은 pop을 하면 저장한 역순으로 리턴됩니다.

5.Queue

=>First In First Out: 먼저 삽입된 데이터가 먼저 출력되는 자료구조

=>스케쥴링에 주로 이용

=>Java에서는 인터페이스라서 직접 객체 생성은 안되고 Queue를 implements 한 LinkedList 나 PriorityQueue 클래스를 이용해서 생성

6.Deque

=>양쪽에서 삽입과 삭제가 가능한 자료구조

=>모바일에서 스크롤 뷰(지도, 테이블, 웹 뷰)에 사용

=>Java에서는 인터페이스라서 직접 객체 생성은 안되고 Deque를 implements 한 ArrayDeque 클래스를 이용해서 생성

**List를 이용한 1-45까지의 숫자 중복없이 입력받아서 저장하기

1.정수를 저장할 수 있는 List 생성

2.6개의 숫자를 입력받아서 List에 저장하고 List의 모든 데이터 출력하기

3.1-45까지만 입력받을 수 있도록 코드 추가

4.중복없이 저장할 수 있도록 코드 추가

5.List의 데이터를 정렬하기

import java.util.ArrayList;

import java.util.Comparator;

import java.util.List;

import java.util.Scanner;

public class LottoList {

public static void main(String[] args) {

//정수를 저장할 수 있는 List 객체 생성

List<Integer> lotto = 

new ArrayList<Integer>();

//1-45까지 중복없이 입력받아서 lotto에 6개 저장

//키보드로부터 입력받을 수 있는 객체 생성

Scanner sc = new Scanner(System.in);

for(int i=0; i<6; i++){

System.out.print("숫자를 입력하세요(1-45):");

//정수 1개를 입력받아서 input에 저장

int input = sc.nextInt();

//1-45사이의 숫자만 저장되도록

if(input < 1 || input > 45){

System.out.println(

"1부터 45사이의 숫자만 입력하세요!!!");

//이번에 수행한 내용은 무효

i = i - 1;

continue;

}

//중복검사

if(i>0){

//중복된 데이터가 있는지 확인하기 위한 변수

boolean flag = false;

for(int j=0; j<= i-1; j++){

//중복된 데이터가 있을 때 변수의 값을 true로 변경

if(input == lotto.get(j)){

flag = true;

break;

}

}

//중복된 값이 있을 때 이번 반복은 무효

if(flag == true){

System.out.println("중복된 숫자는 안됨");

i = i - 1;

continue;

}

}

//input을 List에 저장

lotto.add(input);

}

//사용한 스트림 닫기

sc.close();

//Integer, Double 과 같은 Wrapper 클래스와 String, Date 클래스는

//Comparable 인터페이스를 implements 해서 크기 비교를 compareTo 라는 메소드를 가지고 수행합니다.

//컬렉션의 데이터 크기 비교를 위한 Comparator 만들기

Comparator <Integer> comp = new Comparator<Integer>(){

@Override

public int compare(Integer o1, Integer o2){

return o1.compareTo(o2);

}

};

//lotto 리스트 정렬 - comp를 가지고 비교

lotto.sort(comp);

//데이터 출력

for(Integer imsi : lotto){

System.out.print(imsi + "\t");

}

}

}

 

**Set - 인터페이스

=>데이터를 중복없이 저장하는 자료구조

=>중복된 데이터를 삽입하려고 하면 삽입하지 않습니다.

=>Generic 적용

=>데이터 1개를 가져오는 메소드가 없으므로 빠른 열거 나 iterator를 이용해서 데이터를 가져와야 합니다.

=>toString은 재정의 되어 있어서 toString을 호출하면 각 데이터의 toString을 호출해서 결합한 결과를 리턴합니다.

1.implements 한 클래스

1)HashSet : 데이터의 저장 순서를 알 수 없는 Set

2)LinkedHashSet : 데이터의 저장 순서를 알 수 있는 Set

3)TreeSet : 데이터를 크기 순으로 재배치한 Set, 크기 순으로 배치해야 하기 때문에 저장되는 요소는 반드시 Comparable 인터페이스를 implements 해야 합니다.

2.Method

1)boolean add(E e): e를 삽입하려고 하고 삽입에 성공하면 true 실패하면 false 리턴 - 중복된 데이터를 삽입하려고 하면 false

2)Iterator<E> iterator(): Iterator 리턴

3)int size(): 저장된 데이터 개수 리턴

ex)Set 테스트

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.Set;

import java.util.TreeSet;

public class SetText {

public static void main(String[] args) {

//Set 객체 만들기 - 문자열

//데이터의 저장 순서를 알 수 없습니다.

//Set<String> set = new HashSet<String>();

//LinkedHashSet : 데이터의 저장순서대로 저장하는 Set

//Set<String> set = new LinkedHashSet<String>();

//TreeSet : 데이터를 크기 순서대로 저장하는 Set

Set<String>set = new TreeSet<String>();

set.add("프로그래밍언어");

set.add("데이터베이스");

//위에 있는 데이터와 동일한 데이터이므로 삽입을 안함

set.add("프로그래밍언어");

set.add("운영체제");

set.add("자료구조");

set.add("알고리즘");

//System.out.println(set.size());

//Set의 모든 데이터 접근 - 빠른 열거 이용

for(String imsi : set){

System.out.print(imsi + "\t");

}

System.out.println();

//Set의 모든 데이터 접근 - Iterator 이용

Iterator<String> iter = set.iterator();

while(true){

if(iter.hasNext() == false){

break;

}

String imsi = iter.next();

System.out.print(imsi + "\t");

}

}

}

ex)숫자를 입력받아서 1-45 사이의 숫자를 중복없이 저장하기 - Set 이용

import java.util.Scanner;

import java.util.Set;

import java.util.TreeSet;

public class LottoSet {

public static void main(String[] args) {

//1-45까지의 숫자 6개를 중복없이 입력받아서 저장

//중복없이 크기 순서대로 정수를 저장하는 Set 을 생성

Set<Integer> lotto = 

new TreeSet<Integer>();

Scanner sc = new Scanner(System.in);

//TreeSet의 데이터 개수가 6개 될 때 까지 작업

while(true){

System.out.print("숫자를 입력(1-45):");

int input = sc.nextInt();

if(input < 1 || input > 45){

System.out.println(

"1-45까지 숫자를 입력하세요");

continue;

}

//데이터 삽입 - 중복된 숫자가 오면 삽입되지 않음

lotto.add(input);

//lotto에 6개가 저장되면 종료

if(lotto.size() == 6){

break;

}

}

//데이터 출력

for(Integer imsi : lotto){

System.out.print(imsi + "\t");

}

sc.close();

}

}