🚩 Collection vs Collections

Collection 인터페이스 vs Collections 클래스

Collection 인터페이스

• Java11 | Collection 인터페이스 도큐먼트
  
  (출처 : JavaCodeExamples.com)

• Collection 인터페이스는 Iterable 클래스를 구현한다. 이에 따라서 for-each loop(향상된 for문)을 구현할 수 있다.

• List, Set이 Collection 인터페이스를 상속받는다. 따라서 List와 Set 역시 향상된 for문을 사용할 수 있다.

• Collection 인터페이스의 주요 메서드들은 다음과 같다.

Collection의 핵심 정리⭐

• Collection은 자바 컬렉션 프레임워크의 가장 상위 계층에 위치한 인터페이스로써 List, Set, Queue 등의 컬렉션 프레임워크가 이를 구현함으로써 다양한 장점을 활용할 수 있다.

  • 활용할 수 있는 주요 기능으로 추가, 삭제, 조회, 크기 확인 등이 있다.

(Advancde) Iterable 인터페이스

• Java11 | Iterable 인터페이스 도큐먼트
• Iterable 클래스의 실제 코드

import java.util.Iterator;
import java.util.NoSuchElementException;
 
// `Collection` 클래스는 `java.util.Iterable` 인터페이스를 구현합니다.
class Collection<T> implements Iterable<T>
{
    private T[] array;
    private final int n;
 
    // 생성자
    public Collection(T[] array)
    {
        this.array = array;
        this.n = array.length;
    }
 
    /**
    * T 유형의 요소에 대한 반복자를 반환합니다.
    */
    @Override
    public Iterator<T> iterator()
    {
        return new Iterator<T>()
        {
            private int i = 0;
 
            /**
            * 어레이에 더 많은 요소가 있으면 true를 반환합니다.
            */
            @Override
            public boolean hasNext() {
                return (i < n && array[i] != null);
            }
 
            /**
            * 반복의 다음 요소를 반환합니다.
            * @throws NoSuchElementException 반복이 없는 경우
            * 더 많은 요소
            */
            @Override
            public T next()
            {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                return array[i++];
            }
        };
    }
}
 
class Main
{
    public static void main(String[] args)
    {
        // 정수 어레이
        Integer[] ints = new Integer[] { 1, 2, 3 };
 
        // `Collection` 클래스에서 Integer 어레이을 래핑합니다.
        Collection<Integer> collection = new Collection<>(ints);
 
        // 반복자를 사용하여 어레이을 반복합니다.
        Iterator<Integer> itr = collection.iterator();
        while (itr.hasNext()) {
            System.out.println(itr.next());
        }
 
        // for-each 루프를 사용하여 어레이을 반복합니다.
        // `Collection` 클래스가 `Iterable` 인터페이스를 구현하기 때문에 작동합니다.
        for (Integer i: collection) {
            System.out.println(i);
        }
    }
}

• 참고: Iterator 인터페이스의 방식과는 다르다.

class Main
{
    public static void main(String[] args)
    {
        // 정수 어레이
        Integer[] ints = new Integer[] { 1, 2, 3 };
 
        // `Collection` 클래스에서 `Integer` 어레이을 래핑합니다.
        Collection<Integer> collection = new Collection<>(ints);
 
        Iterator<Integer> itr = collection.iterator();
        while (itr.hasNext()) {
            System.out.println(itr.next());
        }
 
        // for-each 루프는 여기에서 작동하지 않습니다.
    }
}

