List、Set、Map三大集合的排序问题

最新推荐文章于 2022-10-10 10:21:59 发布
最新推荐文章于 2022-10-10 10:21:59 发布
阅读量413 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42061805/article/details/99621057

学了这么长时间的集合，是否会对这三大集合进行排序呢？
首先，了解一下Comparator和Comparable
通常，要对一个存储在集合内的实体类进行排序时，有两种策略：1. 实体类实现Comparable接口；2. 创建集合时指定Comparator，即实现Comparator接口；
为了区分这两个接口，通过称实现Comparable的实体类是可排序的，而Comparator则称呼为比较器。
下面使用具体的代码来使用这两个接口（按照使用的集合分别进行讲解）

List

List中存储的是Integer等数据类型的话，直接使用Collections.sort(List<E> list)或者Collections.sort(List<E> list， Comparator<? super T> c)进行排序。这里讲的是自定义类的排序。

  1. 实现Comparable的方式
package sort.list;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * @ClassName Demo2
 * @Description: 按照User的年龄进行排序
 * @Author 田清波
 * @Mail tqb820965236@163.com
 * @Date 2019/8/13 16:34
 * @Version v1.0
 */
public class Demo2 {
    @Test
    public void test(){
        User user1 = new User("zhangsan", 23);
        User user2 = new User("lisi", 25);
        User user3 = new User("wangwu", 20);

        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);

        System.out.println("未排序：" + list);
        Collections.sort(list);
        System.out.println("已排序：" + list);
    }
}

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

    @Override
    public int compareTo(User o) {
        /**
         * 指定对象减去此对象 - 降序
         * 此对象减去指定对象 - 升序
         */
        // System.out.println(o.age - this.age);
        return this.age - o.age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
  1. 实现Comparator的方式
package sort.list;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * @ClassName Demo2
 * @Description: 按照User的年龄进行排序
 * @Author 田清波
 * @Mail tqb820965236@163.com
 * @Date 2019/8/13 16:34
 * @Version v1.0
 */
public class Demo2 {
    @Test
    public void test(){
        User user1 = new User("zhangsan", 23);
        User user2 = new User("lisi", 25);
        User user3 = new User("wangwu", 20);

        List<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);

        System.out.println("未排序：" + list);
        /**
         * 通过匿名内部类进行实现，即指定排序的方式
         */
        Collections.sort(list, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                /**
                 * o2 - o1 : 降序
                 * o1 - o2 : 升序
                 */
                return o2.getAge() - o1.getAge();
            }
        });
        System.out.println("已排序：" + list);
    }
}

class User {
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

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

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

这里以我春招面试途牛的一道题作为讲解，当时真的不会，所以自然面试没通过（=_=），下来做了一下非常的懊悔！！！
题目：
现在存在这么个需求，就是对学生进行排序操作（升序降序都实现），前提是不能存在相同年龄的学生（当然我觉得这是不合理的）在进行学生添加的时候，相同年龄不再进行添加。
解决思路：

1. 首先使用Set集合（Set集合不允许出现相同的数据，即数据唯一，TreeSet（使用该类添加自定义的实体类时，要么实现可排序接口，要么自定义比较器）这里需要知道TreeSet的存储结构数据是排好序的。
2. 用户Person实现equals（供用户调用）和hashcode方法(在进行数据add的时候，默认调用hashcode方法)
3. hashcode通过age计算hash值,这样保证了数据的唯一性
4. 排序的话两种实现方式
	1. Person实现可排序接口Comparable
	2. 创建集合时指定比较器

代码体现：

package sort.set;

import org.junit.Test;

import java.util.*;

/**
 * @ClassName SetToList
 * @Description: 途牛面试题
 * @Author 田清波
 * @Mail tqb820965236@163.com
 * @Date 2019/8/13 21:20
 * @Version v1.0
 */
public class SetToList {

