Set、List、Map排序问题

Set

方法一：使用Comparator的compareTo排序

import java.util.*;

public class Set_sort {
    public static void main(String[] args) {
        /*
        方法一：使用匿名对象覆写方法
         */
        Set<Integer> set1 = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //升序
                return o1 - o2;
                //降序
                //return o2 - o1;
            }
        });

        set1.add(15);
        set1.add(60);
        set1.add(10);
        set1.add(55);
        set1.add(45);

        System.out.println(set1);


        /*
        方法二：Lambda表达式
         */
        //升序
        Set<Integer> set2 = new TreeSet<>((o1, o2) -> o1 - o2);

        set2.add(15);
        set2.add(60);
        set2.add(10);
        set2.add(55);
        set2.add(45);

        System.out.println(set2);

    }
}

方法二：使用Comparator.naturalOrder()或Comparator.reverseOrder()

import java.util.*;

public class Set_sort {
    public static void main(String[] args) {
        //升序
        Set<Integer> set1 = new TreeSet<>(Comparator.naturalOrder());

        set1.add(15);
        set1.add(60);
        set1.add(10);
        set1.add(55);
        set1.add(45);

        System.out.println(set1);


        //降序
        Set<Integer> set2 = new TreeSet<>(Comparator.reverseOrder());

        set2.add(15);
        set2.add(60);
        set2.add(10);
        set2.add(55);
        set2.add(45);

        System.out.println(set2);

    }
}

List

对List的排序有两种情况：

• 包装类
• 自定义类

对包装类

import java.util.*;

public class List_sort {
    public static void main(String[] args) {
        List<Integer>list = new ArrayList<>();

        list.add(15);
        list.add(60);
        list.add(10);
        list.add(55);
        list.add(45);

		//升序
        Collections.sort(list);
        for (Integer integer : list){
            System.out.print(integer + "\t");
        }

        System.out.println();
		
		//降序
        Collections.reverse(list);
        for (Integer integer : list){
            System.out.print(integer + "\t");
        }
    }
}

对自定义类

方法一：实现Comparable接口

import java.util.*;

class Person implements Comparable<Person>{
    private String name;
    private Integer age;

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

    public String toString(){
        return "[name:" + this.name + "\tage" + this.age + "]";
    }

    @Override
    public int compareTo(Person o) {
        //升序
        return this.age - o.age;
        //降序
        //return o.age - this.age;
    }
}

public class List_sort {
    public static void main(String[] args) {
        List<Person>list = new ArrayList<>();

        Person per1 = new Person("A",15);
        Person per2 = new Person("B",60);
        Person per3 = new Person("C",10);
        Person per4 = new Person("D",55);
        Person per5 = new Person("E",55);
        Person per6 = new Person("F",45);

        list.add(per1);
        list.add(per2);
        list.add(per3);
        list.add(per4);
        list.add(per5);
        list.add(per6);
        
        //排序的升降取决于Person类中的compareTo书写
        Collections.sort(list);
        for(Person per : list){
            System.out.println(per);
        }
    }
}

其它参考文章：
让你永远不再因Collections.sort()而迷惑（1）

方法二：使用Collections匿名对象

import java.util.*;

class Person {
    private String name;
    private Integer age;

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

    //使用这种方法时需要age的getter
    public Integer getAge(){
        return this.age;
    }

    public String toString(){
        return "[name:" + this.name + "\tage" + this.age + "]";
    }
}

public class List_sort {
    public static void main(String[] args) {
        List<Person>list = new ArrayList<>();

        Person per1 = new Person("A",15);
        Person per2 = new Person("B",60);
        Person per3 = new Person("C",10);
        Person per4 = new Person("D",55);
        Person per5 = new Person("E",55);
        Person per6 = new Person("F",45);

        list.add(per1);
        list.add(per2);
        list.add(per3);
        list.add(per4);
        list.add(per5);
        list.add(per6);

        //排序的升降取决于Person类中的compareTo书写
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
            	//升序
                return o1.getAge() - o2.getAge();
            }
        });
        for(Person per : list){
            System.out.println(per);
        }
    }
}

参考文章：
让你永远不再因Collections.sort()而迷惑（2）

Map

对Map接口排序有两种情况：

• 对键
• 对值

根据键

方法一：使用Comparator匿名对象

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

public class Map_sort {
    public static void main(String[] args) {
        Map<Integer,String>map = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //升序
                return o1 - o2;
                //降序
                //return o2 - o1;
            }
        });

        map.put(15,"A");
        map.put(60,"B");
        map.put(10,"C");
        map.put(55,"D");
        map.put(45,"F");

        for(Integer key : map.keySet()){
            System.out.println("[key:" + key + "\tvalue" + map.get(key) + "]");
        }
    }
}

方法二：使用Lambda表达式

import java.util.Map;
import java.util.TreeMap;

public class Map_sort {
    public static void main(String[] args) {
        Map<Integer, String> map = new TreeMap<>((o1, o2) -> o1 - o2);

        map.put(15, "A");
        map.put(60, "B");
        map.put(10, "C");
        map.put(55, "D");
        map.put(45, "F");

        for (Integer key : map.keySet()) {
            System.out.println("[key:" + key + "\tvalue" + map.get(key) + "]");
        }
    }
}

根据值

方法一：使用Collections匿名对象

import java.util.*;

public class Map_sort {
    public static void main(String[] args) {
        Map<String, Integer> map = new TreeMap<>();

        map.put("A", 15);
        map.put("B", 60);
        map.put("C", 10);
        map.put("D", 55);
        map.put("E", 45);

        List<Map.Entry<String,Integer>>list = new LinkedList<>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                //升序
                return o1.getValue() - o2.getValue();
                //降序
                //return o2.getValue() - o1.getValue();
            }
        });

        for(Map.Entry<String,Integer>entry : list){
            System.out.println("[key:" + entry.getKey() + "\tvalue:" + entry.getValue() + "]");
        }

    }
}

方法二：使用Lambda表达式

import java.util.*;

public class Map_sort {
    public static void main(String[] args) {
        Map<String, Integer> map = new TreeMap<>();

        map.put("A", 15);
        map.put("B", 60);
        map.put("C", 10);
        map.put("D", 55);
        map.put("E", 45);

        List<Map.Entry<String,Integer>>list = new LinkedList<>(map.entrySet());
        //升序
        Collections.sort(list, (o1, o2) -> o1.getValue() - o2.getValue());

        for(Map.Entry<String,Integer>entry : list){
            System.out.println("[key:" + entry.getKey() + "\tvalue:" + entry.getValue() + "]");
        }

    }
}

本篇文章为了演示清楚，在排序的地方都是用了Integer包装类，如果是需要对String类排序，则需要使用compareTo()方法。