[윤성우의 열혈 Java 프로그래밍] Chapter 24 - 컬렉션 프레임워크 2

Update: 2023.02.16 Updated: 2023.02.17

카테고리: Java lang

태그: java

24-1. 컬렉션 기반 알고리즘

Collections에 정의된 static 메소드를 사용하는 것은 간단하다.
하지만, 제네릭과 와일드카드 기반으로 정의된 메소드의 의미를 해석하는 것은 간단하지 않다.

- 정렬

sort 메소드의 모습은 다음과 같다.

/**
인자로 List<T>의 인스턴스는 모두 전달 가능
단, T는 Comparable<? extends T> 인터페이스를 구현한 상태이어야 한다.
*/
public static <T extends Comparable<? super T>> void sort(List<T> list)

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

class Car implements Comparable<Car> {
   protected int disp; // 배기량

   public Car(int disp) {
       this.disp = disp;
   }

   @Override
   public String toString() {
       return "cc: " + disp;
   }

   @Override
   public int compareTo(Car car) {
       return this.disp - car.disp;
   }
}

class ECar extends Car {
   private int battery;    // 배기량

   public ECar(int disp, int battery) {
       super(disp);
       this.battery = battery;
   }

   @Override
   public String toString() {
       return String.format("cc: %s, ba: %s", disp, battery);
   }
}

public class CarSortCollections {
    public static void main(String[] args) {
        List<ECar> list = new ArrayList<>();
        list.add(new ECar(1200, 99));
        list.add(new ECar(3000, 55));
        list.add(new ECar(1800, 87));

        Collections.sort(list);

        for (Iterator itr = list.iterator(); itr.hasNext();) {
            System.out.println(itr.next());
        }
    }
}

- 정렬: Comparator<T> 기반

sort 메소드 중 호출 시 정렬의 기준을 결정할 수 있는 형태로 정의된 메소드도 있다.

public static <T> void sort(List<T> list,, Comparator<? super T> c)

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Car implements Comparable<Car> {
    protected int disp; // 배기량

    public Car(int disp) {
        this.disp = disp;
    }

    @Override
    public String toString() {
        return "cc: " + disp;
    }

    @Override
    public int compareTo(Car car) {
        return this.disp - car.disp;
    }
}

class ECar extends Car {
    private int battery;    // 배기량

    public ECar(int disp, int battery) {
        super(disp);
        this.battery = battery;
    }

    @Override
    public String toString() {
        return String.format("cc: %s, ba: %s", disp, battery);
    }
}

class CarComp implements Comparator<Car> {
    @Override
    public int compare(Car car1, Car car2) {
        return car1.disp - car2.disp;
    }
}

public class CarComparator {
    public static void main(String[] args) {
        List<Car> cars = new ArrayList<>();
        cars.add(new Car(1800));
        cars.add(new Car(1200));
        cars.add(new Car(3000));

        List<ECar> eCars = new ArrayList<>();
        eCars.add(new ECar(3000, 55));
        eCars.add(new ECar(1800, 87));
        eCars.add(new ECar(1200, 99));

        CarComp comp = new CarComp();

        // 각각 정렬
        Collections.sort(cars, comp);
        Collections.sort(eCars, comp);

        for (Car car : cars) {
            System.out.print(car + "\t");
        }
        System.out.println();
        for (ECar eCar : eCars) {
            System.out.print(eCar + "\t");
        }
    }
}

- 찾기

정렬된 리스트를 대상으로 특정 인스턴스를 찾을 때 사용할 수 있는 메소드가 있다.

// list에서 key를 찾아 그 인덱스 값 반호나, 못 찾으면 음의 정수 반환
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Car implements Comparable<Car> {
    protected int disp; // 배기량

    public Car(int disp) {
        this.disp = disp;
    }

    @Override
    public String toString() {
        return "cc: " + disp;
    }

    @Override
    public int compareTo(Car car) {
        return this.disp - car.disp;
    }
}

class ECar extends Car {
    private int battery;    // 배기량

    public ECar(int disp, int battery) {
        super(disp);
        this.battery = battery;
    }

    @Override
    public String toString() {
        return String.format("cc: %s, ba: %s", disp, battery);
    }
}

public class CarBinarySearch {
    public static void main(String[] args) {
        List<ECar> eCars = new ArrayList<>();
        eCars.add(new ECar(3000, 55));
        eCars.add(new ECar(1800, 87));
        eCars.add(new ECar(1200, 99));

        Collections.sort(eCars);
        int idx = Collections.binarySearch(eCars, new ECar(1800, 87));
        System.out.println(eCars.get(idx));
    }
}

- 찾기: Comparator<T> 기반

// list에서 key를 찾는데 c의 기준을 적용하여 찾는다.
public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

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

class StrComp implements Comparator<String> {
    @Override
    public int compare(String s1, String s2) {
        return s1.compareToIgnoreCase(s2);
    }
}

public class StringComparator {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Robot", "Apple", "Box");

        StrComp comp = new StrComp();   // 정렬과 탐색의 기준

        Collections.sort(list, comp);   // 정렬

        int idx = Collections.binarySearch(list, "Robot", comp);
        System.out.println(list.get(idx));
    }
}

- 복사

// src의 내용을 dest로 복사
public static <T> void copy(List<? super T> dest, List<? extends T> src)

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

public class CopyList {
    public static void main(String[] args) {
        List<String> src = Arrays.asList("Box", "Apple", "Toy", "Robot");

        /**
         주의!
         매개변수 dest에 전달되는 컬렉션 인스턴스의 저장 공간이 src에 전달되는 컬렉션 인스턴스의 저장공간보다 크거나 최소한 같아야 한다!
         */
        List<String> dest = new ArrayList<>();
        for (int i = 0; i < src.size(); i++) {
            dest.add("");
        }

        Collections.copy(dest,src);

        System.out.println(src);
        System.out.println(dest);
    }
}

hi~ June!!