[Collection Framework] Collection<E>, generic, Iterator

포키·2022년 11월 25일
ArrayListCollectionGenericJavaListWrapper Classcollection frameworkiteratorvector
0

국비과정

목록 보기
33/73

  • Collection에서 equals는 필수
    Collection에 새로 만든 클래스를 원소로 사용할 때는 반드시 equals를 오버라이딩해야 한다.
    (ex) remove(Object o), ~~)

Collection Framework

  • 배열이 아닌 복수데이터의 필요성
    (배열의 한계 : 길이가 고정되어 있음. 한 번 정해진 길이는 변경 불가.)
  • 특정한 클래스를 말하는 게 x
  • interface인 Collection과 Map이 여기에 속함
  • 가변 길이를 가짐
  • (기본적으로는) 기본데이터형 지원하지 않음 = 객체만 가능
  • 기본 데이터타입을 클래스로 표기하는 Wrapper-class
/*
	기본 데이터 타입		wrapper class
============================================
	byte					Byte
	short					Short
	int						Integer
	long					Long
	float					Float
	double					Double
	char					Character
	boolean					Boolean
*/
class CollectionEx1 {
	public static void main(String[] args) {
		int num = 5;
		// int -> Integer
		Integer iObj = new Integer(num++);
		// Integer -> int
		num = iObj.intValue();
		System.out.println(num);
		// double -> Double
		double d = 3.14;
		Double dObj = new Double(d++);
		// Double -> double
		d = dObj.doubleValue();
		System.out.println(d);
		// JDK 1.5~
		// auto-boxing
		Integer iObj2 = 100;
		// auto-unboxing
		int num2 = iObj2;
	}
}
  • 사실 generic은 이 Collection Framework때문에 등장했다.
    모든 객체가 다 들어갈 수 있는 Collection Framework지만, 저장한 데이터를 꺼내어 사용할 때 오류가 날 가능성이 많은 것.
    (=어떤 타입의 데이터가 들어갔는지, 제대로 된 데이터가 들어갔는지 확인하기 어려움)
  • generic <T> = type, <E> = element 의미

interface Collection<E>

  • 배열과 달리 도우미클래스(ex) Arrays)가 거의 필요하지 않음
  • add(E e) : 원소 추가
    remove(Object o) : 원소 삭제
    clear() : 모든 원소 삭제
    size() : Collection의 길이 반환
  • contains(Object o) : 원소 o가 존재하는지 확인
  • containsAll(Collection<?> c) : c 객체의 모든 원소가 이 객체에도 존재하는지 확인
  • removeAll(Collection<?> c) : c 객체의 원소와 일치하는 원소를 모두 제거 (this - c; 차집합)
  • retainAll(Collection<?> c) : c 객체의 원소와 일치하는 원소만 남김 (this ∩ c; 교집합)
  • toArray(T[] a) : Collection To Array
import java.util.*;
class CollectionEx2 {
	public static void main(String[] args) {
		/*
			- 객체만 다룬다
			- 가변길이다.
		*/
		Collection<String> col = new HashSet<String>();

		col.add("아반떼");
		col.add("그랜저");
		col.add("소나타");
		col.add("캐스퍼");
		System.out.println(col.size());

		col.add("펠리세이드");
		System.out.println(col.size());

		// col.clear();
		// System.out.println(col.contains("소나타"));
		col.remove("그랜저");
		System.out.println(col);
		// 넣은 순서 관계없이 출력
		// Collection은 순서 없음 = index 없음
		// 배열로 문제없는 상황이라면 배열을 사용하는 것이 좋다(간단한 기능 = 덜 복잡한 코드와 더 빠른 속도)
		// 처음에는 Collection을 쓰더라도 길이가 확정되면 배열로 바꾸기

		// 1번 방법 - 형변환 필요, 사용 불편, 잘 쓰지 않음
		Object[] arr1 = col.toArray();
		// 2번 방법 - 만들 배열의 형태를 알려줌, 길이는 더 작을 경우 알아서 맞춰줌 = 0 대입
		String[] arr2 = col.toArray(new String[0]);
		// 3번 방법 - 콜렉션의 사이즈를 가져와서 대입
		String[] arr3 = col.toArray(new String[col.size()]);
	}
}
import java.util.*;
class CollectionEx4 {
	public static void main(String[] args) {
		Collection<String> colA = new ArrayList<String>();
		colA.add("banana");
		colA.add("grape");
		colA.add("orange");
		colA.add("mango");
		colA.add("apple");

		Collection<String> colB = new ArrayList<String>();
		colB.add("grape");
		colB.add("kiwi");
		colB.add("lemon");
		colB.add("orange");

		// System.out.println(colA.containsAll(colB));
		// colA.removeAll(colB);
		colA.retainAll(colB);
		System.out.println(colA);
	}
}

