컬렉션 프레임워크 - 순회, 정렬, 전체 정리

순회 - 직접 구현하는 Iterable, Iterator

자료 구조의 구현과 관계 없이 모든 자료 구조를 동일한 방법으로 순회할 수 있는 일관성 있는 방법이 있다면, 자료 구조를 사용하는 개발자 입장에서 매우 편리할 것이다.
자바는 이런 문제를 해결하기 위해 Iterable 과 Iterator 인터페이스를 제공

Iterable 인터페이스의 주요 메서드 ```java
public interface Iterable<T> {
 Iterator<T> iterator();
}

Iterator 인터페이스의 주요 메서드 ```java
public interface Iterator<E> {
 boolean hasNext();
 E next();
}

hasNext() : 다음 요소가 있는지 확인, 다음 요소가 없다면 false
next() : 다음 요소를 반환, 내부에 있는 위치를 다음으로 이동

자료구조에 들어있는 데이터를 처음부터 끝까지 순회하는 방법은 단순

public class MyArrayIterator implements Iterator<Integer> {
    //배열을 반복 할 수 있는 반복자

    private int curIndex = -1;
    //인덱스는 0부터 시작하기 때문에 -1을 갖는다.
    //다음 항목 조회시 0이 된다.
    private int[] targetArr;

    public MyArrayIterator(int[] targetArr) {
        this.targetArr = targetArr;
    }

    @Override
    public boolean hasNext() {
        return curIndex < targetArr.length - 1; //마지막까지 순회
    }

    @Override
    public Integer next() {
        return targetArr[++curIndex];
    }
}

curIndex : 현재 인덱스, next를 호출할 때마다 하나씩 증가
hasNext() : 다음 항목이 있는지 검사, 배열의 끝에 다다르면, 순회 종료, false를 반환

• 참고로 인덱스의 길이는 0부터 시작하므로 배열의 길이에 1을 빼야 마지막 인덱스 나옴
  next() : 다음 항목을 반환
• currentIndex 를 하나 증가하고 항목을 반환한다
• 인덱스는 0 부터 시작하기 때문에 currentIndex 는 처음에는 -1 을 가진다. 이렇게 하면 다음 항목을 조회했을 때 0 이 된다. 따라서 처음 next() 를 호출하면 0 번 인덱스를 가리킨다.

public class MyArray implements Iterable<Integer> {

    private int[] numbers;

    public MyArray(int[] numbers) {
        this.numbers = numbers;
    }

    @Override
    public Iterator<Integer> iterator() {
        return new MyArrayIterator(numbers);
    }
}

Iterable 인터페이스를 구현

• 반복자를 반환하면 된다.
• 반복자인 MyArrayIterator 반환
• MyArrayIterator 는 생상자를 통해 MyArray 의 내부 배열인 numbers 를 참조

public class MyArrayMain {
    public static void main(String[] args) {
        MyArray array = new MyArray(new int[]{1,2,3,4}); //반복 할 수 있는 애다.

        Iterator<Integer> iterator = array.iterator(); //반복자를 반환
        System.out.println("iterator = " + iterator);
        while (iterator.hasNext()){
            Integer next = iterator.next(); //iterator의 next를 호출
            System.out.println("next = " + next);
        }

        System.out.println("for-each 사용");
        for (int val : array) {
            System.out.println("val = " + val);
        }
    }
}

• MyArray 는 Iterable (반복할 수 있는) 인터페이스를 구현한다. 따라서 MyArray 는 반복할 수 있다는 의미가 된다.
• Iterable 인터페이스를 구현하면 iterator() 메서드를 구현해야 한다. 이 메서드는 Iterator 인터페이스를 구현한 반복자를 반환한다. 여기서는 MyArrayIterator 를 생성해서 반환했다.

• 처음에 currentIndex = -1 이다.

• next() 를 처음 호출
• currentIndex = 0 으로 증가
• 1 반환

• next() 호출
• currentIndex = 1 로 증가
• 2 반환