    @Test
    public void test(){
        Set<Person> set = new TreeSet<>(new Comparator<Person>() {
            /**
             * 原先的排序方式失效（升序）
             * @param o1
             * @param o2
             * @return
             */
            @Override
            public int compare(Person o1, Person o2) {
                return o2.getAge() - o1.getAge();// 降序
            }
        });
        Person person1 = new Person("zhangsan" ,11);
        Person person2 = new Person("lisi" ,14);
        Person person3 = new Person("wangwu" ,13);
        Person person4 = new Person("lisi" ,13);

        set.add(person1);
        set.add(person2);
        set.add(person3);
        set.add(person4);

        System.out.println(set.size());
        System.out.println(set);

    }
}

class Person {
    private String name;
    private Integer age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    /**
     * 重写equals和hashCode方法
     *      判断是否是一个对象
     *          （途牛面试题目，当时真的不会做）
     *          题目：现在存在这么个需求，就是对用户进行排序操作（升序降序都实现），前提是不能存在相同年龄的用户（当然我觉得这是不合理的）
     *               在进行用户添加的时候，相同年龄不再进行添加。
     *          解决思路：
     *              首先使用Set集合（Set集合不允许出现相同的数据，即数据唯一，TreeSet（使用该类添加自定义的实体类时，要么实现可排序接口，要么自定义比较器） 数据是排序的）
     *              用户Person实现equals（供用户调用）和hashcode方法(在进行数据add的时候，默认调用hashcode方法)
     *              hashcode通过age计算hash值
     *              这样保证了数据的唯一性
     *              排序的话两种实现方式
     *                  1. Person实现可排序接口Comparable
     *                  2. 创建集合时指定比较器
     * @param o
     * @return
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        if (!(o instanceof Person))
            return false;
        Person person = (Person) o;
        return person.age == this.age;
    }

    /**
     * 对象相同的话，哈希值一定相同
     * 对象不相同的话，哈希值不一定不相同（存在哈希碰撞）
     * 依靠这个性质判断对象是否相同
     * 供散列表进行调用 HashSet HashMap...
     * @return
     */
    @Override
    public int hashCode() {
        return Objects.hash(age);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
	/*
    @Override
    public int compareTo(Person o) {
        return this.age - o.age; // 升序
    }
    */
}
Map

题目：按照水果的个数进行排序
直接上代码（还可以使用List进行实现，即针对List进行排序再转换，这里直接使用TreeSet，TreeMap也可以实现）：

package sort.map;

import org.junit.Test;

import java.util.*;

/**
 * @ClassName MapSort
 * @Description: 对Map进行排序
 * @Author 田清波
 * @Mail tqb820965236@163.com
 * @Date 2019/8/15 9:02
 * @Version v1.0
 */
public class MapSort {
    @Test
    public void test(){
        HashMap<Fruit, Integer> map = new HashMap<>();
        Fruit fruit1 = new Fruit("苹果");
        Fruit fruit2 = new Fruit("草莓");
        Fruit fruit3 = new Fruit("梨");
        Fruit fruit4 = new Fruit("西瓜");
        Fruit fruit5 = new Fruit("香蕉");

        map.put(fruit1, 9);
        map.put(fruit2, 2);
        map.put(fruit3, 8);
        map.put(fruit4, 5);
        map.put(fruit5, 1);

        Map<Fruit, Integer> sort = sort(map);
        Set<Map.Entry<Fruit, Integer>> entries = sort.entrySet();
        for (Map.Entry<Fruit, Integer> entry : entries){
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }

    public Map<Fruit, Integer> sort(Map<Fruit, Integer> map){
        /**
         * 将Map转为Set
         */
        Set<Map.Entry<Fruit, Integer>> entries = map.entrySet();
        TreeSet<Map.Entry<Fruit, Integer>> set = new TreeSet<>(new Comparator<Map.Entry<Fruit, Integer>>() {
            @Override
            public int compare(Map.Entry<Fruit, Integer> o1, Map.Entry<Fruit, Integer> o2) {
                return o1.getValue() - o2.getValue();
            }
        });
        /**
         * 向TreeSet中添加数据
         */
        for (Map.Entry<Fruit, Integer> entry : entries){
            set.add(entry);
        }
        /**
         * 将Set转为LinkHashMap（有序）返回
         */
        LinkedHashMap<Fruit, Integer> resMap = new LinkedHashMap<>();
        for (Map.Entry<Fruit, Integer> entry : set){
            resMap.put(entry.getKey(), entry.getValue());
        }
        return resMap;
    }
}

class Fruit {
    private String name;
    private String remark;

