자바 의 Collections 도구 류 및 Comparator 와 Comparable 의 차이

Collections 클래스 의 흔 한 방법
자바 는 Collection 류 의 인 스 턴 스 대상 을 처리 하기 위해 Collections 도구 류 를 제공 합 니 다.이 종 류 는 도구 류 이 고 내 부 는 모두 static 방법 이다.흔히 볼 수 있 는 몇 가지 사용 을 살 펴 보 자.
Collections.sort()
질서 있 는 List 를 정렬 합 니 다.정렬 규칙 을 사용자 정의 할 수 있 습 니 다.가장 기본 적 인 사용 보기:

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

public class Main {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList<>();
        arr.add(3);
        arr.add(1);
        arr.add(4);
        arr.add(2);

        System.out.println(arr); // [3, 1, 4, 2]
        Collections.sort(arr);
        System.out.println(arr); // [1, 2, 3, 4]
    }
}

정렬 규칙 이 지정 되 지 않 으 면 기본 정렬 에 따라 정렬 합 니 다.사용자 정의 규칙 의 예 를 보십시오.

public class Main {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList<>();
        arr.add(3);
        arr.add(1);
        arr.add(4);
        arr.add(2);

        System.out.println(arr); // [3, 1, 4, 2]
        Collections.sort(arr, new Comparator() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(arr); // [4, 3, 2, 1]
    }
}

Comparator 는 인터페이스 로 내부 의 compare 방법 을 실현 하면 주어진 규칙 에 따라 정렬 할 수 있 습 니 다.
위 정렬 예 에서 new Comparator () {} 는 자바 의 내부 익명 류 이 며, 자체 인 터 페 이 스 는 new 를 직접 사용 할 수 없습니다. 이것 은 실제 new 가 이 인터페이스의 실현 류 임 을 나타 냅 니 다.
Comparator 와 Comparable 의 차이
상기 예 에서 Comparator 를 사 용 했 는데 전자 와 마찬가지 로 Comparable 도 하나의 인터페이스 이다. 이들 이 나타 내 는 다른 점 은 다음 과 같다.

Comparable 은 정렬 인터페이스 이다.하나의 클래스 가 Comparable 인 터 페 이 스 를 실현 하면 이러한 지원 정렬

을 의미 합 니 다.

Comparator 는 비교 인터페이스 입 니 다. 우 리 는 특정한 종류의 순 서 를 제어 해 야 하 는데 이런 종류 자체 가 정렬 (즉, Comparable 인터페이스 가 실현 되 지 않 았 음) 을 지원 하지 않 는 다 면 우 리 는 '이런 종류의 비교 기' 를 만들어 정렬 할 수 있 습 니 다. 이 '비교 기' 는 Comparator 인터페이스 만 실현 하면 됩 니 다.

예 를 들 어 정렬 할 수 있 는 클래스 를 만 듭 니 다.

package com.DeeJay;

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

public class Main {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList<>();
        arr.add(new SortDemo(3));
        arr.add(new SortDemo(1));
        arr.add(new SortDemo(2));
        arr.add(new SortDemo(4));

        System.out.println(arr); // [sortDemo_3, sortDemo_1, sortDemo_2, sortDemo_4]

        Collections.sort(arr);

        System.out.println(arr); // [sortDemo_1, sortDemo_2, sortDemo_3, sortDemo_4]
    }
}
class SortDemo implements Comparable {
    int num;

    public SortDemo(int num) {
        this.num = num;
    }

    @Override
    public int compareTo(Object o) {
        SortDemo s = (SortDemo) o;
        if(this.num < s.num) {
            return -1;
        }else if(this.num > s.num) {
            return 1;
        }
        return 0;
          //         return this.num - s.num;           
        // return this.num - s.num;
    }

    @Override
    public String toString() {
        return "sortDemo_" + this.num;
    }
}