• next() 호출
• currentIndex = 3 으로 증가
• 4반환
• 이후에 hasNext() 를 호출하면 currentIndex(3) < length(4) -1 에 의해서 종료

순회 - 향상된 for문

Iterable과 향상된 for문(Enhanced For Loop)
Iterable , Iterator 를 사용하면 또 하나의 큰 장점을 얻을 수 있다. 다음 코드를 보자

//추가
System.out.println("for-each 사용");
for (int value : myArray) {
 System.out.println("value = " + value);
}

for-each문은 자룍구조를 순회하는 것이 목적

for (int value : myArray) {
 System.out.println("value = " + value);
}

자바는 컴파일 시점에 다음과 같이 코드를 변경

while (iterator.hasNext()) {
 Integer value = iterator.next();
 System.out.println("value = " + value);
}

Iterable은 반복 가능한, 우리가 만든 MyArray는 Iterable을 구현. 따라서 MyArray는 반복 가능하다는 의미. MyArray가 반복 가능하기 때문에 iterator를 반환, for-each문 작동

자바가 제공하는 Iterable, Iterator

• 자바 컬렉션 -> 배열, 연결, 해시, 셋, 연결 해시 셋, 트리 셋 등등 다양한 자료 구조를제공
• Collection 인터페이스의 상위에 Iterable 이 있다는 것은 모든 컬렉션을 Iterable 과
  Iterator 를 사용해서 순회할 수 있다는 뜻이다.
• Map 의 경우 Key 뿐만 아니라 Value 까지 있기 때문에 바로 순회를 할 수는 없다. 대신에 Key 나 Value 를 정해서 순회할 수 있는데, keySet() , values() 를 호출하면 Set , Collection 을 반환하기 때문에 Key 나 Value 를 정해서 순회할 수 있다. 물론 Entry 를 Set 구조로 반환하는 entrySet() 도 순회가 가능하다.

public class JavaIterableMain {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        Set<Integer> set = new HashSet<>();
        //HashSet -> keyIterator를 가져온다. 
        set.add(1);
        set.add(2);
        set.add(3);

        printAll(list.iterator());
        printAll(set.iterator());

        foreach(list);
        //list만 받으면 list 전용

        foreach(set);
        //set 전용
        //java에서 foreach가 일어날 수 있는 조건 -> iterable이 적용 되어 있어야 한다.
        //iterable을 받으면 범용성이 높아진다.
    }

    //iterator만 있으면 순환 가능 
    private static void printAll(Iterator<Integer> iterator) {
        System.out.println("iterator.getClass() = " + iterator.getClass());
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    private static void foreach(Iterable<Integer> iterable) {
        System.out.println("iterator.getClass() = " + iterable.getClass());
        for (Integer i : iterable) {
            System.out.println("i = " + i);
        }
    }
}

Iterator, Iterable은 인테페이스. -> 다형성을 적극 활용 가능
printAll() , foreach() 메서드는 새로운 자료 구조가 추가되어도 해당 자료 구조가 Iterator , Iterable 만 구현하고 있다면 코드 변경 없이 사용할 수 있다

정렬 - Comparable, Comparator

public class SortMain1 {
    public static void main(String[] args) {
        Integer[] array = {3, 2, 1};
        System.out.println("array.toString() = " + array.toString());

        System.out.println("기본 정렬 후");
        Arrays.sort(array);
        System.out.println("Arrays.toString(array) = " + Arrays.toString(array));

    }
}

• Arrays.sort() 를 사용하면 배열에 들어있는 데이터를 순서대로 정렬

비교자 - Comparator
비교자( Comparator )를 사용하면 된다. 이름 그대로 두 값을 비교할 때 비교 기준을 직접 제공할 수 있다

public interface Comparator<T> {
 int compare(T o1, T o2);
}

두 인수를 비교해서 결과 값을 반환하면 된다.

• 첫 번째 인수가 더 작으면 음수, 예( -1 )
• 두 값이 같으면 0
• 첫 번째 인수가 더 크면 양수, 예( 1 )

