Java容器-引用数据类型排序+TreeSet、TreeMap底层实现

目录

1、冒泡排序的实现

2、比较接口(普通数据类型、引用数据类型)

　　普通数据类型:冒泡排序

　　引用数据类型：包装类(Integer、String、Character、Date)

　　自定义类型：实体类:implements Comparable+compareTo|业务排序类：获取comparator对象、compare方法

3、TreeSet、TreeMap的使用

代码实现

1、冒泡排序(只演示升序)

 //采用泛型进行升序排列
    public  static <T extends Comparable<T>>void sort(T [] arry) {
        boolean sorted = true;
        for (int j = 0; j < arry.length - 1; j++) {
            sorted = true;
            for (int i = 0; i < arry.length - 1; i++) {
                if (((Comparable) arry[i]).compareTo(arry[i + 1]) > 0) {
                    T temp = arry[i];
                    arry[i] = arry[i + 1];
                    arry[i + 1] = temp;
                    //有数据交换就顺序是乱的
                    sorted = false;
                }
            }
            //如之前没有进行交换就说明有序即不用交换
            if (sorted) {
                break;
            }
        }
    }

2、引用类型

(1)实体类：Comparable+compareTo

//比较引用对象的大小
    public static void main(){
        //Integer:根据数据类型的大小比较
        System.out.println((Integer)10-(Integer)5);
        //Charaacter：根据Unicode吗比较大小
        Character c1='a';
        Character c2='c';
        System.out.println(c2-c1);
        //String：如果str1("abc")是str2("abcd")的子串,则返回字符串长度之差；否则，根据第一个不同的字符的unicode码之差。
        System.out.println("abc".compareTo("abcd"));
        //Date:根据毫秒数之差比较
        System.out.println(new Date(System.currentTimeMillis()-60*60*1000).compareTo(new Date()));
    }

 //实现对包装类的排序
    public  static <T extends Comparable<T>>void sort(T [] arry) {
        boolean sorted = true;
        for (int j = 0; j < arry.length - 1; j++) {
            sorted = true;
            for (int i = 0; i < arry.length - 1; i++) {
                if (((Comparable) arry[i]).compareTo(arry[i + 1]) > 0) {
                    T temp = arry[i];
                    arry[i] = arry[i + 1];
                    arry[i + 1] = temp;
                    //有数据交换就顺序是乱的
                    sorted = false;
                }
            }
            //如之前没有进行交换就说明有序即不用交换
            if (sorted) {
                break;
            }
        }
    }

(2)业务排序类：持有Comparator+实现compare接口

 //利用Comparator实现升序
    public  static <T extends Comparator<T>>void sort(Object [] arry, Comparator comparator) {
        boolean sorted = true;
        for (int j = 0; j < arry.length - 1; j++) {
            sorted = true;
            for (int i = 0; i < arry.length - 1; i++) {
                if ((comparator.compare(arry[i],arry[i + 1]))> 0) {
                    Object temp = arry[i];
                    arry[i] = arry[i + 1];
                    arry[i + 1] = temp;
                    //有数据交换就顺序是乱的
                    sorted = false;
                }
            }
            //如之前没有进行交换就说明有序即不用交换
            if (sorted) {
                break;
            }
        }
    }

(3)应用类型实现排序

String [] arrStr=new String[]{"ab","a","abc"};
SortUtils.sort(arrStr,new StringConparator());
System.out.println(Arrays.toString(arrStr));
//结果:[a,ab,abc]

//此处模拟：根据字符串长度进行比较

public class StringConparator implements java.util.Comparator<String> {

public int compare(String o1, String o2) {

return o1.length()-o2.length()>0?1:o1.length()-o2.length()==0?0:-1;

}

}

(4)TreeSet、TreeMap(底层实现：通过上述两种方式来比较对象，从而实现排序)

说明1：无参构造器默认用Comparable+compareTo方式实现、有参构造器需要传Comparator+compare

说明2:当add元素的时候，就进行排序。所以不可修改，set以后，依然不改变顺序。所以建议把元素设置成final

 public TreeMap(Comparator<? super K> comparator);

 public static void main(String [] args){
        TreeSet treeSet=new TreeSet();
        treeSet.add("ab");
        treeSet.add("a");
        treeSet.add("abc");
        for(Object s:treeSet){
            System.out.println(s);
        }
 }