Java-很深我只知其一-entity继承Comparable重写compareTo实现排序

本文详细介绍了在Java中如何通过重写实体类的compareTo方法实现排序，包括升序和降序的实现方式，并展示了如何使用Collections.sort进行排序操作。同时，文章还提供了使用匿名内部类和Lambda表达式对Map集合进行排序的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java-很深我只知其一-entity继承Comparable重写compareTo实现排序

实体类排序

compareTo方法返回值int,其实int足以,其底层只识别正数和负数和零;
做出参数和原对象比较,参数比原值大返回正数,参数比原值小返回负数,零什么也不做,这样是正常排序,也就是升序,返回值相反,则是降序;

重写compareTo方法之后,调用;

Collections.sort(list) ,list会是排序结果;

也可以实现多字段排序,实现自定义排序结果;

package com.utils;

import java.io.Serializable;

import com.alibaba.fastjson.JSONObject;
@SuppressWarnings("serial")
public class Interval implements Serializable, Comparable<Interval> {
	      long start, end;
	      String ipStart;
	      String ipEnd;
	      String ips;
	      long size;
	      
	      
	      
	      
	    public String getIpStart() {
			return ipStart;
		}
		public void setIpStart(String ipStart) {
			this.ipStart = ipStart;
		}
		public String getIpEnd() {
			return ipEnd;
		}
		public void setIpEnd(String ipEnd) {
			this.ipEnd = ipEnd;
		}
		public long getSize() {
			return size;
		}
		public void setSize(long size) {
			this.size = size;
		}
		public String getIps() {
			return ips;
		}
		public void setIps(String ips) {
			this.ips = ips;
		}
		public Interval(long start, long end) {
	          this.start = start;
	          this.end = end;
	      }
		
		public Interval(String ipStart,String ipEnd,long start, long end) {
	          this.start = start;
	          this.end = end;
	          this.ipStart = ipStart;
	          this.ipEnd = ipEnd;
	          this.size = end -start +1;
	      }
		public Interval() {

	      }
		public long getStart() {
			return start;
		}
		public void setStart(long start) {
			this.start = start;
		}
		public long getEnd() {
			return end;
		}
		public void setEnd(long end) {
			this.end = end;
		}

		@Override
		public String toString(){
			JSONObject obj = new JSONObject();
			obj.put("start", this.getStart());
			obj.put("end", this.getEnd());
			return obj.toString();
			
		}
		


		@Override
		public int compareTo(Interval o) {
            

           //第一条件升序排序
			if (this.start > o.start)
				return 1;
			if (this.start < o.start)
				return -1;
             //第二条件升序排序
			if (this.end > o.end)
				return 1;
			if (this.end < o.end)
				return -1;
			return 0;
		}
	
}

测试代码

@Test
    public void CollectionsSortTest(){

        Interval int1 = new Interval(255255255255L,3);
        Interval int2 = new Interval(255255255257L,99);
        Interval int22 = new Interval(255255255251L,6);
        Interval int3 = new Interval(28,10);
        Interval int444 = new Interval(11,99);
        Interval int4 = new Interval(11,1);
        Interval int44 = new Interval(11,123);
        Interval int25 = new Interval(2374263757232647267L,2);
        Interval int55 = new Interval(23742375723264726L,2);
        Interval int5 = new Interval(113,2);
        Interval int6 = new Interval(15,3);
        Interval int7 = new Interval(117,4);
        Interval int8 = new Interval(19,6);
        Interval int28 = new Interval(255205255251L,6);
        Interval int9 = new Interval(22,8);
        Interval int19 = new Interval(1,9999);

        ArrayList<Interval> list = new ArrayList<>();
        list.add(int1);
        list.add(int2);
        list.add(int25);
        list.add(int55);
        list.add(int3);
        list.add(int4);
        list.add(int44);
        list.add(int444);
        list.add(int5);
        list.add(int6);
        list.add(int28);
        list.add(int7);
        list.add(int8);
        list.add(int19);
        list.add(int9);
        list.add(int22);
        Collections.sort(list);
        for (Interval s : list) {
            System.out.println(s);
        }
    }

输出结果

Map对象排序

方法①

有一个List集合,其对象为Map
根据Map对象中一个Key或多个Key实现排序

/**
 *    codeItems 已有List<HashMap<String,Object> 集合
 *    dispNo Map对象其中Key之一
 */
Collections.sort( codeItems, new Comparator<HashMap<String, Object>>() {
			@Override
			public int compare(HashMap<String, Object> o1, HashMap<String, Object> o2) {
				if (MapUtils.isEmpty( o1 ) || MapUtils.isEmpty( o1 ))
					return 0;
				Integer o1DispNo = Integer.valueOf( o1.get( "dispNo" ).toString() );
				Integer o2DispNo = Integer.valueOf( o2.get( "dispNo" ).toString() );
				if (o1DispNo > o2DispNo)
					return 1;
				if (o2DispNo > o1DispNo)
					return -1;
				return 0;
			}

也可以将其封装成一个方法

//codeItem 排序 权限修饰符 如果只在当前使用 , 最好私有化
    public List<HashMap<String, Object>> codeItemSort (List<HashMap<String, Object>> codeItems){
		Collections.sort( codeItems, new Comparator<HashMap<String, Object>>() {
			@Override
			public int compare(HashMap<String, Object> o1, HashMap<String, Object> o2) {
				if (MapUtils.isEmpty( o1 ) || MapUtils.isEmpty( o1 ))
					return 0;
				Integer o1DispNo = Integer.valueOf( o1.get( "dispNo" ).toString() );
				Integer o2DispNo = Integer.valueOf( o2.get( "dispNo" ).toString() );
				if (o1DispNo > o2DispNo)
					return 1;
				if (o2DispNo > o1DispNo)
					return -1;
				return 0;
			}
		} );
		return codeItems;
	}

测试代码

@Test
	public void mapSort (){
		HashMap<String, String> map = new HashMap<>();
		map.put( "parentNo", "SCP_FAILURE_CODE_MSG");
		List<HashMap<String, Object>> list = this.itemCodeMapper.getCodeItems( map );
		list = this.codeItemService.codeItemSort( list );
		for (HashMap<String, Object> item : list) {
			System.out.println(item);
		}
	}

测试效果

方法②

如果使用的jdk版本在1.8以上,可以使用1.8新特性Lambada
使代码更简洁,如果数据量大性能更好

 public static void main(String[] args) {
        List<Map<String, Integer>> list = new ArrayList<>();
        Map<String, Integer> map1 = new HashMap<>();
        map1.put("no",111);
        Map<String, Integer> map2 = new HashMap<>();
        map2.put("no",222);
        Map<String, Integer> map3 = new HashMap<>();
        map3.put("no",333);
        list.add( map1 );
        list.add( map2 );
        list.add( map3 );
        list.sort( (Map<String,Integer> m1,Map<String,Integer> m2)->{
            return m2.get( "no" ).compareTo( m1.get( "no" ) );
        } );
        list.forEach( s-> System.out.println(s.toString()));
    }

测试结果: