Map按照条件排序输出

需求：

/**
* Map进行多条件排序输出
* 水果具有好吃不好吃难吃属性。
* 入口Map
* 首先按照好吃不好吃难吃排序
* 然后按照水果的标志Id排序
* 出口Map
*
* 2016年8月14日
*/

 

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;

/**
 * Map进行多条件排序输出
 * 水果具有好吃不好吃难吃属性。
 * 入口Map
 * 首先按照好吃不好吃难吃排序
 * 然后按照水果的标志Id排序
 * 出口Map
 * 
 * 2016年8月14日
 */
public class MainSort {

    /**
     * 主方法
     * @param args
     */
    public static void main(String[] args) {
        // 获取Map
        Map<String,Fruit> fruitMap = getFruitMap();
        // 打印未排序的Map
        show(fruitMap);
        System.out.println("-----------before-----------");
        // 打印排序完了的Map
        show(MainSort.sortMapByValue(fruitMap));
        System.out.println("-----------after------------");
    }

    /**
     * 循环打印Map
     */
    private static void show(Map<String, Fruit> fruitMap) {
        // 循环Map
        for (Map.Entry<String, Fruit> fruitOneMap : fruitMap.entrySet()) {
            Fruit fruit = fruitOneMap.getValue();
            System.out.println(fruit.getFruitName() + " " + fruit.getFruitTaste()+ " " + fruit.getId() );
        }
    }
    
    /**
     * 准备参数
     * @return
     */
    private static Map<String, Fruit> getFruitMap() {
        Map<String,Fruit> fruitMap = new TreeMap<>();

        // 创建对象
        Fruit b = new Fruit("苹果"  , FruitTaste.HAOCHI, "b");
        Fruit a = new Fruit("梨子"  , FruitTaste.YIBAN , "a");
        Fruit c = new Fruit("香蕉"  , FruitTaste.HAOCHI, "c");
        Fruit d = new Fruit("桃子"  , FruitTaste.HAOCHI, "d");
        Fruit e = new Fruit("橘子"  , FruitTaste.NANGCHI , "e");
        Fruit f = new Fruit("杨梅"  , FruitTaste.YIBAN , "f");
        Fruit g = new Fruit("黑李"  , FruitTaste.NANGCHI , "g");
        Fruit h = new Fruit("火龙果", FruitTaste.HAOCHI, "h");
        Fruit i = new Fruit("西瓜"  , FruitTaste.YIBAN, "i");

        // 乱序key值
        fruitMap.put("xniem", b);
        fruitMap.put("asdf", i);
        fruitMap.put("akgjjd", c);
        fruitMap.put("uiooo", f);
        fruitMap.put("qw84", a);
        fruitMap.put("5845uasdf'", d);
        fruitMap.put("48aisdf", e);
        fruitMap.put("458kljsf", g);
        fruitMap.put("4jalsdfj", h);

        return fruitMap;
    }
    
    /**
     * 由于List能够直接使用Collections进行排序
     * 但是Map不行。
     * 这边所做的操作就是先将Map--》List
     * 然后对List进行排序
     * 然后在讲List--》转换成Map
     * @param map
     * @return
     */
    public static Map<String, Fruit> sortMapByValue(Map<String, Fruit> fruitMap) {
        if (fruitMap == null || fruitMap.isEmpty()) {
            return null;
        }
        // LinkedhashMap是有序的、或者TreeMap都是有序的
        Map<String, Fruit> sortedMap = new LinkedHashMap<String, Fruit>();
        List<Map.Entry<String, Fruit>> entryList = new ArrayList<Map.Entry<String, Fruit>>(fruitMap.entrySet());
        Collections.sort(entryList, new MapValueComparator());
        Iterator<Map.Entry<String, Fruit>> iter = entryList.iterator();
        Map.Entry<String, Fruit> tmpEntry = null;
        while (iter.hasNext()) {
            tmpEntry = iter.next();
            sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue());
        }
        return sortedMap;
    }
}



/**
 * 比较器规则类
 * 传入对应的Map进行比较
 * @author elcapitan
 */
class MapValueComparator implements Comparator<Map.Entry<String, Fruit>> {

    @Override
    public int compare(Entry<String, Fruit> o1, Entry<String, Fruit> o2) {
    
        // 获取比较的两个对象
        Fruit fruit1 = o1.getValue();
        Fruit fruit2 = o2.getValue();
        
        // 将好吃，难吃映射成具有比较关系的字符1、2、3
        Map<String,Integer> tasteLev = new HashMap<>();
        tasteLev.put(FruitTaste.HAOCHI, 1);
        tasteLev.put(FruitTaste.YIBAN, 2);
        tasteLev.put(FruitTaste.NANGCHI, 3);        
        
        int cr = 0;
        // 判断好吃不好吃
        int a = tasteLev.get(fruit2.getFruitTaste())-tasteLev.get(fruit1.getFruitTaste());
        if (a!=0) {
            cr = (a>0) ? -1 : 2;
        } else {
            // 按照对应的Id排序
            a = fruit2.getId().compareTo(fruit1.getId());
            if (a!=0) {
                cr = (a>0)? -2 : 1;
            }
        }
        /* 注意上面对一个返回值对应的就是形成比较层次
         * 上层
         * --> 2
         * --> -1
         *     下层
         *    --> 1
         *      --> -2
         */
        return cr;
    }
}

/**
 * 水果实体类
 * 包含水果名称、水果好吃程度、水果标志
 * @author elcapitan
 */
class Fruit {
    private String fruitName;
    private String fruitTaste;
    private String id;
    public String getFruitName() {
        return fruitName;
    }
    public void setFruitName(String fruitName) {
        this.fruitName = fruitName;
    }
    public String getFruitTaste() {
        return fruitTaste;
    }
    public void setFruitTaste(String fruitTaste) {
        this.fruitTaste = fruitTaste;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public Fruit(String fruitName, String fruitTaste, String id) {
        super();
        this.fruitName = fruitName;
        this.fruitTaste = fruitTaste;
        this.id = id;
    }
}

/**
 * 水果好吃程度常量类
 * 包括好吃、一般、不好吃
 * 可以继续添加
 * @author elcapitan
 */
class FruitTaste {
    public static final String HAOCHI = "好吃";
    public static final String NANGCHI = "难吃";
    public static final String YIBAN  = "一般";
}

实现结果：

希望帮你不加班~😯😯😯