Iterator<E>

  • Collection의 도우미 클래스 : 원소를 꺼내는 기능
		Iterator<String> itr = col.iterator();
		while(itr.hasNext()) {
			String element = itr.next();
			System.out.println(element);
		}
  • hasNext() : 다음 값이 존재하는지 확인 (return : boolean)
  • next() : 다음 값을 꺼냄 (return : <E>)
		for(String element : col) {
			System.out.println(element);
		}
  • 기존에 배운 for each문도 사실 iterator 방식을 사용하고 있다.
    for each문이 index를 사용하지 않는다는 것이 바로 이 의미이다.
  • iterator : 전체 / for each문: 1.5 이후 사용 가능

💘 호기심 탐구

		Iterator<String> itr = col.iterator();
		while(itr.hasNext()) {
			String element = itr.next();
			System.out.println(element);
		}
        while(itr.hasNext()) {
			String element = itr.next();
			System.out.println(element);
		}
  • 여기서 두 번째 while문은 출력되지 않는다.
  • 한 번 사용된 Iterator 객체가 재사용되지 않는 것을 보아,
    Collection 객체의 원소에 접근할 수 있게 도와주는 방식이 아니라,
    Collection 객체의 원소를 Iterator 객체에 담아 사용하는 방식이라고 추측할 수 있다.

interface List

  • Collection에 index가 추가됨
  • 아래에 ArrayList 클래스, Vector 클래스 존재

✨class ArrayList & ✨class Vector

  • 거의 비슷한데, 기능의 차이가 아니라 다른 차이가 있음; thread safe or not
    (자바에는 이런 식으로 thread safe or not으로 구분된 개념들이 많음)
  • add(int x, <E> element) : x 위치(index)에 원소 추가
  • remove(int x) : x 위치(index)에 있는 원소 제거
  • get(int x) : x 위치(index)에 있는 원소 반환
  • set(int x, <E> element) : x 위치(index)에 있는 원소 변경
  • indexOf(Object o) : list에서 key값 찾아 index 반환, 없으면 -1 반환
  • indexOf(Object o, int x) : indexOf(Object o)에 시작점 x 추가

SubList 만들기

  • subList(시작점, 끝점) : list의 subList 생성
    (범위는 시작점부터 끝점-1까지, 잊지 말자!)
  • subList 만들기
import java.util.*;
class ListEx3 {
	public static void main(String[] args) {
		Vector<String> list = new Vector<String>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		list.add("f");
		list.add("g");

		List<String> subList = list.subList(1, 5);
		System.out.println("list : " + list);
		System.out.println("subList : " + subList);
		// list.add("some");
        
		subList.add("x");
		System.out.println("list : " + list);
		System.out.println("subList : " + subList);

		Vector<String> newList = new Vector<String>(subList);
		newList.add("z");
		
		System.out.println("list : " + list);
		System.out.println("subList : " + subList);
		System.out.println("newList : " + newList);
	}
}
  • subList를 변경하면 List에 반영된다.
  • List를 변경하면 subList에서 오류가 난다. -> 갱신 필요
  • 자유롭게 쓰고 싶다면 아예 관계없는 새 객체를 만들어 데이터 옮겨담기
    Vector<String> newList = new Vector<String>(subList);

배열을 List로 변경

  • Arrays.asList(배열)을 이용해 list로 변경
  • 생성된 list는 배열과 마찬가지로 길이 고정이므로,
    자유로운 사용을 위해 새로운 list 객체를 생성하여 데이터 옮겨담기
    List<String> list = Arrays.asList(arr);
import java.util.*;
class ListEx4 {
	public static void main(String[] args) {
		// 배열 -> List
		String[] arr = {"some", "any", "other", "another"};
		
		// fixed-size
		List<String> list = Arrays.asList(arr);
		System.out.println(list);

		//System.out.println(list.get(1));
		// list.add("java");

		ArrayList<String> myList = new ArrayList<String>(list);
		myList.add("java");
		System.out.println(myList);
	}
}

List의 정렬

  • Collections.sort(list) : list 정렬
  • Collections.max(list) : list 최대값 반환 (정렬 필수)
  • Collections.min(list) : list 최소값 반환 (정렬 필수)

interface Set<E>

  • 수학의 집합과 같은 개념 = 중복 허용하지 않음
import java.util.*;
class SetEx1 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("a");
		list.add("a");
		list.add("a");
		list.add("a");
		list.add("a");

		HashSet<String> set = new HashSet<String>();
		set.add("a");
		set.add("a");
		set.add("a");
		set.add("a");
		set.add("a");

		System.out.println(list);
		System.out.println(set);

		// ex) 놀이공원 입장객 중 재입장한 사람들을 제외하고 순수 입장객 수만 계산
	}
}
  • 결과:

List vs. Array

출처

profile
포키
welcome
이전 포스트

[예외처리] try~ catch~, finally~, throws

다음 포스트

[난수생성] Math.random(), Random 클래스

0개의 댓글