public class SortMain2 {
    public static void main(String[] args) {
        Integer[] array = {3, 2, 1};
        System.out.println("array.toString() = " + array.toString());

        System.out.println("Comparator 비교");
        Arrays.sort(array, new AscComparator());
        System.out.println("AscComparator : " + Arrays.toString(array));

        Arrays.sort(array, new DesComparator());
        System.out.println("DesComparator : " + Arrays.toString(array));

        Arrays.sort(array, new AscComparator().reversed());
        System.out.println("AscComparator.reversed" + Arrays.toString(array));

        System.out.println("기본 정렬 후");
        Arrays.sort(array);
        System.out.println("Arrays.toString(array) = " + Arrays.toString(array));

    }
}

Arrays.sort() 를 사용할 때 비교자( Comparator )를 넘겨주면 알고리즘에서 어떤 값이 더 큰지 두 값을 비교할때, 비교자를 사용한다.
DescComparator 를 사용하면 숫자가 점점 내려가는 내림차순으로 정렬된다. 왜냐하면 DescComparator 구현의 마지막에 -1 을 곱해주었기 때문에 이렇게 하면 양수는 음수로, 음수는 양수로 반환된다. 쉽게 이야기해서 계산의 결과가 반대로 된다. 따라서 정렬의 결과도 반대가 된다.

new AscComparator().reversed()

정렬을 반대로 하고 싶으면 reversed() 메서드를 사용하면 된다. 이렇게 하면 비교의 결과를 반대로 변경한다. 앞서 설명한 -1 을 곱한 것과 같은 결과가 나온다.

Comparable, Comparator

Comparable 인터페이스를 구현하면 된다. 이 인터페이스는 이름 그대로 비교 가능한, 비교할 수 있는 이라는 뜻으로, 객체에 비교 기능을 추가해 준다.

public interface Comparable<T> {
 public int compareTo(T o);
}

