一点一点看JDK源码（五）java.util.ArrayList 后篇之sort与Comparator

一点一点看JDK源码（五）java.util.ArrayList 后篇之sort与Comparator

liuyuhang原创，未经允许禁止转载

本文举例使用的是JDK8的API

目录：一点一点看JDK源码（〇）

Comparator为额外实现的比较接口，与类本身无关

该接口在ArrayList的sort中有应用（很多时候都可以用的，只是以此举例）

Comparator接口主要用途有两种，

1、比较有序集合内任意两个元素A、B（完全遍历的compareTo方法，于compare方法内实现）

　　若A元素小于B元素，则返回1，donothing

　　若A元素等于B元素，则返回0，donothing

　　若A元素小于B元素，则返回-1，交换元素位置

　　若compare方法的返回值遵循以上原则，则进行排序

　　示例代码如下：

package com.FM.ArrayListStudy;

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

public class ComparatorInArrayListStudy01 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(12);
        list.add(3);
        list.add(4);
        list.add(3);
        list.add(11);
        list.add(7);
        System.out.println(list);//排序之前的list
        
        list.sort(new Comparator<Integer>() {//使用Comparator进行自然排序
            @Override
            public int compare(Integer one, Integer anotherOne) {
                int compareTo = one.compareTo(anotherOne);//正序排序
                //int compareTo = anotherOne.compareTo(one);//逆序排序
                
                //比较结果为1则不操作
                //比较结果为0则相等
                //比较结果为-1则交换位置
                System.out.println(anotherOne + "  --  " + one + "   ---   " + compareTo);
                return compareTo;
            }
        });
        System.out.println(list);//排序之后的list
    }
}

运行结果：

2、依照比较的结果（-1,0,1）进行判断分组

　　示例代码如下：Apple类

package com.FM.ArrayListStudy;

public class Apple {

    private Integer id;
    private Integer size;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getSize() {
        return size;
    }

    public void setSize(Integer size) {
        this.size = size;
    }

    public Apple(Integer id, Integer size) {
        super();
        this.id = id;
        this.size = size;
    }

    @Override
    public String toString() {
        return "Apple [id=" + id + ", size=" + size + "]";
    }

}

　　示例代码如下：利用Comparator接口分组

package com.FM.ArrayListStudy;

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

public class ComparatorInArrayListStudy02 {
    public static void main(String[] args) {
        ArrayList<Apple> list = new ArrayList<Apple>();
        list.add(new Apple(1, 81));
        list.add(new Apple(2, 76));
        list.add(new Apple(3, 91));
        list.add(new Apple(4, 84));
        list.add(new Apple(5, 79));
        list.add(new Apple(6, 87));
        list.add(new Apple(7, 85));
        list.add(new Apple(8, 83));
        list.add(new Apple(9, 91));
        System.out.println(list);//排序之前的list
        
        List<List<Apple>> disPartList = disPart(list,new Comparator<Apple>(){
            @Override
            public int compare(Apple o1, Apple o2) {//这里写具体的分组接口,分组方式可以使用对象内的属性的组合方式
                if(o1.getSize()/10 == o2.getSize()/10){//将苹果Apple按照size分组,每10个size分为一组
                    return 0;
                }
                return 1;
            }
        });
        for(List lis : disPartList){//分别遍历每一组
            System.out.println(lis);
        }
    }

    /**
     * 按照comparator进行分组的方法
     */
    public static <T> List<List<T>> disPart(List<T> list, Comparator<? super T> c) {
        ArrayList<List<T>> resultList = new ArrayList<List<T>>();
        for (T t : list) {
            boolean flag = false;
            for (int i = 0; i < resultList.size(); i++) {
                if (c.compare(t, resultList.get(i).get(0)) == 0) {// 若匹配成功则加入resultList中的子元素
                    flag = true;
                    resultList.get(i).add(t);
                    break;
                }
            }
            if (flag == false) {// 若flag为false则将此元素加入resultList为新元素
                List<T> listIn = new ArrayList<T>();
                listIn.add(t);
                resultList.add(listIn);
            }
        }
        return resultList;
    }
}

运行结果：

分组的方式很多，很多人也喜欢自己写遍历来分组

利用好Comparator接口进行分组能更好的重用，也更容易扩展！

 

以上！！