• Iterable 인터페이스는 컬렉션 구현 방법을 노출시키지 않으면서도 그 집합체 안에 있는 모든 항목에 접근할 수 있는 방법을 제공한다.
  
  그 외 장점은 다음과 같다.

  • 향상된 for 루프 사용
  • 일관된 인터페이스 - iterator() 메서드를 이용하여 반환
  • 외부 반복자(External Iterator) 패턴 - 컬렉션과 반복 작업을 분리시키는 방식으로, 컬렉션 반복 작업을 수행하는 외부 반복자를 제공하고, 클라이언트는 이 반복자를 사용하여 컬렉션을 순회한다. 컬렉션의 내부 구조가 변경되어도 반복 작업에 영향을 주지 않으면서, 유연하고 확장된 코드를 제공할 수 있다.
    (참고 : https://blog.javarouka.me/2012/01/01/internal-external-iterator/)
  • 다중 반복자 사용 -
  • 컬렉션 순회 알고리즘의 활용 - 스트림과 forEach 메서드를 함께 사용하여 간결하고 효율적인 코드를 작성

Collections 클래스

• Java11 | Collections 클래스 도큐먼트

• Collections 클래스는 java.util.Collections 에 정의되어 있다.

• 이 클래스는 정렬, 역정렬, 이진탐색, 복제 등 다양한 정적 메서드를 가지고 있다.

• Arrays가 배열과 관련된 메서드를 제공하는 것처럼,
  ⭐Collections는 컬렉션과 관련된 메서드를 제공한다.
  fill(), copy(), sort(), binarySearch()등의 메서드들은 두 클래스 모두에 포함되어 있으며 같은 기능을 한다.

Collections의 다양한 메서드 활용하기

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import static java.util.Collections.*;	//Collections를 생략할 수 있게 해줌.

public class CollectionsEx {
    public static void main(String[] args) {
        List list = new ArrayList();
        System.out.println(list); //[]

        addAll(list, 1,2,3,4,5); //⭐요소 모두 추가
        System.out.println(list); //[1, 2, 3, 4, 5]

        rotate(list, 2);    //⭐오른쪽으로 두 칸씩 이동
        System.out.println(list); //[4, 5, 1, 2, 3]

        swap(list, 0, 2);   //⭐첫번째와 세번째를 교환(swap)
        System.out.println(list); //[1, 5, 4, 2, 3]

        shuffle(list);  //⭐저장된 요소의 위치를 임의로 변경
        System.out.println(list); //[1, 2, 5, 3, 4]

        sort(list, reverseOrder()); //⭐역순 정렬 reverse(list);와 동일
        System.out.println(list); //[5, 4, 3, 2, 1]

        sort(list); //⭐정렬
        System.out.println(list); //[1, 2, 3, 4, 5]

        int idx = binarySearch(list, 3);    //⭐3이 저장된 위치(index)를 반환
        System.out.println("index of 3 = " + idx); //index of 3 = 2

        System.out.println("max="+max(list)); //⭐max=5
        System.out.println("min="+min(list)); //⭐min=1
        System.out.println("min="+max(list, reverseOrder())); //⭐min=1

        fill(list, 9); //⭐list를 9로 채운다.
        System.out.println("list="+list); //list=[9, 9, 9, 9, 9]

        //⭐list와 같은 크기의 새로운 list를 생성하고 2로 채운다. 단, 결과는 변경불가
        List newList = nCopies(list.size(), 2);
        System.out.println("newList="+newList); //newList=[2, 2, 2, 2, 2]

        System.out.println(disjoint(list, newList)); // ⭐공통 요소가 없으면 true , true

        //⭐newList의 요소값들을 list에 복사
        copy(list, newList);
        System.out.println("newList="+newList); //newList=[2, 2, 2, 2, 2]
        System.out.println("list="+list); //list=[2, 2, 2, 2, 2]

        //⭐list의 요소값 2를 전부 1로 바꿈
        replaceAll(list, 2, 1);
        System.out.println("list="+list); //list=[1, 1, 1, 1, 1]

        //⭐enumeration 반환
        Enumeration e = enumeration(list); // Enumeration 타입
        ArrayList list2 = list(e); // list(Enumeration e)를 사용해 순회된 AL반환 list2=[1, 1, 1, 1, 1]

        System.out.println("list2="+list2);
    }
}

• 람다식에서도 Collections.toC

컬렉션의 동기화 synchronized

• 멀티 쓰레드 (multi-thread) 프로그래밍에서 는 하나의 객체를 여러 쓰레드가 동시에 접근할 수 있기 때문에 데이터의 일관성 (consistency) 을 유지하기 위해서는 공유되는 객체에 동기화(synchronization)가 필요하다.

• Vector와 Hashtable과 같은 구버전(JDK 1.2 이전) 클래스들은 자체적으로 동기화 처리가 되어 있는데, 멀티쓰레드 프로그래밍이 아닌 경우에는 불필요한 기능이 되어 성능을 떨어뜨리는 요인이 된다.
  
  그래서 새로 추가된 ArrayList와 HashMap과 같은 컬렉션은 ⭐동기화를 자체적으로 처리하지 않고 필요한 경우에만 java.util.Collections클래스의 동기화 메서드를 이용해서 동기화처리가 가능하도록 변경하였다.

• Collections 클래스의 동기화 메서드 사용방법
  List syncList = Collections.synchronizedList(new ArrayList( ... ));

+ 참고 자료

• 자바의 정석 3판
• https://velog.velcdn.com/images/9to0/post/961e00c6-61f3-4e60-8dc9-fc4654fba0c2/image.png
• https://docs.oracle.com/en%2Fjava%2Fjavase%2F11%2Fdocs%2Fapi%2F%2F/java.base/java/util/Collections.html
• https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Iterable.html

🚩 List vs Set vs Map

• 상속계층도 확인하기
  

• 각 인터페이스의 특징
  

컬렉션 프레임워크

• 컬렉션 프레임웍이란, '데이터 군群을 저장하는 클래스들을 표준화한 설계'이다.

• JDK 1.2부터 컬렉션 프레임웍이 등장하면서 다양한 종류의 컬렉션 클래스가 추가되고 모든 컬렉션 클래스를 표준화된 방식으로 다룰 수 있도록 체계화 되었다.

• 컬렉션 프레임웍의 장점:
  ① 컬렉션(다수의 데이터)를 다루는 데 필요하고 다양한 풍부한 클래스를 제공
  ② 객체지향적 설계

  • 사용법을 익히기에 편리함.
  • 재사용성이 높은 코드를 작성

• ⭐ 컬렉션 프레임웍의 대표적 인터페이스 ❶List, ❷Set, ❸Map

  • List : 순서O, 데이터 중복O
    구현 클래스 : ArrayList, LinkedList, Stack, Vector 등
  • Set : 순서X, 데이터 중복X
    구현 클래스 : HashSet, TreeSet 등
  • Map : 키(key)와 값(value) 쌍(pair)로 이루어진 데이터 집합
    구현 클래스 : HashMap, TreeMap, Hashtable, Properties 등

List 인터페이스

• ⭐List 인터페이스는 중복을 허용하면서 저장순서가 유지되는 컬렉션을 구현하는 데 사용된다.

• 다양한 하위 구현클래스

  • ArrayList : 동기화 보장X
  • Vector : 동기화 보장
  • LinkedList
  • Stack

• List 사용 예제

import java.util.*;

class ArrayListEx1{
	public static void main(String[] args) {
    	//⭐배열 크기가 10인 ArrayList 객체 참조변수 list1 생성
		ArrayList list1 = new ArrayList(10);
        //⭐list1에 인티저 객체들 순서대로 추가. 단, 기본형을 넣어도 오토박싱되어 무관
		list1.add(new Integer(5));
		list1.add(new Integer(4));
		list1.add(new Integer(2));
		list1.add(new Integer(0));
		list1.add(new Integer(1));
		list1.add(new Integer(3));

		//⭐list2에는 list1의 1번인덱스부터 3번인덱스까지 추출한 값 담김
		ArrayList list2 = new ArrayList(list1.subList(1,4));
        //🔥사용자 정의 static 메서드 print
		print(list1, list2);

		Collections.sort(list1);	//⭐ list1과 list2를 정렬한다.
		Collections.sort(list2);	// Collections.sort(List l)
		print(list1, list2);
		//⭐containsAll 메서드는 해당 컬렉션 요소 포함여부 boolean으로 반환. true
		System.out.println("list1.containsAll(list2):" + list1.containsAll(list2));

		//⭐ add()메서드로 int가 아닌 String추가 (Object 배열)
		list2.add("B");
		list2.add("C");
        //⭐특정 인덱스에 추가할수도 있음.
		list2.add(3, "A");
		print(list1, list2);

		//⭐set은 update의 개념. 3번째 인덱스의 value "AA"로 바꾸기
		list2.set(3, "AA");
		print(list1, list2);

		//⭐list1에서 list2와 겹치는 부분만 남기고 나머지는 삭제한다.
		System.out.println("list1.retainAll(list2):" + list1.retainAll(list2));
		print(list1, list2);

		//💡⭐ list2에서 list1에 포함된 객체들을 삭제한다.
        //💡⭐ i의 값을 list2.size()-1부터 시작하여 0까지 감산
		for(int i= list2.size()-1; i >= 0; i--) {
        	//⭐list1이 list2의 i인덱스 요소를 가지고 있다면
			if(list1.contains(list2.get(i)))
            	//⭐list2에서 그 i번째 요소를 삭제한다.
				list2.remove(i);
		}
		print(list1, list2);
	} // main의 끝

	static void print(ArrayList list1, ArrayList list2) {
		System.out.println("list1:"+list1);
		System.out.println("list2:"+list2);
		System.out.println();
	}
} // class

<실행결과>
list1:[5, 4, 2, 0, 1, 3]
list2:[4, 2, 0]

list1:[0, 1, 2, 3, 4, 5]
list2:[0, 2, 4]

list1.containsAll(list2):true
list1:[0, 1, 2, 3, 4, 5]
list2:[0, 2, 4, A, B, C]

list1:[0, 1, 2, 3, 4, 5]
list2:[0, 2, 4, AA, B, C]

list1.retainAll(list2):true
list1:[0, 2, 4]
list2:[0, 2, 4, AA, B, C]

list1:[0, 2, 4]
list2:[AA, B, C]

Set 인터페이스

• ⭐Set 인터페이스는 중복을 허용하지 않고 저장순서가 유지되지 않는 컬렉션 클래스를 구현하는데 사용된다.

• HashSet, TreeSet 등이 존재한다.

• HashSet에 새로운 요소를 추가할 때는 add메서드나 addAll메서드를 사용하는데, 만일 HashSet에 이미 저장되어 있는 요소와 중복된 요소를 추가하고자 한다면 이 메서드들은 false를 반환함으로써 중복된 요소이기 때문에 추가에 실패했다는 것을 알려준다.
  ➡️ 이러한 HashSet의 특징을 이용하여, 컬렉션 내의 중복 요소들을 쉽게 제거할 수 있다.

Map 인터페이스

• ⭐Map 인터페이스는 키(key)와 값(value)을 하나의 쌍으로 묶어서 저장하는 컬렉션 클래스를 구현하는데 사용된다.
  ⭐키(Key)는 중복X, 값(Value)는 중복O(허용)
  🌟<기존에 저장된 데이터와 중복된 키와 값을 저장하면> 기존의 값은 없어지고 마지막에 저장된 값이 남게된다.
  Hashtable(옛날), HashMap, LinkedHashMap, SortedMap, TreeMap 등이 있다. Map은 어떤 두 값을 연결한다는 의미에서 붙여진 이름.

import java.util.*;

class HashSetEx1 {
	public static void main(String[] args) {
		//⭐ objArr은 여러 중복된 문자열 값이 존재하는 배열. (단, Integer객체 하나 끼어있음)
		Object[] objArr = {"1",new Integer(1),"2","2","3","3","4","4","4"};
		//⭐ HashSet 객체 set에 저장. (타입을 보니, set의 메서드만 사용할 것이구나!)
		Set set = new HashSet();

		//⭐HashSet 객체 set이 objArr의 요소를 순회하며 add함)
		for(int i=0; i < objArr.length; i++) {
			set.add(objArr[i]);	// HashSet에 objArr의 요소들을 저장한다.
		}
		// HashSet에 저장된 요소들을 출력한다.
		//⭐ 결과는 [1,1,2,3,4] 일 것이다. 앞의 1은 Integer 타입이고, 뒤의 1은 String 타입이라 서로 다른 객체이다.
		System.out.println(set);
	}
}

<실행결과>
[1, 1, 2, 3, 4]

Map.Entry 인터페이스

• Map.Entry 인터페이스는 Map 인터페이스의 내부 인터페이스이다.
  (인터페이스도 내부 인터페이스가 존재할 수 있다.)

• Map 에 저장되는 key-value쌍을 다루기 위해 내부적으로 Entry 인터페이스를 정의해 놓았다. 이 것은 보다 객체지향적으로 설계하도록 유도하기 위한 것으로 Map 인터페이스를 구현하는 클래스에서는 Map.Entry 인터페이스도 함께 구현해야한다.

• 내부 구현 방식
  

Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);

