精华内容
下载资源
问答
  • 主要介绍了Java8 用Lambda表达式给List集合排序的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了Java List集合排序实现方法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • list集合树状排序-java

    2019-02-15 16:44:33
    list集合树状排序 对于前端jquery-treetable无法进行父子关联数据问题进行改进,后台传list集合前,对list进行排序,然后在返回到前台。
  • 主要介绍了java list集合排序按某一属性排序操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 主要介绍了JAVA像SQL一样对List对象集合进行排序的实现方法,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • javalist集合排序

    2019-03-01 17:31:02
    Collections.sort(newsPcRespList, new Comparator<NewsPcResp>(){ @Override public int compare(NewsPcResp a, NewsPcResp b) {//将List依照倒序排序 return a.getSortTag() .comp...
        Collections.sort(newsPcRespList, new Comparator<NewsPcResp>(){
            @Override
            public int compare(NewsPcResp a, NewsPcResp b) {//将List依照倒序排序
                return a.getSortTag() .compareTo(b.getSortTag());
            }
        });
    
    展开全文
  • JavaList集合进行排序

    千次阅读 2019-03-29 15:53:27
    这几天做题刚好遇到对List集合排序的题,发现一种好用的方法,做一个笔记。 我是基于spring,对于刚学java的小伙伴可以直接在main方法中去完成。 第一步 创建一个实体类对象User package bean; public class User {...

    这几天做题刚好遇到对List集合排序的题,发现一种好用的方法,做一个笔记。

    我是基于spring,对于刚学java的小伙伴可以直接在main方法中去完成。

    第一步
    创建一个实体类对象User

    package bean;
    
    public class User {
    
        private String username;
        private Integer age;
    
        public User(String username, Integer age) {
            this.username = username;
            this.age = age;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    }
    
    

    第二步
    编写测试文件

    package test;
    
    import bean.User;
    import org.junit.jupiter.api.Test;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    public class SortDemo {
    
        @Test
        void doSort(){
            List<User> list = new ArrayList<User>();
            list.add(new User("张三",5));
            list.add(new User("李四",30));
            list.add(new User("王五",19));
            list.add(new User("微风",30));
            
            /**
             * 对年龄进行降序排序
             */
            Collections.sort(list, new Comparator<User>() {
                public int compare(User o1, User o2) {
                    int diff = o1.getAge() - o2.getAge();
                    if(diff < 0)  return 1;//前面的数小于后面的数
                    if(diff > 0)  return -1;//前面的数大于后面的数
                                  return 0;//相等的情况
                }
            });
            
            /**
             * 对年龄进行升序排序
             */
            /*
            Collections.sort(list, new Comparator<User>() {
                public int compare(User o1, User o2) {
                    int diff = o1.getAge() - o2.getAge();
                    if(diff > 0)      return 1;
                    else if(diff < 0) return  -1;
                                      return 0;//相等返回0
    
                }
            });
            */
            for (User user:list){
                System.out.println(user.getAge());
            }
        }
    }
    
    

    降序排序运行结果:

    在这里插入图片描述

    展开全文
  • 主要介绍了JAVAlist集合进行排序Collections.sort(),需要的朋友可以参考下
  • JavaList集合三种排序方式

    千次阅读 2020-11-23 15:32:27
    JavaList集合三种排序方式方式一(Integer类型集合排序)方式二(对象类型集合排序)方式三(同样是对象类型集合排序 ) 方式一(Integer类型集合排序) public static void main(String[] args) { List<Integer> ...

    方式一(Integer类型集合排序)

    public static void main(String[] args) {
    	List<Integer> nums = new ArrayList<Integer>();
    	nums.add(3);
    	nums.add(5);
    	nums.add(1);
    	nums.add(0);
    	System.out.println(nums);
    	Collections.sort(nums);
    	System.out.println(nums);
    }
    /*
     * 输出结果
     * [3, 5, 1, 0]
     * [0, 1, 3, 5]
     */ 
    

    方式二(对象类型集合排序)

    package core.java.collection.collections;
    public class User implements Comparable<User>{
    	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();//先按照年龄排序
    		if(i == 0){
    			return this.score - o.getScore();//如果年龄相等了再用分数进行排序
    		}
    		return i;
    	}
    }
     
    public static void main(String[] args) {
    	List<User> users = new ArrayList<User>();
    	users.add(new User(78, 26));
    	users.add(new User(67, 23));
    	users.add(new User(34, 56));
    	users.add(new User(55, 23));
    	Collections.sort(users);
    	for(User user : users){
    		System.out.println(user.getScore() + "," + user.getAge());
    	}
    	/*
    	 * 输出结果
    	 * 55,23
    	 * 67,23
    	 * 78,26
    	 * 34,56
    	 */ 
    }
    

    我们会发现sort(List)方法中List中的T必须实现Comparable接口,然后实现compareTo()方法,该方法的返回值0代表相等,1表示大于,-1表示小于;为什么在简单例子中没有看到实现Comparable接口呢?是因为Integer类其实自己已经实现了Comparable接口,Java已经给我们做好了。

    方式三(同样是对象类型集合排序 )

    package core.java.collection.collections;
    public class Students {
    	private int age;
    	private int score;
    	public Students(int age, int score){
    		super();
    		this.age = age;
    		this.score = score;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public int getScore() {
    		return score;
    	}
    	public void setScore(int score) {
    		this.score = score;
    	}
    }
    public static void main(String[] args) {
    	List<Students> students = new ArrayList<Students>();
    	students.add(new Students(23, 100));
    	students.add(new Students(27, 98));
    	students.add(new Students(29, 99));
    	students.add(new Students(29, 98));
    	students.add(new Students(22, 89));
    	Collections.sort(students, new Comparator<Students>() {
    		@Override
    		public int compare(Students o1, Students o2) {
    			int i = o1.getScore() - o2.getScore();
    			if(i == 0){
    				return o1.getAge() - o2.getAge();
    			}
    			return i;
    		}
    	});
    	for(Students stu : students){
    		System.out.println("score:" + stu.getScore() + ":age" + stu.getAge());
    	}
    	/*
    	 * 输出结果
    	 * score:89:age22
    	 * score:98:age27
    	 * score:98:age29
    	 * score:99:age29
    	 * score:100:age23
    	 */
    }
    

    从上面的例子我们可以看出Students类没有实现Comparable接口,只是在sort()方法中多传入一个参数,只不过该参数是一个接口我们需要实现其compare方法。

    展开全文
  • 最新Java集合排序以及java集合类详解(Collection , List ,Set , Map 摘 要 ? 摘要内容 Java里面最重要最常用也就是集会一部分了能够用好集合和理解好集合对于做Java程序的开发拥有无比的好处本文详细解释了关于Java...
  • 利用Java8的stream流和Comparator实现集合排序 temp = temp.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList()); 结果如下: 支持倒叙排序,在正序的基础上再调用reversed...

    学生数据模型如下:

     

    @Data
    @AllArgsConstructor
    public class User implements Comparable<User>{
        private int age;
        private String sex;
        private int grade;
    
        @Override
        public int compareTo(User o) {
            return o.getAge()-this.getAge();
        }
    }

    包括了学生年龄,性别,年级属性

    有一组学生数据集合如下:

    现在要求要对这组学生数据按年龄进行排序

    1:利用集合框架提供的Collections.sort实现排序,其中User需要实现比较器Comparable接口,并且实现其中compareTo接口,返回的时当前入参的学生和当前这个学生的年龄差,负数,0,正数表示当前入参比本身小,相等和大,调用Collections.sort(temp);返回的排序方式为自然排序,结果如下:

    2.Collections.sort还提供了两个参数的方法,第二个参数为为比价器,如下:

     

    Collections.sort(temp, new Comparator<User>() {
        @Override
        public int compare(User o1, User o2) {
            return -o1.getAge()+o2.getAge();
        }
    });

    如果用这种方式实现排序,则User就不用实现Comparable,而是直接在调用sort接口时穿一个Comparator的对象,即匿名内部类,实现compare接口,如上,实现结果如下:

    如果compare接口改写如下:

     

    Collections.sort(temp, new Comparator<User>() {
        @Override
        public int compare(User o1, User o2) {
            return o1.getAge()-o2.getAge();
        }
    });

    则排序相反,如下:

    3.如果jdk版本为Java8或者更高的版本,则可以利用java8的新特性的stream流实现排序,而且user对象无需实现compare接口,代码如下:

     

    //3.利用Java8的stream流和Comparator实现集合排序
    temp = temp.stream().sorted(Comparator.comparing(User::getAge)).collect(Collectors.toList());

    结果如下:

    支持倒叙排序,在正序的基础上再调用reversed方法,代码如下:

     

    temp = temp.stream().sorted(Comparator.comparing(User::getAge).reversed()).collect(Collectors.toList());

    结果如下:

     

    现在如果排序要求更复杂,排序要求:先按学生年龄降序排序,年龄相等的话,则按年级升级排序!则可以利用java8的stream流实现,如下:

     

    temp =  temp.stream().sorted(Comparator.comparing(User::getAge)
                                  .reversed()
                                  .thenComparing(Comparator.comparing(User::getGrade))
                        ).collect(Collectors.toList());

    结果如下:

    如果要求排序为:先按年龄降序排序,再按年级降序排序,代码如下:

     

    temp =  temp.stream().sorted(Comparator.comparing(User::getAge)
                                  .reversed()
                                  .thenComparing(Comparator.comparing(User::getGrade).reversed())
                        ).collect(Collectors.toList());

    结果如下:

     

    4.如果排序对象为数组的话,则调用数组的Arrays.sort方法同样可以实现数组的排序,不过这要求user类需要实现compare接口,同集合的sort方法类似,这边不在描述。

     

    展开全文
  • 由于List元素可以重复,去重用循环很low,但由于Set是不可重复的,所以可借用set进行去重 ... * list1 -- 未去重的集合  * list2 -- 去重后的集合  *   * */      List&lt;String&gt; list1 = new ...
  • 主要介绍了java如何对map进行排序,java map集合的使用详解,大家可以参考使用
  • 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 ...
  • NULL 博文链接:https://singhoo.iteye.com/blog/1717722
  • java 对象集合按字段排序
  • JavaList集合根据时间字段排序

    千次阅读 2021-03-21 17:25:47
    大家做了个案例,让我们直接贴代码 import java.text.SimpleDateFormat; import java.util.ArrayList;...import java.util.List; public class Test02 { public static void main(String[] args) { Lis
  • JavaList集合排序

    万次阅读 2016-01-24 17:07:47
    Java 集合框架中使用最为普遍的集合类之一。ArrayList 是一种 List 实现,它的内部用一个动态数组来存储元素,因此 ArrayList 能够在添加和移除元素的时候进行动态的扩展和缩减。 使用Collections工具类进行排序: ...
  • java8 list集合内排序问题 list是java开发最常用的容器之一,有时需要对获取的...java8以后使用lamda表达式比较可以大大简化list集合排序的代码实现。下面我分别用这三种方法对list进行排序: lamda表达式写法: ...
  • 在开发中,我们可能会遇到,我们会根据不同情况对一个List集合进行排序操作,为了方便List集合根据对象中的某一个属性进行排序,开发了此工具类:
  • public class Java8Test { public static void main(String[] args) { Person p1 = new Person("麻子", 31); Person p2 = new Person("李四", 20); Person p3 = new Person("王五", 26); List<Person&...
  • import java.util.List; import lombok.Data; @Data public class StudentInfo{ //名称 private String name; //性别 true男 false女 private Boolean gender; //年龄 private Integer age; //身高 pri...
  • 假设有个Employee的类 public class Employee { private String name; private int age; private double salary;...有个employees的List集合 List<Employee> employees = Arrays.asList( ...
  • 今天小编就为大家分享一篇关于List集合中对数据实现多重规则进行排序的案例,小编觉得内容挺不错的,现在分享大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • java list集合根据时间字段排序

    千次阅读 2020-09-19 11:04:14
    // list列表根据元素中的时间字段进行排序 public List listSort2(List<AppChatApiRes> initList) {// 接收实体类list List<AppChatApiRes> list = initList; // System.out.println("排序前----:" + ...
  • javalist集合冒泡排序

    万次阅读 2015-01-05 13:55:08
    javaList集合进行冒泡排序。。。
  • 集合中的对象进行排序,例如:List中存放了User对象,则可根据User对象的某一个属性进行顺序or倒序的排序
  • Java中的list集合排序方法

    千次阅读 2018-06-27 00:35:44
    java中提供了对集合进行操作的工具类Collections,Collections对集合中的元素提供了默认的排序方法,sort(),根据元素的自然顺序 对指定列表按升序进行排序。这里举两个例子来说明下这个方法 1.首先是一个简单的...
  • Java 集合ArrayList排序

    千次阅读 2020-08-19 16:12:48
    Java 集合ArrayList排序 ArrayList的排序可以借助Collections工具类的sort(List list)以及重载的sort(List list, Comparator<? super T> c)方法;其中要想使用sort(List lis)方法进行排序集合元素必须实现...
  • JAVA实现快速排序

    2017-05-23 21:18:49
    java实现的快速排序算法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 163,479
精华内容 65,391
关键字:

java给list集合内容排序

java 订阅