java排序接口Comparable<T> 的实现与使用

java集合排序

一、map集合的排序

比较value进行排序

		List<String> lastEventCauselist = new ArrayList<String>();
		List<String> lastNumlist = new ArrayList<String>();
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        for(int i=0;i<Numlist.size();i++) {
        	map.put(eventCauselist.get(i), Integer.valueOf(Numlist.get(i)));
        }
		
        List<Map.Entry<String,Integer>> list = new ArrayList<Map.Entry<String,Integer>>(map.entrySet());
        Collections.sort(list,new Comparator<Map.Entry<String,Integer>>() {
            //升序排序
            public int compare(Entry<String, Integer> o1,
                    Entry<String, Integer> o2) {
                return o1.getValue().compareTo(o2.getValue());
            }

        });
        
        for(Map.Entry<String,Integer> mapping:list){ 
        	lastEventCauselist.add(mapping.getKey());
        	lastNumlist.add(String.valueOf(mapping.getValue()));
       } 
        
		
		maps.put("eventCauselist", eventCauselist);
		maps.put("Numlist", Numlist);

Map遍历与排序

LinkHashMap有序的，前台通过each遍历有序的map

一般通过map排序，前台list获取有序的封装数据并展示

比较key进行排序

	public Map<String, List<String>> getRadarChartData(String deviceCode)
	{
		Map<String, List<String>> maps = new HashMap<String, List<String>>(); 		 
        String radarCeilTime = prPreStationMapper.getRadarCeilTime(deviceCode);
		List<ScadaVO> radarRecordChartName = prPreStationMapper.getRadarRecordChartName(deviceCode);
		if(StringUtil.isEmpty(radarCeilTime))
		{
			return null;
		}
		if(CollectionUtils.isEmpty(radarRecordChartName)) {
			return null;
		}
		String radarMaxTime = prPreStationMapper.getRadarMaxTiem(deviceCode);

		String[] dateString = {radarMaxTime+"00:00",radarMaxTime+"23:00",radarMaxTime+"22:00",radarMaxTime+"21:00",radarMaxTime+"20:00",radarMaxTime+"19:00",radarMaxTime+"18:00",radarMaxTime+"17:00",radarMaxTime+"16:00",radarMaxTime+"15:00",radarMaxTime+"14:00",radarMaxTime+"13:00",radarMaxTime+"12:00",radarMaxTime+"11:00",radarMaxTime+"10:00",radarMaxTime+"09:00",radarMaxTime+"08:00",radarMaxTime+"07:00",radarMaxTime+"06:00",radarMaxTime+"05:00",radarMaxTime+"04:00",radarMaxTime+"03:00",radarMaxTime+"02:00",radarMaxTime+"01:00"};
		
		Map<String, Object> radarData = new HashMap<String,Object>(1);

	
	
			for(int i=0;i<dateString.length;i++)
			{
				radarData.put(dateString[i], radarCeilTime);
			}

		//查询真实数据
		for(ScadaVO sc:radarRecordChartName)
		{
			radarData.put(sc.getTimestamp().substring(0, 16), sc.getTagValue());	
		}
		
	      Map<String, Object> map = new TreeMap<String, Object>(
	                new Comparator<String>() {
	                    public int compare(String obj1, String obj2) {
	                        // 降序排序
	                        return obj2.compareTo(obj1);
	                    }
	                });
	              for (Map.Entry<String, Object> entry : radarData.entrySet()) {
	            	  map.put(entry.getKey(), entry.getValue());
                   }
	              
	      //map转为list，否则前台获取object 通过for in获取的数据是无序的
	      List<String> listKey = new ArrayList<String>();
	      List<String> listValue = new ArrayList<String>();
	      List<String> dataKey = new ArrayList<String>();
			
		  //echarts顺时针展示
	      String zeroTime = radarMaxTime+"00:00";
	      Object firstMap = map.get(zeroTime);
	      listKey.add(zeroTime);
	      listValue.add(String.valueOf(firstMap));
		  if(!radarCeilTime.equals(String.valueOf(map.get(zeroTime)))) {
			  dataKey.add(String.valueOf(firstMap));
	       }else {
	    	   dataKey.add("");
	       }
	      Iterator<String> it = map.keySet().iterator();
	       while (it.hasNext()) {
	       String key = it.next().toString();
	       if(!zeroTime.equals(key)) {
		       listKey.add(key);
		       listValue.add(radarCeilTime);
		       if(!radarCeilTime.equals(String.valueOf(map.get(key)))) {
		    	   dataKey.add(String.valueOf(map.get(key)));
		       }else {
		    	   dataKey.add("");
		       }
	        }
	       }
	       
	       maps.put("textlist", listKey);
	       maps.put("maxlist", listValue);
	       maps.put("datalist", dataKey);
		   return maps;
	}

	public Map<String, List<String>> showLeakPointVO(LeakPointVO vo)
	{
		Map<String, List<String>> maps = new HashMap<String, List<String>>();
		List<String> datelist = new ArrayList<String>();
		List<String> Numlist = new ArrayList<String>();
		List<String> Longlist = new ArrayList<String>();
		 ArrayList<String> dyOrglist =new ArrayList<String>();
		
		List<LeakPointVO> rushCount = leakMapper.showLeakPointVO(vo);
		LeakPipeVO leakPipeVO = new LeakPipeVO();
		List<LeakPipeVO> LeakPipeCount  = leakMapper.showLeakPipeVO(leakPipeVO);
		
		List<LeakPointVO> realRushCount = new ArrayList<LeakPointVO>();
		List<LeakPipeVO> realLeakPipeCount = new ArrayList<LeakPipeVO>();
		
		for (LeakPointVO leakPointVO : rushCount) {
			dyOrglist.add(leakPointVO.getCheckDate());
		}

		for(LeakPipeVO LeakpipeVO:LeakPipeCount) {
			if(!dyOrglist.contains(LeakpipeVO.getTrackDate())) {
				dyOrglist.add(LeakpipeVO.getTrackDate());
			}	
		}
		
        Map<String, String> map = new TreeMap<String, String>(
                new Comparator<String>() {
                    public int compare(String obj1, String obj2) {
                        // 降序排序
                        return obj1.compareTo(obj2);
                    }
                });
		ArrayList<String> rtDatelist =new ArrayList<String>();
		for(String month:dyOrglist) {
			map.put(month, month);
		}
        Set<String> keySet = map.keySet();
        Iterator<String> iter = keySet.iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            rtDatelist.add(map.get(key));
        }
		
		
		for(String daylistName:rtDatelist) {
			String checkDateName = compareDic(daylistName);
			datelist.add(checkDateName);
		}
		
		for(String dyorg :rtDatelist) {
			boolean flag = false;
			for(LeakPointVO leakPointVO:rushCount) {
				if(dyorg.equals(leakPointVO.getCheckDate())) {
					realRushCount.add(leakPointVO);
					flag= true;
					break;
				}
			}
			if(!flag) {
				LeakPointVO leakPointVO = new LeakPointVO();
				leakPointVO.setCheckDate(dyorg);
				leakPointVO.setNormalValue("0");
				realRushCount.add(leakPointVO);
			}
		}
		
		
		for (LeakPointVO leakPointVO : realRushCount) {
			String counts = leakPointVO.getNormalValue();
			String checkDate = leakPointVO.getCheckDate();
			if(!dyOrglist.contains(checkDate)||null==checkDate) {
				continue;
			}
			Numlist.add(counts);
		}
		
		for(String dyorg :rtDatelist) {
			boolean flag = false;
			for(LeakPipeVO leakPieVO:LeakPipeCount) {
				if(dyorg.equals(leakPieVO.getTrackDate())) {
					String pipeLenth ="0.00";
					if(null!=leakPieVO.getPipeLength()) {
						pipeLenth = leakPieVO.getPipeLength();
					}
					Double format = Double.valueOf(pipeLenth);
					String fm = String.format("%.2f", format);
					leakPieVO.setPipeLength(fm.toString());
					realLeakPipeCount.add(leakPieVO);
					flag= true;
					break;
				}
			}
			if(!flag) {
				LeakPipeVO leakpeVO = new LeakPipeVO();
				leakpeVO.setTrackDate(dyorg);
				leakpeVO.setPipeLength("0.00");
				realLeakPipeCount.add(leakpeVO);
			}
		}
		
		for (LeakPipeVO LeakPipeVO : realLeakPipeCount) {
			String counts = LeakPipeVO.getPipeLength();
			String checkDate = LeakPipeVO.getTrackDate();
			if(!dyOrglist.contains(checkDate)||null==checkDate) {
				continue;
			}
			Longlist.add(counts);
		}
		
		maps.put("datelist", datelist);
		maps.put("Numlist", Numlist);
		maps.put("Longlist", Longlist);

		return maps;
	}
	

	private String compareDic(String type) {
		String eventCauseName= "";
		if(null!=type&&type.length()>0) {
			switch(type)
			{
			case "2018-01":
				eventCauseName = "1月";
				break;
			case "2018-02":
				eventCauseName = "2月";
				break;
			case "2018-03":
				eventCauseName = "3月";
				break;
			case "2018-04":
				eventCauseName = "4月";
				break;
			case "2018-05":
				eventCauseName = "5月";
				break;
			case "2018-06":
				eventCauseName = "6月";
				break;
			case "2018-07":
				eventCauseName = "7月";
				break;
			case "2018-08":
				eventCauseName = "8月";
				break;
			case "2018-09":
				eventCauseName = "9月";
				break;
			case "2018-10":
				eventCauseName = "10月";
				break;
			case "2018-11":
				eventCauseName = "11月";
				break;
			case "2018-12":
				eventCauseName = "12月";
				break;
			}
		}
		return eventCauseName;
	   }

 

