精华内容
下载资源
问答
  • 在开发中,我们可能会遇到,我们会根据不同情况对一个List集合进行排序操作,为了方便List集合根据对象中的某一个属性进行排序,开发了此工具类:
  • 1. 根据集合对象某个属性值, 排序 List<RoomCartypeParamters> roomCartypeParamtersList = new ArrayList<>(); //进行排序, 按照指定字段升序排列 Collections.sort(roomCartypeParamtersList, ...

    1. 根据集合中对象的某个属性值, 排序

      List<RoomCartypeParamters> roomCartypeParamtersList = new ArrayList<>();
            //进行排序, 按照指定字段升序排列
            Collections.sort(roomCartypeParamtersList, new Comparator<RoomCartypeParamters>() {
                @Override
                public int compare(RoomCartypeParamters o1, RoomCartypeParamters o2) {
                    return o1.getId().compareTo(o2.getId());
                }
            });
            return roomCartypeParamtersList;
        }
    

    2. 附加知识

    2.1 set集合转list集合的操作

    Set<RoomCartypeParamters> roomCartypeParamtersSet = new HashSet<>();
    //可通过new的方式, 将set集合转为arrayList集合
     List<RoomCartypeParamters> roomCartypeParamtersList = new ArrayList(roomCartypeParamtersSet);
    
    

    2.2 将小集合放入大集合中

    List<RoomCartypeParamters> roomCartypeParamtersListAll = new ArrayList<>();
    List<RoomCartypeParamters> roomCartypeParamtersList = roomCartypeParamtersMapper.getCarParamtersDetail(roomCartypeParamters);
                    roomCartypeParamtersListAll.addAll(roomCartypeParamtersList);
    
    展开全文
  • 错了,现在是java8的时代,我们来看看新特性下如何排序的: List<CountCardDetailVo> all = new ArrayList<>(); //根据创建时间降序排序 all.sort(Comparator.comparing(CountCardDetailVo::...

    附:本文大部分参考网上资源,主要用于个人的笔记心得记录

     

    下面是个人在处理业务中的使用:

    到了这里你觉得很神奇?错了,现在是java8的时代,我们来看看新特性下如何排序的:

    List<CountCardDetailVo> all = new ArrayList<>();
    //根据创建时间降序排序
    all.sort(Comparator.comparing(CountCardDetailVo::getCreateTime).reversed());
    //根据创建时间升序排序
    all.sort(Comparator.comparing(CountCardDetailVo::getCreateTime));

     

    展开全文
  • 主要介绍了java ArrayList集合中的某个对象属性进行排序的实现代码,需要的朋友可以参考下
  • 首先讲一下Comparable接口和Comparator接口...1.Comparable自然规则排序 //在自定义类Student里面实现Comparable接口,并重写抽象方法compareTo(User u); //Collections.sort(集合); 实例: public static void m...

    首先讲一下Comparable接口和Comparator接口,以及他们之间的差异。有助于Collections.sort()方法的使用。请参考

    1.Comparable自然规则排序
    //在自定义类Student里面实现Comparable接口,并重写抽象方法compareTo(User u);
    //Collections.sort(集合);

    实例:

    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]

    稍微复杂的List里面放一个复杂的对象

    public class ListTest {
    
    	public static void main(String[] args) {
    		
    		List<User> list = new ArrayList<User>();
    		User u1 = new User(1,"张三丰");
    		User u2 = new User(2,"王重阳");
    		User u3 = new User(3,"郭靖");
    		User u4 = new User(4,"1");
    		User u5 = new User(5,"awm");
    		list.add(u1);
    		list.add(u2);
    		list.add(u3);
    		list.add(u4);
    		list.add(u5);
    		
    		for(User u : list){
    			System.out.print(u.getAge() + "-" +u.getName() + " ");
    		}
    		System.out.println();
    		
    		Collections.sort(list);
    		
    		for(User u : list){
    			System.out.print(u.getAge() + "-" +u.getName() + " ");
    		}
    	}
    }
    
    class User implements Comparable<User> {
    	
    	//省略构造器及get/set方法
    	@Override
    	public int compareTo(User o) {
    		
    		return this.name.compareTo(o.getName());
    	}
    }
    

    输出结果:

    1-张三丰 2-王重阳 3-郭靖 4-1 5-awm 
    4-1 5-awm 1-张三丰 2-王重阳 3-郭靖 

    很明显咱们要求的按name中文排序是没有达到的,咱们再做下调整,如下例

    public class ListTest {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		List<User> list = new ArrayList<User>();
    		User u1 = new User(1,"张三丰");
    		User u2 = new User(2,"王重阳");
    		User u3 = new User(3,"郭靖");
    		User u4 = new User(4,"1");
    		User u5 = new User(5,"awm");
    		list.add(u1);
    		list.add(u2);
    		list.add(u3);
    		list.add(u4);
    		list.add(u5);
    		
    		for(User u : list){
    			System.out.print(u.getAge() + "-" +u.getName() + " ");
    		}
    		System.out.println();
    		
    		Collections.sort(list);
    		
    		for(User u : list){
    			System.out.print(u.getAge() + "-" +u.getName() + " ");
    		}
    	}
    }
    
    class User implements Comparable<User> {
    	Collator collator = Collator.getInstance(java.util.Locale.CHINA);
    	
    	//省略属性及get/set方法
    	@Override
    	public int compareTo(User o) {
    		// TODO Auto-generated method stub
    		return collator.compare(this.name, o.getName());
    	}	
    
    }
    

    输出结果:

    1-张三丰 2-王重阳 3-郭靖 4-1 5-awm 
    4-1 5-awm 3-郭靖 2-王重阳 1-张三丰 

    符合排序要求

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

    2.Comparator专门规则排序(l临时排序)
    //新建一个实现了Comparator接口的类,并重写抽象方法compare(User u1, User u2);
    //Collections.sort(集合,实现了Comparator接口的类的实例化对象);

    Collections提供的第二种排序方法sort(List<T> list, Comparator<? super T> c)
    先看例子:

    public class ListTest {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		List<User> list = new ArrayList<User>();
    		User u1 = new User(1,"张三丰");
    		User u2 = new User(2,"王重阳");
    		User u3 = new User(3,"郭靖");
    		User u4 = new User(4,"1");
    		User u5 = new User(5,"awm");
    		list.add(u1);
    		list.add(u2);
    		list.add(u3);
    		list.add(u4);
    		list.add(u5);
    		
    		for(User u : list){
    			System.out.print(u.getAge() + "-" +u.getName() + " ");
    		}
    		System.out.println();
    		
    		Collections.sort(list,new User());
    		
    		for(User u : list){
    			System.out.print(u.getAge() + "-" +u.getName() + " ");
    		}
    	}
    }
    
    class User implements Comparator<User> {
    	Collator collator = Collator.getInstance(java.util.Locale.CHINA);
    	
    	//省略属性及get/set方法
    	@Override
    	public int compare(User o1, User o2) {
    		// TODO Auto-generated method stub
    		return collator.compare(o1.getName(), o2.getName());
    	}
    }
    

    输出结果:

    1-张三丰 2-王重阳 3-郭靖 4-1 5-awm 
    4-1 5-awm 3-郭靖 2-王重阳 1-张三丰 

    符合排序要求

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

    以上两种均可实现按集合对象属性首字母或者说是拼音排序,仅供参考。

     

     

    展开全文
  • import java.util.ArrayList;... * 首先先看一下关于集合排序Demo; * * 先创建一个自己的测试类; * @author Administrator * */ public class SortTest { public static void main(String[] args).
    package cn.sort;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    /**
     * 集合排序;
     * 
     * 首先先看一下关于集合的排序Demo;
     * 
     * 先创建一个自己的测试类;
     * @author Administrator
     *
     */
    public class SortTest {
    
    	public static void main(String[] args) {
    		
    		// 实例化一个指定类型存储的List集合;
    		List<String> list = new ArrayList<String>();
    		
    		// 集合数据装载;
    		list.add("aaa");
    		list.add("ccc");
    		list.add("bbb");
    		
    		// 利用Collections工具类的sort()进行升序;
    		Collections.sort(list);
    		
    		// 控制台数据打印;
    		System.out.println(list);
    		
    	}
    	
    }
    
    package cn.sort;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    /**
     * 
     * 集合对象排序|根据集合中对象的指定属性进行排序;
     * 
     * 下面整理一下关于集合对象的排序规则;
     * 
     * 利用实现Comparator来进行排序;
     * 
     * 首先还是和以往一样,创建一个自己的测试类;
     * @author Administrator
     *
     */
    public class CollectionsSort {
    	
    	/**
    	 * Java主函数|入口;
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		
    		/**
    		 * 实例化一个指定对象存储的List集合;
    		 */
    		List<Student> list = new ArrayList<Student>();
    		
    		// 对象数据装载;
    		Student b = new Student("BBB","Y",32);
    		Student c = new Student("CCC","x",33);
    		Student a = new Student("AAA","Y",31);
    		
    		// 集合数据装载;
    		list.add(a);
    		list.add(b);
    		list.add(c);
    		
    		// 调用排序规则;
    		sortObj(list);
    		
    		//重新打印排序后的集合数据;
    		for(Student people : list) {
    			
    			// 控制台数据打印;
    			System.out.println(people.getAge());
    		}
    	}
    	
    	/**
    	 * 封装排序函数|方法;
    	 * @param list
    	 */
    	public static void sortObj(List<Student> list) {
    		
    		/**
    		 * 自定义排序规则;
    		 * 
    		 * 利用Collections工具类的sort()方法进行重写排序规则;
    		 */
    		Collections.sort(list,  new Comparator<Student>() {
    
    			/**
    			 * 重写排序规则;
    			 * @param a
    			 * @param b
    			 * @return
    			 */
    			@Override
    			public int compare(Student a, Student b) {
    				
    				/**
    				 * 自定义排序规则;
    				 * 
    				 * 如果没有明确具体的排序内容,可以直接进行对象排序;
    				 * Eg: a.compareTo(b);
    				 * 
    				 * 如果有明确的需求说要对某个集合中的对象按照指定属性进行排序,
    				 * 则可以按照以下方式进行自定义排序;
    				 */
    				String one = a.getSex();
    				String two = b.getSex();
    //				return two.compareTo(one);
    				return one.compareTo(two);
    			}
    		});
    	}
    
    }
    
    /**
     * 封装自定义排序规则;
     * 
     * 下面是将排序规则封装进入自己特定的工具类中,
     * 可以根据不同的需求封装不同的函数|方法;
     * @author Administrator
     *
     */
    class sortUtils implements Comparator {
    
    	@Override
    	public int compare(Object o1, Object o2) {
    		String a = (String) o1;
    		String b = (String) o2;
    		return -a.compareTo(b);
    	}
    	
    }
    
    /**
     * 临时创建一个Entity测试类;
     * 
     * @author Administrator
     *
     */
    class Student {
    	
    	// 初始化私有属性;
    	private String name;
    	private String sex;
    	private int age;
    	
    	/**
    	 * 由于申明了有参构造,故而
    	 * 在这里需要重新申明无参构造器;
    	 * 
    	 * 在默认的情况下无参构造器就存在,只是当创建了有参构造器之后便覆盖了无参构造器;
    	 * 所以需要自己重现有参构造器;
    	 */
    	public Student() {}
    
    	/**
    	 * 申明有参构造器;
    	 * 
    	 * 根据指定顺序的构造器进行对象初始化;
    	 * @param name
    	 * @param sex
    	 * @param age
    	 */
    	public Student(String name, String sex, int age) {
    		this.name = name;
    		this.sex = sex;
    		this.age = age;
    	}
    	
    	/**
    	 * Get/Set;
    	 * @return
    	 */
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getSex() {
    		return sex;
    	}
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    }
    
    
    /**
     * 数据排序.
     * @param platformList
     */
    public static void sortPlatformList(List<BePlatform> platformList) {
      Collections.sort(platformList, new Comparator<BePlatform>() {
        @Override
        public int compare(BePlatform p1, BePlatform p2) {
          return p1.getStartTime().compareTo(p2.getStartTime());
        }
      });
    }

     

    展开全文
  • java8List根据某个属性排序

    万次阅读 2019-05-23 19:56:00
    List<PromotionForHomeDto> list = promotionBasicDao. list(new WherePrams().orderBy("create_time desc")); list = list.stream().sorted(Comparator.comparing(PromotionForHomeDto::getCreateTime)) ...
  • 如何对List集合中的对象进行按某个属性排序

    万次阅读 多人点赞 2018-03-06 08:42:33
    我们在实际的开发工作中,经常会碰到排序的问题,如题,我们如何针对List集合中的某一个属性进行排序先举一个简单的例子:package test; import java.util.ArrayList; import java.util.List; import java.util.*; ...
  • 1.以集合某个对象属性的时间顺序排列 List<CutPriceReport> cutPriceReportList =cutPriceReportList(); if(cutPriceReportList != null && cutPriceReportList.size() > 0){ ...
  • package com.stream; import java.util.Comparator; import java.util.List; public class Test { public static void main(String[] args) { ... //根据TestDto对象的priority字段降序排序 dtoList.sort(Co
  • 这里新建一个UserInfo对象,用来测试lambda表达式排序属性如下: public class UserInfo { private int id; private int age; private String name; public UserInfo(int id, int age, String name) { this....
  • 1、声明一个测试对象 import java.time.LocalDate; import java.util.List; import lombok.Data; @Data public class StudentInfo{ //名称 private String name; //性别 true男 false女 private Boolean ...
  • list集合排序
  • 按照A对象中的orderIndex的值进行排序 private List<A> sortlist(List<A> list) { Collections.sort(list, new Comparator<A>() { @Override public int compare(A o1, A o2) { //按照值的...
  • 对象属性如下,期望结果是:查询出来的列表,active为true的在前,false的在后。 实现如下: @Override public List<TaskNotifyPolicy> findByBelongId(String belongId) { List<TaskNotifyPolicy...
  • Map集合按某个属性排序

    千次阅读 2018-02-07 17:02:23
    集合按照“xiangMuShu”这个属性进行排序,示例代码如下:  List> listMap = new ArrayList>();  TreeMap map1 = new TreeMap();  map1.put("xiangMuShu", 84.3);  map1.put("fenLeiName", "电子");  Tree...
  • 最近项目里需要对集合中的对象按照name属性排序,要求name属性按照字母排序后,返回集合结果,下面是实现方式: 首先要实现排序的对象要实现Comparable类,重写该类的compareTo方法,方法里写明要比较的属性,代码...
  • 前段时间跟公司前端对接的时候,一个简单的数据库查询,但是前端说将结果按某个属性分组,每组单独一个集合,集合第一个元素为该属性,第二个元素为该属性值相同的所有对象集合,由于是小白一个,这个数据整理也是花...
  • // 先将需要排序的实体对象集合赋值给orderList集合 int len = orderList.size(); // 长度 for ( int i = 0 ;i ;i++){ for ( int j = 0 ;j (i + 1 );j++){ // 将较大电量值的实体对象向后移动 ...
  • import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.List;... * Java程序对集合里的对象按对象某个属性排序,这个属性是日期(YYYY-MM-DD hh:mm) * @author
  • 在进行软件构造实验三的过程中,遇到了对List集合按照对象的某一属性排序的问题,我们知道,在一般的情况下,java中提供了对集合进行操作的工具类Collections, Collections能够对集合中的元素用默认的排序方法sort...
  • 实现根据属性age升序排列: public class MainTest { public static void main(String[] args) { List<Person> list = Lists.newArrayList( new Person("1","abc",1), new Person("4","abc",4), ...
  • public static void main(String[] args) throws Exception{ ArrayList<Car> list = new ArrayList<>(); for(int i=0;i<100;i++){ Car car = new Car(); car.setId(i); car.setName("第一条"+... .
  • java8 的排序有两种 使用sorted方法排序 : 使用sort方法排序 区别直接看代码 public class Main { public static void main(String[] args) { //创建Users List<User> users = createUsers(); //排序...
  • https://blog.csdn.net/weixin_43563446/article/details/83552305
  • java集合对象属性比较排序

    千次阅读 2017-05-12 21:32:44
    TreeSet:它可以给Set集合中的元素进行指定方式的排序。 保证元素唯一性的方式:通过比较的结果是否为0. 底层数据结构是:二叉树。 排序的第一种方式: 让元素自身具备比较性。只要让元素实现Comparable接口,覆盖...
  • NULL 博文链接:https://uule.iteye.com/blog/765832
  • import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; class OrangeTest { public static void main(String[] args) { //定义list集合 List<Dome> list = Arrays.asList...
  • 1、如果两个对象equals,Java运行时环境会认为他们的hashcode 一定相等 。  2、如果两个对象不equals,他们的hashcode 有可能 相等。  3、如果两个对象hashcode相等,他们 不一定 equals。  4、如果两个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 54,687
精华内容 21,874
关键字:

java对象集合按某个属性排序

java 订阅