컬렉션/ArrayList/HashSet - 객지설 11주차

컬렉션

자료를 저장하기 위한 구조. 제네릭 기법으로 구현되어 있어서 어떠한 타입의 데이터도 저장 가능

 

컬렉션 종류 -> 모든 클래스는 java.uti 패키지에 있

1. 컬렉션 인터페이스

2. 컬렉션 클래스

 

List 참조변수가 ArrayList를 가리킬 수 있음.

Set 참조변수가 HashSet을 가리킬 수 있음.

=> 업캐스팅

 

컬렉션 특징

- 기초 자료형은 저장 불가. 클래스만 가능함 (단, 기초 자료형을 클래스로 감싼 랩퍼 클래스인 Integer나 Double은 사용 가능)

Vector<int> list = new Vector<int>(); //컴파일 오류
Vector<Integer> list = new Vector<Integer>(); //올바른 코드

 

컬렉션 인터페이스의 주요 메소드

- boolean contains(Object obj) : 원하는 원소가 포함되어 있는지 판별

- boolean add(E element) : 원소 추가

- boolean remove(Object obj) : 원소 삭제

- int size() : 원소의 개수 반환

Collection 인터페이스를 상속받아, 구현한 모든 클래스가 메소드를 사용할 수 있음.

 

+) for-each 구문

- for ( 변수명 : 배열/컬렉션의 클래스 대입 가능 )

String[] a = new String[] { "A", "B", "C", "D", "E" };
List<String> list = Arrays.asList(a);

for (String s : list) {
     System.out.println(list.get(i));
}

 

컬렉션을 사용하는 이유

여러 알고리즘 메소드를 제공함 -> 정렬, 섞기 탐색

ex. 배열을 이용하면 정렬, 탐색 등의 코드를 모두 작성해야하지만, ArrayList는 메소드 사용하면 됨.

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        String[] s = { "i", "walk", "the", "line" };
        List<String> list = Arrays.asList(s); //s를 List 형태로 반환

        Collections.sort(list); // Collections.sort() 사용
        System.out.println(list);
    }
}

-> ArrayList를 사용하는 이유

ArrayList

가변 크기의 배열을 구현하는 제네릭 클래스

ArrayList	Array
- 배열의 크기가 지정되어 있지 않음 *요소를 더할 때마다 저절로 증가함 - 생성 방법 : ArrayList<String> list = new ArrayList<String>(); - 요소 저장, 요소 읽기, 요소 교환, 요소 차례로 방문 모두 ArrayList 클래스에서 지원이 됨. - ArrayList의 크기 : arrayList.size();	- 배열의 크기가 고정되어 있음. *주어진 크기보다 적게 쓰고 싶으면 남은 크기가 낭비 *주어진 크기보다 많이 쓰고 싶으면 코드 수정 후 컴파일 - 생성 방법 : String[] arr = new String[10]; - 요소 저장, 요소 읽기, 요소 교환, 요소 차례로 방문 모두 사용자가 코드를 작성할 필요가 있음 - 배열의 크기 : array.length();

 

ArrayList 기본 연산

- 생성 : 제네릭 클래스이기 때문에 타입 매개변수 지정 필요.

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

 

- 원소 추가 : 차례로 추가 가능

list.add("MILK");
list.add("BREAD");
list.add("BUTTER");

// { "MILK", "BREAD", "BUTTER" }

 

- 원소 추가2 : 중간에 추가 가능 -> 그 뒤의 원소들은 한 칸씩 밀려남

list.add( 1, "APPLE" );

// { "MILK", "APPLE", "BREAD", "BUTTER" }

 

- 원소 수정 : 특정 위치의 원소를 바꾸기 가능

list.set( 2, "GRAPE" ); // 인덱스 2의 원소를 "GRAPE"로 대체

// { "MILK", "APPLE", "GRAPE", "BUTTER" }

 

- 원소 삭제 : 특정 위치의 원소 삭제 가능 -> 그 뒤의 원소들은 한 칸씩 당겨짐

list.remove( 3 );

// { "MILK", "APPLE", "GRAPE" }

 

- 원소 읽기 : ArrayList 객체제 저장된 객체를 가져오는 메소드

String s = list.get(1); //APPLE 이라는 값이 s에 저장됨

 

-원소 찾기 : ArrayList에서 찾고 싶은 원소의 인덱스를 반환하는 메소드

int index = list.indexOf("MILK");

 

- 배열 크기 : ArrayList의 저장된 원소 개수를 알아내는 메소드

int size = list.size();

 

import java.util.ArrayList;

class Point {
	int x, y;
	public Point(int x, int y) { //생성자
		this.x = x;
		this.y = y;
	}
	public String toString() {
		return "(" + x + ", " + y + ")";
	}
}
public class Test {
	public static void main(String[] args) {
		ArrayList<Point> list = new ArrayList<Point>(); //ArrayList의 객체 생성
		//ArrayList<Point> list = new ArrayList<P>(); 도 가능 -> 타입 유추
		
		list.add(new Point(0, 0)); //첫 번재 원소에 Point객체 저장
		list.add(new Point(4, 0)); //두 번재 원소에 Point객체 저장
		list.add(new Point(3, 5)); //세 번재 원소에 Point객체 저장
		list.add(new Point(-1, 3)); //네 번재 원소에 Point객체 저장
		list.add(new Point(13, 2)); //다섯 번재 원소에 Point객체 저장
		
		System.out.println(list);
	}
}

//출력 결과
[(0, 0), (4, 0), (3, 5), (-1, 3), (13, 2)]

* Point 객체에 toString이 없으면 ArrayList의 toString이 호출되어서 외계어가 나오기 때문에 꼭 toString 정의 필요

* 전체를 출력할 때는 toString() 없이 ArrayList의 참조변수 자체를 System.out.println()로 출력해도 된다.

 

import java.util.ArrayList;

public class Test {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		
		list.add("Apple");
		list.add("Banana");
		list.add("Mango");
		list.add("Pear");
		list.add("Grape");
		
		int index1 = list.indexOf("Mango");
		int index2 = list.indexOf("Kiwi");
		
		System.out.println("Mango의 위치: " + index1);
		System.out.println("Kiwi의 위치: " + index2);
		System.out.println("list의 크기: " + list.size()); //list.lenght()가 아님을 유의
	}
}

//출력 결과
Mango의 위치: 2
Kiwi의 위치: -1
list의 크기: 5

 

배열을 ArratList로 바꾸기

- Arrays.asList() 메소드 사용 : 배열을 List의 형태로 변형하여 반환

String[] array = { "APPLE", "BANANA", "PEACH" };
List <String> list = Arrays.asList(array); //업캐스팅? 
//arrat 변수가 ArrayList로 변경

 

Set

- ArrayList와 달리 순서 존재 없이 데이터를 저장하는 집합의 자료구조

- 중복되는 데이터 저장 불가

- 종류 : HashSet, TreeSet, LinkedHashSet

 

HashSet

- 해쉬 테이블에 원소를 저장

- 성능이 좋음

- 원소들의 순서가 일정하지 않음

import java.util.HashSet;

public class Test {
	public static void main(String[] args) {
		HashSet<String> set = new HashSet<String>();
		
		set.add("MILK");
		set.add("Bread");
		set.add("Butter");
		set.add("Cheese");
		set.add("Ham");
		set.add("Ham"); //add 자체가 실행X
		
		System.out.println(set); 
		
		if(set.contains("Ham") == true) {
			System.out.println("Ham은 포함되어 있음.");
		}
		
		if(set.contains("Kimchi")) {
			System.out.println("Kimchi은 포함되어 있음.");
		}
		else {
			System.out.println("Kimchi은 포함되어 있지 않음.");
		}
	}
}

//출력결과
[Ham, Butter, Cheese, MILK, Bread]
Ham은 포함되어 있음.
Kimchi은 포함되어 있지 않음.

 

import java.util.Set;
import java.util.HashSet;

public class Test {
	public static void main(String[] args) {
		Set<String> s = new HashSet<String>(); //Set 참조변수가 HashSet 객체 가리킴
		String[] sample = { "사과", "사과", "바나나", "토마토", "사과", "바나나" }; //sample 배열 생성
		
		for(String a : sample) {
			if (s.add(a) == false) { //추가 되지 않는다면
				System.out.println("중복된 단어: " + a);
			}
		}
		
		System.out.println("s의 크기는 " + s.size());
		System.out.println("중복되지 않은 단어: " + s);
	}
}

//출력 결과
중복된 단어: 사과
중복된 단어: 사과
중복된 단어: 바나나
s의 크기는 3
중복되지 않은 단어: [토마토, 사과, 바나나]

* hase에서 add는 반환값이 존재함 -> 추가가 된다면 true, 추가가 되지 않으면 false 반환함

* s 출력할 때 나오는 원소의 순서는 무작위임.