자바 기반 List 내 요소 의 정렬 성능 비교

개술
일상적인 개발 에서 일부 데 이 터 를 얻 은 후에 일정한 규칙 에 따라 이 데 이 터 를 정렬 해 야 할 수도 있다.JAVA 에 서 는 동적 배열 ArrayList 가 데 이 터 를 저장 하 는 데 자주 사용 되 기 때문에 ArrayList 의 요 소 를 어떻게 효율적으로 정렬 하고 조건 에 맞 는 데이터 세트 를 형성 하 는 지 는 일상적인 개발 에서 반드시 고려 해 야 할 문제 이다.본 고 는 집합 프레임 워 크 가 제공 하 는 Collections.sort 방법,Comparable 인터페이스 실현,그리고 JAVA 8 stream 흐름 에서 제공 하 는 정렬 방법 을 분석 하 는 동시에 같은 조건 에 따라 데이터 세트 크기 의 정렬 성능 을 비교 할 것 이다.
2.조건 에 따라 몇 가지 방안 과 성능 대 비 를 정렬 한다.
2.1 집합 프레임 워 크 가 제공 하 는 Collections.sort 를 이용 하여 정렬

private ArrayList<StreamConfig> testCollectionSort(ArrayList<StreamConfig> lists) {
        Collections.sort(lists, new Comparator<StreamConfig>() {
            @Override
            public int compare(StreamConfig s1, StreamConfig s2) {
                return s2.getLostThreshold() - s1.getLostThreshold();
            }
        });
        return lists;
    }

@Data
@ToString
public class StreamConfig {

    /**
     *   
     */
    private Long id;

    /**
     *     (    )
     */
    private Integer detectRate;

    /**
     *     
     */
    private Integer lostThreshold;

    /**
     *     (  : )
     */
    private Integer reportRate;

    /**
     *     
     */
    private Date createTime;

    /**
     *     
     */
    private Date modifyTime;
}

 long startTime = System.currentTimeMillis();
    log.info("Collection.sort        ：{}", System.currentTimeMillis());
    ArrayList<StreamConfig> list = testCollectionSort(lists);
    long endTime = System.currentTimeMillis();
    log.info("Collection.sort       ：{} ms", endTime - startTime);

2.2 Comparable 인터페이스 실현

@Data
@ToString
public class StreamConfig implements Comparable<StreamConfig>{

    /**
     *   
     */
    private Long id;

    /**
     *     (    )
     */
    private Integer detectRate;

    /**
     *     (           )
     */
    private Integer lostThreshold;

    /**
     *     (  : )
     */
    private Integer reportRate;

    /**
     *     
     */
    private Date createTime;

    /**
     *     
     */
    private Date modifyTime;

    /**
     *   
     */
    private String remark;

    /**
     * nodeCode
     */
    private String nodeCode;

    /**
     *    Id
     */
    private String unitId;

    @Override
    public int compareTo(StreamConfig o) {
        return this.getLostThreshold() - o.getLostThreshold();
    }
}

 long comparableStartTime = System.currentTimeMillis();
        Collections.sort(list3);
        long comparableEndTime = System.currentTimeMillis();
        log.info("Comparable       ：{}", comparableEndTime - comparableStartTime);

2.3 JAVA 8 stream 흐름 을 이용 하여 정렬

 long streamStartTime = System.currentTimeMillis();
        log.info("java 8 stream      ：{}", streamStartTime);
        List<StreamConfig> collect = list2.stream().sorted(Comparator.comparing(StreamConfig::getLostThreshold)).collect(Collectors.toList());
        log.info("java 8 stream       ：{} ms", System.currentTimeMillis() - streamStartTime);

2.4 성능 대비
테스트 방안:
Collection.sort 와 Comparable 인 터 페 이 스 를 실현 하 는 두 가지 방법의 상호 방 해 를 방지 하기 위해 Comparable 방안 의 단독 테스트 를 실현 할 것 이다.데이터 양 집 은 각각 1000,10000,100000 이 고 결과 단 위 는 밀리초(ms)이 며 각 데이터 세트 는 다섯 번 테스트 하여 평균 값 을 취한 다.
테스트 코드 는 다음 과 같 습 니 다:

public String test() {
        ArrayList<StreamConfig> lists = new ArrayList<>(100000);
        for (int i = 0; i < 100000; i++) {
            StreamConfig streamConfig = new StreamConfig();
            streamConfig.setReportRate((int) (Math.random() * 10000));
            streamConfig.setLostThreshold((int) (Math.random() * 100000));
            streamConfig.setDetectRate((int) (Math.random() * 10000));
            streamConfig.setCreateTime(randomDate("2019-01-01", "2021-05-31"));
            streamConfig.setId(System.currentTimeMillis() + (int) (Math.random() * 100000));
            lists.add(streamConfig);
        }
        ArrayList<StreamConfig> list2 = new ArrayList<>(lists);
        ArrayList<StreamConfig> list3 = new ArrayList<>(lists);
        long startTime = System.currentTimeMillis();
        log.info("Collection.sort        ：{}", System.currentTimeMillis());
        ArrayList<StreamConfig> list = testCollectionSort(lists);
        long endTime = System.currentTimeMillis();
        log.info("Collection.sort       ：{} ms", endTime - startTime);

        log.info("Comparable        ：{}", System.currentTimeMillis());
        long comparableStartTime = System.currentTimeMillis();
        Collections.sort(list3);
        long comparableEndTime = System.currentTimeMillis();
        log.info("Comparable       ：{}", comparableEndTime - comparableStartTime);


        long streamStartTime = System.currentTimeMillis();
        log.info("java 8 stream      ：{}", streamStartTime);
        List<StreamConfig> collect = list2.stream().sorted(Comparator.comparing(StreamConfig::getLostThreshold).reversed()).collect(Collectors.toList());
        log.info("java 8 stream      ：{}", System.currentTimeMillis());
        log.info("java 8 stream       ：{} ms", System.currentTimeMillis() - streamStartTime);
        return "success";
    }

테스트 결 과 는 다음 과 같다.

소결
1.테스트 결 과 를 보면 데 이 터 량 이 각각 1000,10000,100000 의 데이터 세트 에서 자바 8 stream 의 정렬 방안 은 Collection.sort 방안 과 Comparable 인터페이스 방안 을 실현 하 는 데 걸 리 는 시간 보다 훨씬 많다.
2.테스트 결 과 를 보면 Collection.sort 방안 과 Comparable 인터페이스 방안 을 실현 하 는 데 걸 리 는 시간 이 가 까 울 수록 이 두 가지 방안 은 데이터 양 이 같 을 때 차이 가 크 지 않다.
3.본 고 에서 비교 한 것 은 단일 조건 에서(즉,lost Threshold 속성 값 에 따라 비교 하 는 것)다 중 조건 이 약간 차이 가 있 을 수 있 고 후속 적 으로 다 중 조건 에 대해 데이터 테스트 와 검증 을 할 수 있다.
4.테스트 결 과 를 통 해 알 수 있 듯 이 단일 조건 을 비교 할 때 Collection.sort 방안 과 Comparable 인터페이스 방안 이 더욱 높 은 성능 을 가지 고 데이터 양 이 많 을 때 이 두 가지 정렬 방식 을 사용 하 는 것 을 권장 합 니 다.
자바 기반 의 List 요소 의 정렬 성능 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.자바 List 요소 의 정렬 성능 에 관 한 더 많은 내용 은 예전 의 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 많은 응원 부 탁 드 리 겠 습 니 다!