集合排序问题

Treeset

ThreeSet用来对元素进行排序,同时也可以保证元素的唯一性

数字从大到小排序,字符串按照字母顺序,汉字是按照unicode码表进行排序的

import java.util.TreeSet;

class Main{
    public static void main(String[] args) {
        TreeSet<Integer> integers = new TreeSet<>();
        integers.add(1);
        integers.add(3);
        integers.add(2);
        integers.add(2);
        System.out.println(integers);//[1,2,3]
    }
}

对象自定义排序

需要实现Comparable接口,实现User方法

在添加元素的生活,会调用compareTo方法,如果该方法返回位0,认为添加的元素和集合当中的元素相等

如果返回值是负数,则比跟元素小,就会放到二叉树左边

如果返回的是一个正数就会放到右边

import java.util.*;

class User implements Comparable<User>{//实现Comparable接口泛型中定义本类

    private int score;

    private int age;

    public User(int score, int age){
        super();
        this.score = score;
        this.age = age;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public int compareTo(User o) {
        int i=this.getAge()-o.getAge();//用this减去传入的对象
        if (i==0){
            i=this.getScore()-o.getScore();
        }
        return i;
    }

    @Override
    public String toString() {
        return "User{" +
                "score=" + score +
                ", age=" + age +
                '}';
    }
}

在返回值为0的时候,就说明数据重复了,因此没有添加进去

Main

class Main{
    public static void main(String[] args) {
        Set<User> users = new TreeSet<>();
        users.add(new User(80,20));
        users.add(new User(80,20));
        users.add(new User(81,60));
        users.add(new User(83,25));
       // [User{score=80, age=20}, User{score=83, age=25}, User{score=81, age=60}]
        System.out.println(users);
    }
}

List排序

class Main{
    public static void main(String[] args) {
        List<User> users = new LinkedList<>();//只要是继承了list接口的都可以
        users.add(new User(80,20));
        users.add(new User(80,20));
        users.add(new User(81,60));
        users.add(new User(83,25));
        //[User{score=80, age=20}, User{score=83, age=20}, User{score=83, age=25}, User{score=81, age=60}]
        Collections.sort(users);
        System.out.println(users);
    }
}

调用Collections.sort方法,传入list集合就可以进行升序排序了

可以使用调用sort传入定义了Comparator接口的类,进行自定义升序降序

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

public class Main{
    public static void main(String[] args) {
        ArrayList<Integer> objects = new ArrayList<>();
        objects.add(1);
        objects.add(3);
        objects.add(2);
        objects.add(4);
        Comparator<Integer>comparator=new Comparator<Integer>() {
            @Override
            //第一个为本类中原来的数,第二个为比较的
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        } ;
        objects.sort(comparator);
        objects.sort((o1,o2)->o2-o1);//lambda表达式 与上面的作用相同看起来更简便
        System.out.println(objects);//[4, 3, 2, 1]
    }

}

数组排序

class Main{
    public static void main(String[] args) {
        int a[]={3,4,5,1,2,3};
        Arrays.sort(a);
        for (int b:a){
            System.out.print(b);//123345
        }
    }
}

Map

排序默认是升序排列的

class Main{
    public static void main(String[] args) {
        Map<User,Integer>map=new TreeMap<>();
        map.put(new User(99,18),1);
        map.put(new User(23,40),2);
        map.put(new User(11,70),44);
        map.put(new User(33,40),3);
        //{User{score=99, age=18}=1, User{score=23, age=40}=2, User{score=33, age=40}=3, User{score=11, age=70}=44}
        System.out.println(map);
    }
}