list集合的排序

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

public class Test {

    public static void main(String[] args) {

        List<Student> list = new ArrayList<Student>();

        //创建3个学生对象，年龄分别是20、19、21，并将他们依次放入List中
        Student s1 = new Student();
        s1.setAge(20);
        Student s2 = new Student();
        s2.setAge(19);
        Student s3 = new Student();
        s3.setAge(21);
        list.add(s1);
        list.add(s2);
        list.add(s3);

        System.out.println("排序前："+list);

        Collections.sort(list, new Comparator<Student>(){

            /*
             * int compare(Student o1, Student o2) 返回一个基本类型的整型，
             * 返回负数表示：o1 小于o2，
             * 返回0 表示：o1和o2相等，
             * 返回正数表示：o1大于o2。
             */
            public int compare(Student o1, Student o2) {

                //按照学生的年龄进行升序排列
                if(o1.getAge() > o2.getAge()){
                    return 1;
                }
                if(o1.getAge() == o2.getAge()){
                    return 0;
                }
                return -1;
            }
        }); 
        System.out.println("排序后："+list);
    }
}

	public List<CheckAdvice> removeExtra(List<CheckAdvice> list) {
		List<CheckAdvice> newList= new ArrayList<CheckAdvice>();
        HashMap<String, String> hashMap = new HashMap<String, String>();
        for (CheckAdvice checkAdvice : list) {
            if (checkAdvice == null) {
                continue;
            }
            String  adviceId = checkAdvice.getAdviceId();
            if (adviceId != null) {
                String value = hashMap.get(adviceId);
                if (StringUtil.isEmpty(value)) { //如果value是空的  说明取到的这个adviceId是第一次取到
                    hashMap.put(adviceId, adviceId);
                    newList.add(checkAdvice); 
                } else {
                    continue;
                }
            }   
        }
        hashMap.clear();
        return newList;
	}

