Collection 子接口之 Set

黑洞代码

发布于 2021-01-28 15:23:52

5770

发布于 2021-01-28 15:23:52

Comparable 和 Comparator 的区别

Comparable 接口实际上是出自java.lang包，它有一个 compareTo(Object obj)方法用来排序。
Comparator接口实际上是出自 java.util 包，它有一个compare(Object obj1, Object obj2)方法用来排序。

一般我们需要对一个集合使用自定义排序时，我们就要重写compareTo()方法或compare()方法，当我们需要对某一个集合实现两种排序方式，比如一个 song 对象中的歌名和歌手名分别采用一种排序方法的话，我们可以重写compareTo()方法和使用自制的Comparator方法或者以两个 Comparator 来实现歌名排序和歌星名排序，第二种代表我们只能使用两个参数版的 Collections.sort().

Comparator 定制排序

public class ComparatorDemo {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(-1);
        arrayList.add(3);
        arrayList.add(3);
        arrayList.add(-5);
        arrayList.add(7);
        arrayList.add(4);
        arrayList.add(-9);
        arrayList.add(-7);
        System.out.println("原始数组:");
        System.out.println(arrayList);
        // void reverse(List list)：反转
        Collections.reverse(arrayList);
        System.out.println("Collections.reverse(arrayList):");
        System.out.println(arrayList);

        // void sort(List list),按自然排序的升序排序
        Collections.sort(arrayList);
        System.out.println("Collections.sort(arrayList):");
        System.out.println(arrayList);
        // 定制排序的用法
        Collections.sort(arrayList, new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println("定制排序后：");
        System.out.println(arrayList);
    }
}

// 输出
原始数组:
[-1, 3, 3, -5, 7, 4, -9, -7]
Collections.reverse(arrayList):
[-7, -9, 4, 7, -5, 3, 3, -1]
Collections.sort(arrayList):
[-9, -7, -5, -1, 3, 3, 4, 7]
定制排序后：
[7, 4, 3, 3, -1, -5, -7, -9]

重写 compareTo 方法实现按年龄来排序

person对象没有实现Comparable接口，所以必须实现，这样才不会出错，才可以使treemap中的数据按顺序排列。前面一个例子的String类已经默认实现了Comparable接口，详细可以查看String类的API文档，另外其他。像Integer类等都已经实现了Comparable接口，所以不需要另外实现了。

public class Person implements Comparable<Person> {

    private String name;
    private int age;

    public int getScore() {
        return score;
    }

    private int score;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    /**
     * T重写compareTo方法实现按年龄来排序
     */
    @Override
    public int compareTo(Person o) {
        if (this.age > o.getAge()) {
            return 1;
        }
        if (this.age < o.getAge()) {
            return -1;
        }
        return this.score - o.score;
    }

    public static void main(String[] args) {
        TreeMap<Person, String> pdata = new TreeMap<Person, String>();
        pdata.put(new Person("张三", 30, 80), "zhangsan");
        pdata.put(new Person("李四", 30, 70), "lisi");
        pdata.put(new Person("王五", 20, 88), "wangwu");
        pdata.put(new Person("小红", 15, 90), "xiaohong");
        // 得到key的值的同时得到key所对应的值
        Set<Person> keys = pdata.keySet();
        for (Person key : keys) {
            System.out.println(key.getAge() + "-" + key.getName() + "-" + key.getScore());

        }
    }
}

// 输出

15-小红-90
20-王五-88
30-李四-70
30-张三-80

Comparator

public class Person implements Comparable<Person> {

    private String name;
    private int age;

    public int getScore() {
        return score;
    }

    private int score;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    /**
     * T重写compareTo方法实现按年龄来排序
     */
    @Override
    public int compareTo(Person o) {
        if (this.age > o.getAge()) {
            return 1;
        }
        if (this.age < o.getAge()) {
            return -1;
        }
        return this.score - o.score;
    }

    public static void main(String[] args) {
        TreeMap<Person, String> pdata = new TreeMap<Person, String>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                if (o1.getAge() > o2.getAge()) {
                    return -1;
                }
                if (o2.getAge() > o1.getAge()) {
                    return 1;
                }
                return o2.score - o1.score;
            }
        });
        pdata.put(new Person("张三", 30, 80), "zhangsan");
        pdata.put(new Person("李四", 30, 70), "lisi");
        pdata.put(new Person("王五", 20, 88), "wangwu");
        pdata.put(new Person("小红", 15, 90), "xiaohong");
        // 得到key的值的同时得到key所对应的值
        Set<Person> keys = pdata.keySet();
        for (Person key : keys) {
            System.out.println(key.getAge() + "-" + key.getName() + "-" + key.getScore());

        }
    }
}

// 输出

30-张三-80
30-李四-70
20-王五-88
15-小红-90

无序性和不可重复性的含义是什么

1、什么是无序性？无序性不等于随机性，无序性是指存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的。

2、什么是不可重复性？不可重复性是指添加的元素按照 equals()判断时，返回 false，需要同时重写 equals()方法和 HashCode()方法。

比较 HashSet、LinkedHashSet 和 TreeSet 三者的异同

1、HashSet 是 Set 接口的主要实现类，HashSet 的底层是 HashMap，线程不安全的，可以存储 null 值；

2、LinkedHashSet 是 HashSet 的子类，能够按照添加的顺序遍历；

3、TreeSet 底层使用红黑树，能够按照添加元素的顺序进行遍历，排序的方式有自然排序和定制排序。

本文参与腾讯云自媒体分享计划，分享自微信公众号。

原始发表：2021-01-22，如有侵权请联系 cloudcommunity@tencent.com 删除

java

编程算法

本文分享自落叶飞翔的蜗牛微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

java

编程算法

登录后参与评论

0 条评论

热度