Java Collection - 002 排序

第一种，可以实现边添加边排序，需要用到TreeSet。

第二种，用数组存放对象们，但是不需单独取出某属性排列好再重存，而是在原数组上用比较器重新排一次序。需要用到Arrays.sort(arr,comparator)。

第三种，用集合类中的list的子类存放对象们，然后排序。需要用到Collections.sort(list,comparator)。 

java常用类实现Comparable接口，并提供了比较大小的标准。实现Comparable接口的常用类：

• BigDecimal、BigIneger以及所有数值型对应包装类：按它们对应的数值的大小进行比较。
• Character：按字符的UNICODE值进行比较。
• Boolean：true对应的包装类实例大于false对应的包装类实例。
• String：按字符串中字符的UNICODE值进行比较。
• Date、Time：后面的时间、日期比前面的时间、日期大。

一般默认排序是升序，也就是自然排序 

1.TreeSet排序:

   /*
 * TreeSet存储对象的时候, 可以排序, 但是需要指定排序的算法
 * 
 * Integer能排序(有默认顺序), String能排序(有默认顺序), 自定义的类存储的时候出现异常(没有顺序)
 * 
 * 如果想把自定义类的对象存入TreeSet进行排序, 那么必须实现Comparable接口
 *   在类上implement Comparable
 *   重写compareTo()方法
 *   在方法内定义比较算法, 根据大小关系, 返回正数负数或零
 *   在使用TreeSet存储对象的时候, add()方法内部就会自动调用compareTo()方法进行比较, 根据比较结果使用二叉树形式进行存储
 */

2.TreeSet是依靠TreeMap来实现的。
TreeSet是一个有序集合，TreeSet中的元素将按照升序排列，缺省是按照自然排序进行排列. 基本封装类型以及实现了Comparable接口，可以直接添加排序。如Integer， String类型 

import java.util.Iterator;
import java.util.*;

public class TreeSetTest {
    public static void main(String[] args) {
        Set ts = new TreeSet();
        ts.add("abc");
        ts.add("xyz");
        ts.add("rst");
        Iterator it = ts.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

输出结果：

abc

rst

xyz

打印结果不是和先前加入的顺序一样，它是按照一个字母的排序法进行排序的。这是因为String 类实现了Comparable接口。

By default, String object (name) in TreeSet will be displayed in ascending order. if you want them displayed in descending order, you just need to 

You just need to instantiate the TreeSet with

 new TreeSet<>(Collections.reverseOrder()); 

 

This is a Comparator which reverses the natural order of the objects.

 

2.TreeSet对自定义对象的排序 

2.1 使用TreeSet()构造方法，并对需要添加到set集合中的元素实现Comparable接口进行排序； 

如果我们自己定义的一个类的对象要加入到TreeSet当中，那么这个类必须要实现Comparable接口。

package test.treeset;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;


public class test_treeset {
     @SuppressWarnings("unchecked")
    public static void main(String[] args) {
            Set ts = new TreeSet();
            ts.add(new Teacher("zhangsan", 1));
            ts.add(new Teacher("lisi", 2));
            ts.add(new Teacher("wangmazi", 3));
            ts.add(new Teacher("wangwu",4));
            ts.add(new Teacher("mazi", 3));
            Iterator it = ts.iterator();
            while (it.hasNext()) {
                System.out.println(it.next());
            }
        }
}
class Teacher implements Comparable {
    int num;
    String name;

    Teacher(String name, int num) {
        this.num = num;
        this.name = name;
    }

    public String toString() {
        return "学号：" + num + "\t\t姓名：" + name;
    }

    //o中存放时的红黑二叉树中的节点，从根节点开始比较
    public int compareTo(Object o) {
        Teacher ss = (Teacher) o;
        int result = num < ss.num ? 1 : (num == ss.num ? 0 : -1);//降序
        //int result = num > ss.num ? 1 : (num == ss.num ? 0 : -1);//升序
        if (result == 0) {
            result = name.compareTo(ss.name);
        }
        return result;
    }
}

运行结果：

学号：4 姓名：wangwu
学号：3 姓名：mazi
学号：3 姓名：wangmazi
学号：2 姓名：lisi
学号：1 姓名：zhangsan

2.2. 通过TreeSet(Comparator<? super E> comparator) 构造方法指定TreeSet的比较器进行排序；

在使用Arrays对数组中的元素进行排序的时候，可以传递一个比较器。

在使用Collections对集合中的元素进行排序的时候，可以传递一个比较器。

那么在使用TreeSet对加入到其中的元素进行排序的时候可以传入一个比较器吗？

public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<E,Object>(comparator));
    }

通过查看它的构造方法就知道可以传入一个比较器。

构造一个新的空TreeSet，它根据指定比较器进行排序。插入到该 set 的所有元素都必须能够由指定比较器进行相互比较：对于 set 中的任意两个元素 e1 和e2，执行 comparator.compare(e1, e2) 都不得抛出 ClassCastException。如果用户试图将违反此约束的元素添加到 set 中，则 add 调用将抛出 ClassCastException。