根据实体类中的某一字段进行排序

实体类实现Comparable<T> 接口，仅仅对集合中某个字段通过递归二次遍历，不影响整体查询返回结果的逻辑性。

import java.io.Serializable;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import com.cnten.platform.framework.web.dict.DictContext;
import com.github.pagehelper.util.StringUtil;

public class CheckAdvice implements Serializable,Comparable<CheckAdvice> {

	private static final long serialVersionUID = 6674013991838914395L;
	private String adviceId;

	private String columnId;

	private String columnName;

	private String title;

	private String profile;

	private String contentFrom;

	private String oriLink;

	private String isReco;

	private String isRecoName;
	
	private String newsDate;

	private String isWork;

	private String isWorkName;

	private String skipMode;
	
	private String useLink;
	
	private String commentTotal;
	
	private String viewTotal;
	private String pointTotal;
	private String messageStatus;
	
	private String attachmentId;
	
	private String itemCode;
	private String itemName;
	private String href;
	private String companyId;
	private String companyName;
	
	private String blockCode;
	
	private String duration;
	private String createTime;
	public String getAdviceId() {
		return adviceId;
	}

	public void setAdviceId(String adviceId) {
		this.adviceId = adviceId;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getProfile() {
		return profile;
	}

	public void setProfile(String profile) {
		this.profile = profile;
	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

	public String getContentFrom() {
		return contentFrom;
	}

	public void setContentFrom(String contentFrom) {
		this.contentFrom = contentFrom;
	}

	public String getOriLink() {
		return oriLink;
	}

	public void setOriLink(String oriLink) {
		this.oriLink = oriLink;
	}

	public String getIsReco() {
		return isReco;
	}

	public void setIsReco(String isReco) {
		this.isReco = isReco;
	}

	public String getIsWork() {
		return isWork;
	}

	public void setIsWork(String isWork) {
		this.isWork = isWork;
	}

	public String getColumnId() {
		return columnId;
	}

	public void setColumnId(String columnId) {
		this.columnId = columnId;
	}

	public String getSkipMode() {
		return skipMode;
	}

	public void setSkipMode(String skipMode) {
		this.skipMode = skipMode;
	}

	public String getColumnName() {
		return columnName;
	}

	public void setColumnName(String columnName) {
		this.columnName = columnName;
	}

	public String getIsRecoName() {
		isRecoName = "";
		String dictItemName = DictContext.getInstance().getDict("whether", isReco);
		if (StringUtil.isNotEmpty(dictItemName))
			isRecoName = dictItemName;
		return isRecoName;
	}

	public void setIsRecoName(String isRecoName) {
		this.isRecoName = isRecoName;
	}

	public String getIsWorkName() {

		isWorkName = "";
		String dictItemName = DictContext.getInstance().getDict("whether", isWork);
		if (StringUtil.isNotEmpty(dictItemName))
			isWorkName = dictItemName;
		return isWorkName;
	}

	public void setIsWorkName(String isWorkName) {
		this.isWorkName = isWorkName;
	}

	public String getUseLink() {
		return useLink;
	}

	public void setUseLink(String useLink) {
		this.useLink = useLink;
	}

	public String getCommentTotal() {
		return commentTotal;
	}

	public void setCommentTotal(String commentTotal) {
		this.commentTotal = commentTotal;
	}

	public String getViewTotal() {
		return viewTotal;
	}

	public void setViewTotal(String viewTotal) {
		this.viewTotal = viewTotal;
	}

	public String getPointTotal() {
		return pointTotal;
	}

	public void setPointTotal(String pointTotal) {
		this.pointTotal = pointTotal;
	}

	public String getMessageStatus() {
		return messageStatus;
	}

	public void setMessageStatus(String messageStatus) {
		this.messageStatus = messageStatus;
	}

	public String getAttachmentId() {
		return attachmentId;
	}

	public void setAttachmentId(String attachmentId) {
		this.attachmentId = attachmentId;
	}

	public String getItemCode() {
		return itemCode;
	}

	public void setItemCode(String itemCode) {
		this.itemCode = itemCode;
	}

	public String getItemName() {
		return itemName;
	}

	public void setItemName(String itemName) {
		this.itemName = itemName;
	}
    
	public String getNewsDate() {
		return newsDate;
	}

	public void setNewsDate(String newsDate) {
		this.newsDate = newsDate;
	}

	public String getHref() {
		return href;
	}

	public String getCompanyId() {
		return companyId;
	}

	public void setCompanyId(String companyId) {
		this.companyId = companyId;
	}

	public String getCompanyName() {
		return companyName;
	}

	public void setCompanyName(String companyName) {
		this.companyName = companyName;
	}

	public String getBlockCode() {
		return blockCode;
	}

	public void setBlockCode(String blockCode) {
		this.blockCode = blockCode;
	}

	public String getDuration() {
		return duration;
	}

	public void setDuration(String duration) {
		this.duration = duration;
	}

	public String getCreateTime() {
		return createTime;
	}

	public void setCreateTime(String createTime) {
		this.createTime = createTime;
	}

	@Override
	public int compareTo(CheckAdvice ca) {
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		try {
			 return df.parse(ca.getNewsDate()).compareTo(df.parse(this.getNewsDate()));
		} catch (ParseException e) {
			return 0;
		}
	}
	
} 		

	public List<CheckAdvice> getHomePageData(String blockCode,String companyId) {
		List<CheckAdvice> dataList = checkAdviceMapper.getHomePageData(blockCode,companyId);
		Collections.sort(dataList);
		return dataList;
	}