blic class MyUser implements Comparable<MyUser> {

    private String id;
    private int age;

    public MyUser(String id, int age) {
        this.id = id;
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(MyUser o) {
        return age < o.age ? -1 : (age == o.age ? 0 : 1);
    }

    @Override
    public String toString() {
        return "MyUser{" +
                "id='" + id + '\'' +
                ", age=" + age +
                '}';
    }
}

public class SortMain3 {
    public static void main(String[] args) {
        MyUser myUser1 = new MyUser("a", 30);
        MyUser myUser2 = new MyUser("b", 20);
        MyUser myUser3 = new MyUser("c", 10);

        MyUser[] userArray = {myUser1, myUser2, myUser3};
        System.out.println("기본 데이터");
        System.out.println(Arrays.toString(userArray));

        System.out.println("Comparable 기본 정렬");
        Arrays.sort(userArray);
        System.out.println(Arrays.toString(userArray));

        System.out.println("IdComparator 정렬");
        Arrays.sort(userArray, new IdComparator());
        System.out.println(Arrays.toString(userArray));

        System.out.println("IdComparator().reversed() 정렬");
        Arrays.sort(userArray, new IdComparator().reversed());
        System.out.println(Arrays.toString(userArray));
    }
}

다른 방식으로 정렬

public class IdComparator implements Comparator<MyUser> {
    @Override
    public int compare(MyUser o1, MyUser o2) {
        return o1.getId().compareTo(o2.getId());
    }
}

  System.out.println("IdComparator 정렬");
        Arrays.sort(userArray, new IdComparator());
        System.out.println(Arrays.toString(userArray));

        System.out.println("IdComparator().reversed() 정렬");
        Arrays.sort(userArray, new IdComparator().reversed());
        System.out.println(Arrays.toString(userArray));

Arrays.sort(array, Comparator)
기본 정렬이 아니라 정렬 방식을 지정하고 싶다면, Arrays.sort의 인수로 비교자를 만들어서 넘겨주면 된다. Comparable을 무시하고 별도로 전달한 비교자를 사용해서 정렬

Comparable, Comparator 정리
객체의 기본 정렬 방법은 객체에 Comparable 를 구현해서 정의. 객체는 이름 그대로 비교할 수 있는 객체가 되고 기본 정렬 방법을 가진다
우 비교자(Comparator)를 별도로 구현해서 정렬 메서드에 전달하면 된다. 이 경우 전달한 Comparator 가 항상 우선권을 가진다
Integer , String 같은 기본 객체들은 대부분 Comparable 을 구현

정렬3 - Comparable, Comparator

public class SortMain4 {
    public static void main(String[] args) {
        MyUser myUser1 = new MyUser("a", 30);
        MyUser myUser2 = new MyUser("b", 20);
        MyUser myUser3 = new MyUser("c", 10);

        List<MyUser> list = new ArrayList<>();
        list.add(myUser1);
        list.add(myUser2);
        list.add(myUser3);
        System.out.println("기본 데이터");
        System.out.println("list = " + list);


        System.out.println("Comparable 기본 정렬");
        list.sort(null); // 비교자 사용 안하려면 null
        //Collections.sort(list);
        System.out.println("list = " + list);

        System.out.println("IdComparator 정렬");
        list.sort(new IdComparator()); //IdComparator 기준으로 정렬
        //Collections.sort(list, new IdComparator());
        System.out.println("list = " + list);
    }
}

Collections.sort(list)

리스트는 순서가 있는 컬렉션이므로 정렬할 수 있다. 이 메서드를 사용하면 기본 정렬이 적용된다.
하지만 이 방식보다는 객체 스스로 정렬 메서드를 가지고 있는 list.sort() 사용을 더 권장한다참고로 둘의 결과는 같다.

• list.sort(null)
  별도의 비교자가 없으므로 Comparable 로 비교해서 정렬한다. 자연적인 순서로 비교한다.
  자바 1.8 부터 사용

• Collections.sort(list, new IdComparator())
  별도의 비교자로 비교하고 싶다면 다음 인자에 비교자를 넘기면 된다. 하지만 이 방식보다는 객체 스스로 정렬 메서드를 가지고 있는 list.sort() 사용을 더 권장한다. 참고로 둘의 결과는 같다.

Tree 구조와 정렬

이진 탐색 트리는 데이터를 저장할 때 왼쪽 노드에 저장해야 할 지, 오른쪽 노드에 저장해야 할 지 비교가 필요

public class SortMain5 {
    public static void main(String[] args) {
        MyUser myUser1 = new MyUser("a", 30);
        MyUser myUser2 = new MyUser("b", 20);
        MyUser myUser3 = new MyUser("c", 10);

        TreeSet<MyUser> tree = new TreeSet<>();
        tree.add(myUser1);
        tree.add(myUser2);
        tree.add(myUser3);
        System.out.println("기본 데이터");
        System.out.println("tree = " + tree);

        TreeSet<MyUser> tree2 = new TreeSet<>(new IdComparator());
        tree2.add(myUser1);
        tree2.add(myUser3);
        System.out.println("IdComparator 정렬");
        System.out.println("tree2 = " + tree2);

    }
}

new TreeSet<>() `

TreeSet 을 생성할 때 별도의 비교자를 제공하지 않으면 객체가 구현한 Comparable 을 사용

new TreeSet<>(new IdComparator())

TreeSet 을 생성할 때 별도의 비교자를 제공하면 Comparable 대신 비교자( Comparator )를 사용

컬랙션 유틸

public class CollectionsSortMain {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        Integer max = Collections.max(list);
        Integer min = Collections.min(list);

        System.out.println("max = " + max);
        System.out.println("min = " + min);
        System.out.println("list = " + list);
        Collections.shuffle(list);
        System.out.println("shuffleList = " + list);
        Collections.sort(list);
        System.out.println("sortList = " + list);
        Collections.reverse(list);
        System.out.println("reverseList = " + list);
    }
}

Collections 정렬 관련 메서드

• max : 정렬 기준으로 최대 값을 찾아서 반환한다.
• min : 정렬 기준으로 최소 값을 찾아서 반환한다.
• shuffle : 컬렉션을 랜덤하게 섞는다.
• sort : 정렬 기준으로 컬렉션을 정렬한다.
• reverse : 정렬 기준의 반대로 컬렉션을 정렬한다.

public class OfMain {
    public static void main(String[] args) {
        //편리한 불변 컬렉션 생성
        List<Integer> list = List.of(1, 2, 3);
        Set<Integer> set = Set.of(1, 2, 3);
        Map<Integer, String> map = Map.of(1, "one", 2, "two");

        //list.add(4); => 불변이기에 변경 불가능

        System.out.println("list = " + list);
        System.out.println("set = " + set);
        System.out.println("map = " + map);
        System.out.println("list = " + list.getClass());
    }
}

List.of(...) : 를 사용하면 컬렉션을 편리하게 생성할 수 있다. 단 이때는 가변이 아니라 불변 컬렉션이 생성 된다.
List , Set , Map 모두 of() 메서드를 지원

public class ImmutableMain {
    public static void main(String[] args) {
        //불변
        List<Integer> list = List.of(1,2,3);
        
        //가변
        ArrayList<Integer> mutable = new ArrayList<>(list);
        mutable.add(4);
        System.out.println("mutable = " + mutable);
        System.out.println("mutable.getClass() = " + mutable.getClass());
        
        //불변 
        List<Integer> list2 = Collections.unmodifiableList(mutable);
        System.out.println("list2.getClass() = " + list2.getClass());
        // list2.add(4); => 불변이기에 변경 불가능
    }
}

불변 리스트를 가변 리스트로 전환하려면 new ArrayList<>() 를 사용하면 된다
리스트를 불변 리스트로 전환하려면 Collections.unmodifiableList() 를 사용

public class EmptyListMain {
    public static void main(String[] args) {
        //빈 가변
        List<Integer> list = new ArrayList<>();
        List<Integer> list2 = new LinkedList<>();

        //빈 불변
        List<Integer> list3 = Collections.emptyList();
        List<Integer> list4 = java.util.List.of();

        System.out.println("list3.getClass() = " + list3.getClass());
        System.out.println("list4.getClass() = " + list4.getClass());
    }
}

빈 가변 리스트는 원하는 컬렉션의 구현체를 직접 생성
빈 불변 리스트 2가지 생성 방법

• Collections.emptyList() : 자바5부터 제공되는 기능이다.
• List.of() : 자바9부터 제공되는 최신 기능이다.
• List.of() 가 더 간결하고, List.of(1,2,3) 도 불변이기 때문에 사용법에 일관성이 있다

Arrays.asList()
자바 9를 사용한다면 List.of() 를 권장

List<Integer> list = Arrays.asList(1, 2, 3);
List<Integer> list = List.of(1, 2, 3);

Arrays.asList() 로 생성된 리스트는 고정된 크기를 가지지만, 요소들은 변경
즉 리스트의 길이는 변경 X, 기존 위치에 있는 요소들은 다른 요소로 교체 가능

• set() 을 통해 요소를 변경할 수 있다.
• add() , remove() 같은 메서드를 호출하면 예외가 발생한다. 크기를 변경할 수 없다

List.of() 를 사용하는 것을 권장한다. 다음과 같은 경우 Arrays.asList() 를 선택할 수
있다

멀티스레드 동기화

public class SyncMain {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        System.out.println("list.getClass() = " + list.getClass());
        //동기화 문제 발생 안하는 환경으로 만든다
        List<Integer> synchronizedList = Collections.synchronizedList(list);
        System.out.println("synchronizedList = " + synchronizedList.getClass());
    }
}

• Collections.synchronizedList 를 사용하면 일반 리스트를 멀티스레드 상황에서 동기화 문제가 발생하지 않는 안전한 리스트로 만들 수 있다.