package test.treeset;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetTest {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        TreeSet ts = new TreeSet(new Teacher2.TeacherCompare());
        ts.add(new Teacher2("zhangsan", 2));
        ts.add(new Teacher2("lisi", 1));
        ts.add(new Teacher2("wangmazi", 3));
        ts.add(new Teacher2("mazi", 3));
        Iterator it = ts.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

class Teacher2 {
    int num;
    String name;

    Teacher2(String name, int num) {
        this.num = num;
        this.name = name;
    }

    public String toString() {
        return "学号：" + num + "    姓名：" + name;
    }

    static class TeacherCompare implements Comparator {// 老师自带的一个比较器
        //o1中存放的事目标节点
        //o2中存放时的红黑二叉树中的节点，从根节点开始比较
        public int compare(Object o1, Object o2) {
            Teacher2 s1 = (Teacher2) o1;// 转型
            Teacher2 s2 = (Teacher2) o2;// 转型
            int result = s1.num > s2.num ? 1 : (s1.num == s2.num ? 0 : -1);
            if (result == 0) {
                result = s1.name.compareTo(s2.name);
            }
            return result;
        }

    }

}

运行结果：

学号：1 姓名：lisi
学号：2 姓名：zhangsan
学号：3 姓名：mazi
学号：3 姓名：wangmazi

二、用数组存放对象，用比较器改变sort（）排序方法。

数组本身有默认的排序方法，针对int、string等基本类型有默认的sort()方法。而针对类对象的排序，可以给sort()方法传进一个比较器对象，赋予其排序的算法。

public class ArraysTest {

    public static void main(String[] args) {
        Person[] people = new Person[5];
        people[0] = (new Person("小明", 20));
        people[1] = (new Person("小张", 30));
        people[2] = (new Person("小刘", 18));
        people[3] = (new Person("小林", 17));
        people[4] = (new Person("小刘", 35));

        Arrays.sort(people, new MyCompare());// 传进来一个比较器对象，使数组按比较器定义的规则来排序
        for (Person i : people) {
            System.out.println(i);
        }
    }
}

class Person {
    String name;
    int age;
    public Person() {}

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return "姓名：" + name + ",年龄：" + age;
    }
}

class MyCompare implements Comparator<Person> {// 定义比较器
    /*
     * 
     * 重写比较方法compare(o1,o2)：     
     * 方法传进来两个对象，用两个对象的某属性进行对比，返回一个int。
     *      int>0，则o1排在o2后面；
     *     int<0,则o1排在o2前面；
     *     int=0，则维持原相对位置，即原来存放时o1、o2的前后地址顺序。     * 
     */
    public int compare(Person o1, Person o2) {
        int result;
        if (o1.age > o2.age) {
            result = 1;
        } else if (o1.age < o2.age) {
            result = -1;
        } else {
            result = 0;
        }
        return result;
    }
}

 

第三种：用list的子类：Vector、ArrayList存放对象们，调用Collections.sort（list,comparator）方法进行排序。 

public class CollectionsTest {

    public static void main(String[] args) {
        Vector<Person> people = new Vector<>();// 用向量保存对象
        // ArrayList<Person> people=new ArrayList<>()://用ArrayList保存对象。
        people.add(new Person("小明", 20));
        people.add(new Person("小张", 30));
        people.add(new Person("小刘", 18));
        people.add(new Person("小林", 17));
        people.add(new Person("小刘", 35));
        Collections.sort(people, new MyComparator());// 调用方法进行排序
        Iterator it = people.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

class Person {
    String name;
    int age;
    
    public Person() {}

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return "姓名：" + name + ",年龄：" + age;
    }

}

class MyComparator implements Comparator<Person> {// 实现Comparator接口，自定义比较器，实现compare方法定义比较算法
    /*
     * compare(o1,o2)：方法传进两个对象，根据某属性进行比较，返回一个int值。 int>0,o1排在o2后； int<0,o1排在o2前；
     * int=0,维持原来存放时的相对位置。
     * 
     */
    public int compare(Person p1, Person p2) {
        int result = p1.age < p2.age ? 1 : (p1.age == p2.age ? 0 : -1);// 降序排列
        // int result=p1.age<p2.age?1:(p1.age==p2.age?0:-1);//升序排列

        if (result == 0) {
            result = p1.name.compareTo(p2.name);
        }
        return result;
    }
}

 

通过匿名比较器进行排序

public static List<String> sortAsFloat(List<String> list, final boolean reverseOrder) {
        Collections.sort(list, new Comparator<String>(){

            public int compare(String o1, String o2) {
                if (reverseOrder) {
                    return (int) (Float.parseFloat(o2) - Float.parseFloat(o1));
                } else {
                    return (int) (Float.parseFloat(o1) - Float.parseFloat(o2));
                }
            }            
        });
        
        return list;
    }