상기 예 에서 SortDemo 류 는 Comparable 인터페이스 1 을 실현 하고 compare To 방법 을 재 작성 하여 SortDemo 류 의 인 스 턴 스 대상 이 서로 비교 하여 정렬 할 수 있 도록 합 니 다. 직접 호출 Collections.sort() 하면 실 현 된 compare To 방법 에 따라 정렬 할 수 있 습 니 다. 추가 적 인 비교 논 리 를 입력 하지 않 아 도 됩 니 다.
상기 상황 에 대해 직접 쓸 수 없다 return this.num - s.num;. 예 를 들 어 byte a = -128; byte b = 1; System.out.println((byte) a - b); // 127 다시 컴 파 레이 터 를 사용 하 는 예 를 들 어, 이번 에는 우리 의 SortDemo 클래스 가 정렬 을 지원 하지 않 습 니 다. 컴 파 레이 터 를 실현 하 는 내부 익명 클래스 를 호출 하여 정렬 규칙 을 지정 합 니 다.

package com.DeeJay;

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

public class Main {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList<>();
        arr.add(new SortDemo(3));
        arr.add(new SortDemo(1));
        arr.add(new SortDemo(2));
        arr.add(new SortDemo(4));

        System.out.println(arr); // [sortDemo_3, sortDemo_1, sortDemo_2, sortDemo_4]

        Collections.sort(arr, new Comparator() {  //         
            @Override
            public int compare(SortDemo o1, SortDemo o2) {
                return o1.num - o2.num;
            }
        });

        System.out.println(arr); // [sortDemo_1, sortDemo_2, sortDemo_3, sortDemo_4]
    }
}
class SortDemo{
    int num;

    public SortDemo(int num) {
        this.num = num;
    }

    @Override
    public String toString() {
        return "sortDemo_" + this.num;
    }
}

Collections.binarySearch
지정 한 List 와 key 의 index 를 되 돌려 줍 니 다.이 방법 에 대해 주의 할 점 이 있 습 니 다.
검색 을 하려 면 Collections. sort () 를 호출 하여 자 연 스 러 운 순서 로 정렬 해 야 합 니 다. 그렇지 않 으 면 되 돌아 오 는 결과 에 문제 가 있 을 수 있 습 니 다. Collections. sort () 를 호출 하려 면 List 내부 의 유형 이 Comparable 인 터 페 이 스 를 실현 하도록 해 야 합 니 다.
Integer 라 는 자바 에 대해 서 는 이미 Comparable 클래스 를 실현 하 였 으 며, 처리 하지 않 아 도 되 지만, 우리 가 정의 한 클래스 는 Comparable 을 실현 해 야 합 니 다.

package com.DeeJay;

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

public class Main {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList<>();
        arr.add(3);
        arr.add(1);
        arr.add(2);
        arr.add(4);

        Collections.sort(arr); //   binarySearch      sort
        System.out.println(Collections.binarySearch(arr, 3));
    }
}

Collections.copy(destList, targetList)
이 방법 이 주의해 야 할 점 은 목적 List 의 길이 가 복 제 될 targetList 보다 짧 지 않도록 해 야 한 다 는 것 이다.

package com.DeeJay;

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

public class Main {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList<>();
        arr.add(3);
        arr.add(1);
        arr.add(2);
        arr.add(4);
        ArrayList arr2 = new ArrayList<>();
        arr2.add(null);
        arr2.add(null);
        arr2.add(null);
        arr2.add(null);
        Collections.copy(arr2, arr);
        System.out.println(arr2); // [3, 1, 2, 4]
    }
}

Collections.fill() Collections.reverse() Collections.shuffle()

package com.DeeJay;

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

public class Main {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList<>();
        arr.add(3);
        arr.add(1);
        arr.add(2);
        arr.add(4);
        Collections.sort(arr);
        System.out.println(arr);// [1, 2, 3, 4]
        Collections.reverse(arr);
        System.out.println(arr); // [4, 3, 2, 1]
        Collections.shuffle(arr);
        System.out.println(arr); // [1, 3, 2, 4]       
        Collections.fill(arr, null);
        System.out.println(arr); // [null, null, null, null]
    }
}