// Map.Entry 인터페이스를 구현하고 있는 Key-Value 쌍을 가지고 있는 HashMap의 Node 객체들의 Set 집합을 반환
Set<Map.Entry<String, Integer>> entry = map.entrySet();

System.out.println(entry); // [1=a, 2=b, 3=c]

// Set을 순회하면서 Map.Entry를 구현한 Node 객체에서 key와 value를 얻어 출력
for (Map.Entry<String, Integer> e : entry) {
    System.out.printf("{ %s : %d }\n", e.getKey(), e.getValue());
}

<실행결과>
[a=1, b=2, c=3]

{ a : 1 }
{ b : 2 }
{ c : 3 }

• Map에서 스트림 활용하기

HashMap<String, Integer> map = new HashMap<>();
map.put("A", 3)
map.put("B", 4)

for(Map.Entry<String, Integer> entry : map.entrySet()) {
	System.out.println("entry.getKey() :" + entry.getKey());
    System.out.println("entry.getValue() :" + entry.getValue());
}

System.out.println( map.entrySet().stream()
					.map(Map.Entry<String, Integer> ::getKey)
                    .collect(Collectors.toList())
);

<실행결과>
entry.getKey() : A
entry.getValue() : 3
entry.getKey() : B
entry.getValue() : 4
[A, B]