    public Fruit() {
    }

    public String getName() {
        return name;
    }

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

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    public Fruit(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Fruit{" +
                "name='" + name + '\'' +
                ", remark='" + remark + '\'' +
                '}';
    }
}
java对List、Set、Map升序、降序排序用法
hkl_Forever的博客
09-12 4174
下面介绍java中对对List、Set、Map的升序、降序排序的常用写法 1、List排序： 2、Set排序： 3、Map排序：
Java集合归类（List、set、Map）及Comparator排序
weixin_42271651的博客
05-08 1095
集合: List集合 import java.util.ArrayList; import java.util.Iterator; import java.util.List; //Java集合类 public class ListDemo { public static void main(String[] args) { List<String&g...
set转成list集合再排序输出
01-03
Java相关 public static void main(String[] args) { User u1=new User(1, "zhangsan"); User u2=new User(2, "lisan"); User u3=new User(3, "wangsan"); //放入到Set集合中 Set userset=new HashSet(); userset.add(u1); userset.add(u2); userset.add(u3);
list集合 & Set集合 & 泛型 & 集合排序
weixin_52528062的博客
10-10 368
Comparable是在集合内部定义的方法实现的排序，位于java.lang下。Comparable 接口仅仅只包括一个函数，Comparable是一个对象，本身就已经支持自比较所需要实现的接口。自定义类要在加入list容器中后能够排序，也可以实现Comparable接口。在用Collections类的sort方法排序时若不指定Comparator，那就以自然顺序排序。所谓自然顺序就是实现Comparable接口设定的排序方式。若一个类实现了comparable接口，则意味着该类支持排序。
Set 和List的排序规则（Set是无序的 List是有序的）
weixin_34406061的博客
06-08 535
//分别向Set集合 以及List集合中添加“A” “a” “c” “C” “a” 5个元素，观察重复值“a”能否在List集合以及Set集合中成功的添加。import java.util.ArrayList;import java.util.HashSet;import java.util.Iterator;import java.util.List;import java...
List、Set、Map排序详解
mingyuli的博客
04-18 397
首先，了解一下Comparator和Comparable 通常，要对一个存储在集合内的实体类进行排序时，有两种策略：1. 实体类实现Comparable接口；2. 创建集合时指定Comparator，即实现Comparator接口； 区别：称实现Comparable的实体类是可排序的，而Comparator则称为比较器。 下面使用具体的代码来使用这两个接口（按照使用的集合分别进行讲解） 一、List List中存储的是Integer等数据类型的话，直接使用Collections.sort(List&lt
List Set集合排序
m0_47760827的博客
11-24 145
ArrayList<People> list = new ArrayList<>(); list.add(new People(1, 27, "张三")); list.add(new People(3, 24, "张三")); list.add(new People(2, 24, "张三")); System.out.println(list); // Collections.sort(list, n...
Set-List-Map.rar_DEMO_list set map
09-22
在Java编程语言中，集合框架是处理对象组的重要工具，主要包括`List`、`Set`和`Map`接口。这些接口及其实现类提供了丰富的功能，适用于各种数据存储和操作需求。`Set-List-Map.rar_DEMO_list set map`这个压缩包文件...
Java_Collection_List-Set-Map.zip_list set map
09-24
在Java编程语言中，集合框架是处理对象组的重要工具，主要包括List、Set和Map三大接口。这些接口由Java Collection Framework提供，它是一个统一的架构，用于存储和操作各种类型的对象。接下来，我们将深入探讨这三...
Java集合排序及java集合类详解(Collection、List、Map、Set)讲解.pdf
02-12
Java集合排序及java集合类详解(Collection、List、Map、Set)讲解 Java集合框架是Java语言中最重要的组件之一，能够正确使用Java集合框架对于Java程序的开发具有无比的好处。本文将详细解释Java集合框架的实现原理、...
Java集合排序及java集合类详解(Collection、List、Map、Set).pdf
12-23
Java集合排序及Java集合类详解 Java集合框架是Java语言中最重要、最常用的部分之一，它能够使开发者更方便地处理数据结构。Java集合框架主要包括Collection、List、Set、Map四个接口，它们分别实现了不同的数据结构...
Java集合CollectionListSetMap使用详细讲解(1).doc
最新发布
07-27
包括集合框架概述、容器简介、容器分类、Collection接口的常用方法和迭代器、List接口的特点和实现原理、Map接口的概述、常用方法和实现原理、Set接口的概念、常用方法和集合框架中常用的类比较。 在集合框架中，...
map set list常用简单创建、排序
dzy_001的博客
10-14 311
利用Collections创建单个元素集合 Collections.singleton() Collections.singletonList() Collections.singletonMap("key","value") 创建多个元素集合 Sets.newHashSet() Maps.newHashMap() Lists.newArrayList() list&l...
集合接口（List，Set，Map）List（序列）排序--5，6
q540694991的博客
10-09 561
集合接口（List，Set，Map）--5 一.List ：实现类ArrayList public class TestGeneric { /** * 带有泛型——Course，的List类型属性 */ public List courses; public TestGeneric() { this.courses = new ArrayList();//通过接口
set,map,list集合的特点及其排序的方法
强哥的博客
06-09 2683
特点:list：存储： 有序的 可重复的 访问：可以for循环，foreach循环，iterator迭代器 迭代。set：存储：无序的 不重复的 访问：可以foreach循环，iterator迭代器 迭代map：存储：存储的是一对一对的映射 ”key=value“，key值 是无序，不重复的。value值可重复 访问：可以map中key值转为为set存储，...
Comparable和Comparator对List和Set集合进行排序
cjr2015的博客
08-24 741
 1、Comparable接口实现排序，请参考下列代码 public class HelloWorld { public static void main(String[] args) { List&lt;Student&gt; list = new ArrayList&lt;Student&gt;(); TreeSet&lt;Student&gt; set = new TreeS...
根据对象的属性，对集合（list / set）中的对象进行排序
yushuangping的博客
11-27 1374
一：针对list      通过java.util.Collections的sort方法，有2个参数，第一个参数是list对象，第二个参数是new Comparator&lt;对象类&gt;（）{}方法，这个方法实现了compare（）方法，具体代码如下所示： package com.example.mylearngit; import com.example.mylearngit.bea...
Java8实现Map/List/Set排序
卓立的博客
11-03 7478
Java8之前如果想对一个集合排序，那么集合元素要么实现了Comparable接口，要么另外定义一个继承于Comparator的比较器并实现compare方法，使用起来是非常麻烦的。在我之前的文章中也介绍了一种Guava的排序实现方案，也是非常简单的，有兴趣的同学可以去了解一下Guava Ordering 。Java8之后可以使用java.util包的Comparator比较器，实现对集合的排序，...
关于java Stream流将list集合分组之后与原list的集合的顺序不一致的问题
qq_42493919的博客
05-12 6835
关于java Stream流将list集合分组之后与原list的集合的顺序不一致的问题 问题：在将list集合按照某个或某几个字段分组之后，map中key的顺序与原来list的顺序不一致，导致需要按顺序进行字段匹配时出现了错误 // 按照原本的分组---所得的map是无序的 Map<String, List<ShiQc>> map = shiQcList.stream().collect(Collectors.groupingBy(m -(m.getApplyName() + m.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值