07java进阶——集合框架3（Map）

1.映射表（Map）

1.1基本概念

1.2Map中常用的方法

package cn.jxufe.java.chapter7;

import java.util.HashMap;
import java.util.Map;

public class Test09Map {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        function();
        System.out.println();
        function_1();
        System.out.println();
        function_2();
    }

    /*
     *  移除集合中的键值对,返回被移除之前的值
     *  V remove(K)
     */
    public static void function_2() {
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        System.out.println(map);

        String value = map.remove(3);
        System.out.println(value);
        System.out.println(map);
        System.out.println(map.size());
        System.out.println(map.values());
        System.out.println(map.keySet());
        System.out.println(map.containsKey(2));
        System.out.println(map.containsValue("b"));
        System.out.println(map.entrySet());
    }

    /*
     * 通过键对象,获取值对象
     * V get(K)
     * 如果集合中没有这个键,返回null
     */
    public static void function_1() {
        // 创建集合对象,作为键的对象整数,值的对象存储字符串
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        System.out.println(map);

        String value = map.get(4);
        System.out.println(value);

        String value2 = map.get(3);
        System.out.println(value2);
    }

    /*
     *  将键值对存储到集合中
     *  V put(K,V) K 作为键的对象, V作为值的对象
     *  存储的是重复的键,将原有的值,覆盖
     *  返回值一般情况下返回null,
     *  存储重复键的时候,返回被覆盖之前的值
     */
    public static void function() {
        // 创建集合对象,HashMap,存储对象,键是字符串,值是整数
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("a", 1);

        map.put("b", 2);

        map.put("c", 3);

        System.out.println(map);
    }

}

1.3map的遍历

方法1：

package cn.jxufe.java.chapter7;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
 *  Map集合的遍历
 *    利用键获取值
 *    Map接口中定义方法keySet
 *    所有的键,存储到Set集合
 */
public class Test10Map {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("a", 11);
        map.put("b", 12);
        map.put("c", 13);
        map.put("d", 14);
        map.put("ab", 14);

        // 1. 调用map集合的方法keySet,所有的键存储到Set集合中
        Set<String> set = map.keySet();
        System.out.println(set);
        // 2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            // it.next返回是Set集合元素,也就是Map中的键
            // 3. 调用map集合方法get,通过键获取到值
            String key = it.next();
            Integer value = map.get(key);
            System.out.println(key + "...." + value);
        }
        System.out.println("=======================");
        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println(key + "...." + value);
        }

    }

}

方法2：

在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

• entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回。

package cn.jxufe.java.chapter7;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
 *  Map集合获取方式
 *  entrySet方法,键值对映射关系(结婚证)获取
 *  实现步骤:
 *    1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
 *        Set<Entry <K,V> >
 *    2. 迭代Set集合
 *    3. 获取出的Set集合的元素,是映射关系对象
 *    4. 通过映射关系对象方法 getKet, getValue获取键值对
 *    
 *    创建内部类对象 外部类.内部类 = new 
 */
public class Test11Map {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "abc");
        map.put(2, "bcd");
        map.put(3, "cde");
        // 1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
        Set<Map.Entry<Integer, String>> set = map.entrySet();
        // 2. 迭代Set集合
        Iterator<Map.Entry<Integer, String>> it = set.iterator();
        while (it.hasNext()) {
            // 3. 获取出的Set集合的元素,是映射关系对象
            // it.next 获取的是什么对象,也是Map.Entry对象
            Map.Entry<Integer, String> entry = it.next();
            // 4. 通过映射关系对象方法 getKet, getValue获取键值对
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "...." + value);
        }

        System.out.println("=========================");
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "..." + entry.getValue());
        }
    }

}

1.4HashMap存储自定义类型键值

package cn.jxufe.java.chapter7;

import java.util.HashMap;
import java.util.Map;

/*
 *  使用HashMap集合,存储自定义的对象
 *  自定义对象,作为键,出现,作为值出现
 */
public class Test12HashMap {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * HashMap 存储自定义对象Person,作为键出现
         * 键的对象,是Person类型,值是字符串
         * 保证键的唯一性,存储到键的对象,重写hashCode equals
         */
        HashMap<Person, String> map = new HashMap<Person, String>();
        map.put(new Person("a", 20), "里约热内卢");
        map.put(new Person("b", 18), "索马里");
        map.put(new Person("b", 18), "索马里");
        map.put(new Person("c", 19), "百慕大");
        for (Person key : map.keySet()) {
            String value = map.get(key);
            System.out.println(key + "..." + value);
        }
        System.out.println("===================");
        for (Map.Entry<Person, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "..." + entry.getValue());
        }
    }
}

1.5LinkedHashMap

1.6TreeMap

package cn.jxufe.java.chapter7;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class Test13TreeMap {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("smith", 30);
        hashMap.put("pull", 31);
        hashMap.put("kobe", 29);
        hashMap.put("weide", 29);
        System.out.println("Display entries in hashMap");
        System.out.println(hashMap + "
");
        
        Map<String,Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("smith", 30);
        linkedHashMap.put("pull", 31);
        linkedHashMap.put("kobe", 29);
        linkedHashMap.put("weide", 29);
        System.out.println("Display entries in linkedHashMap");
        System.out.println(linkedHashMap + "
");
        
        Map<String,Integer> treeMap = new TreeMap<>();
        treeMap.put("smith", 30);
        treeMap.put("pull", 31);
        treeMap.put("kobe", 29);
        treeMap.put("weide", 29);
        System.out.println("Display entries in treeMap");
        System.out.println(treeMap);  
    }
}

1.7HashTable

package cn.jxufe.java.chapter7;

import java.util.Hashtable;
import java.util.Map;

/*
 *  Map接口实现类 Hashtable
 *  底层数据结果哈希表,特点和HashMap是一样的
 *  Hashtable 线程安全集合,运行速度慢
 *  HashMap 线程不安全的集合,运行速度快
 *  
 *  Hashtable命运和Vector是一样的,从JDK1.2开始,被更先进的HashMap取代
 *  
 *  HashMap 允许存储null值,null键
 *  Hashtable 不允许存储null值,null键
 *  
 *  Hashtable他的孩子,子类 Properties 依然活跃在开发舞台
 */
public class Test15HashTable {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map<String, String> map = new Hashtable<String, String>();
        map.put(null, null);
        System.out.println(map);
    }

}

2.示例学习：单词的出现次数

package cn.jxufe.java.chapter7;

import java.util.Arrays;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Test14CountWords {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String text = "Good morning. have a good class." + "have a good visit.have fun!";
        Map<String, Integer> map = new TreeMap<>();
        String[] wordStrings = text.split("[ 
	
.,;:!]");//注意
和[之间有个空格
        System.out.println(Arrays.toString(wordStrings));
        for (int i = 0; i < wordStrings.length; i++) {
            String key = wordStrings[i].toLowerCase();
            if(key.length()>0) {
                if(!map.containsKey(key)) {
                    map.put(key, 1);
                }
                else {
                    int value = map.get(key);
                    value++;
                    map.put(key, value);
                }
            }
        }
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        
        for(Map.Entry<String, Integer> entry:entrySet)
            System.out.println(entry.getKey()+" : " + entry.getValue());
    }

}

3.静态导入

package cn.jxufe.java.chapter7;

import static java.lang.System.out;
import static java.util.Arrays.sort;

import java.util.Arrays;

/*
 * JDK1.5新特性,静态导入
 * 减少开发的代码量
 * 标准的写法,导入包的时候才能使用
 * 
 * import static java.lang.System.out;最末尾,必须是一个静态成员
 */
public class Test16StaticImport {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        out.println("hello");

        int[] arr = { 1, 4, 2 };
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

}

4.可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：

修饰符 返回值类型 方法名(参数类型... 形参名){  }

其实这个书写完全等价与

修饰符 返回值类型 方法名(参数类型[] 形参名){  }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

jdk1.5以后。出现了简化操作。... 用在参数上，称之为可变参数。

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

package cn.jxufe.java.chapter7;

/*
 *  JDK1.5新的特性,方法的可变参数
 *  前提: 方法参数数据类型确定,参数的个数任意
 *  可变参数语法: 数据类型...变量名
 *  可变参数,本质就是一个数组
 */
public class Test17VarArgument {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 调用一个带有可变参数的方法,传递参数,可以任意
        // getSum();
        int sum = getSum(5, 34, 3, 56, 7, 8, 0);
        System.out.println(sum);
        int sum2 = getSum(5, 34, 3);
        System.out.println(sum2);

    }

    /*
     * 可变参数的注意事项
     * 1. 一个方法中,可变参数只能有一个
     * 2. 可变参数,必须写在参数列表的最后一位
     */

    /*
     * 定义方法,计算10个整数和
     * 方法的可变参数实现
     */
    public static int getSum(int... a) {
        int sum = 0;
        for (int i : a) {
            sum = sum + i;
        }
        return sum;
    }

}

5.Collections集合工具类

package cn.jxufe.java.chapter7;

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

public class Test18Collections {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        function();
        function_1();
        function_2();
    }

    /*
     * Collections.shuffle方法
     * 对List集合中的元素,进行随机排列
     */
    public static void function_2() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(5);
        list.add(9);
        list.add(11);
        list.add(8);
        list.add(10);
        list.add(15);
        list.add(20);
        System.out.println(list);

        // 调用工具类方法shuffle对集合随机排列
        Collections.shuffle(list);
        System.out.println(list);
    }

    /*
     * Collections.binarySearch静态方法
     * 对List集合进行二分搜索,方法参数,传递List集合,传递被查找的元素
     */
    public static void function_1() {
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(5);
        list.add(8);
        list.add(10);
        list.add(15);
        list.add(20);
        // 调用工具类静态方法binarySearch
        int index = Collections.binarySearch(list, 16);
        int index2 = Collections.binarySearch(list, 15);
        System.out.println(index);
        System.out.println(index2);
    }

    /*
     *  Collections.sort静态方法
     *  对于List集合,进行升序排列
     */
    public static void function() {
        // 创建List集合
        List<String> list = new ArrayList<String>();
        list.add("ewrew");
        list.add("qwesd");
        list.add("Qwesd");
        list.add("bv");
        list.add("wer");
        System.out.println(list);
        // 调用集合工具类的方法sort
        Collections.sort(list);
        System.out.println(list);
    }
}

6.集合的嵌套

集合嵌套并不是一个新的知识点，仅仅是集合内容又是集合，如Collection集合嵌套、Collection集合与Map集合相互嵌套、Map集合嵌套。

•   ArrayList嵌套 ArrayList

ArrayList< ArrayList<String> >
Collection< ArrayList<Integer> >

• Map嵌套 ArrayList

HashMap<String, ArrayList<Person>>
ArrayList< HashMap<String, String>>

• Map集合嵌套

HashMap<String, HashMap<String,String>>
HashMap<String, HashMap<Person,String>>

keySet遍历

package cn.jxufe.java.chapter7;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
 *  Map集合的嵌套,Map中存储的还是Map集合
 *  要求:
 *    传智播客  
 *      Java基础班
 *        001  张三
 *        002  李四
 *      
 *      Java就业班
 *        001  王五
 *        002  赵六
 *  对以上数据进行对象的存储
 *   001 张三  键值对
 *   Java基础班: 存储学号和姓名的键值对
 *   Java就业班:
 *   传智播客: 存储的是班级
 *   
 *   基础班Map   <学号,姓名>
 *   传智播客Map  <班级名字, 基础班Map>
 */
public class Test19MapMap {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 定义基础班集合
        HashMap<String, String> javase = new HashMap<String, String>();
        // 定义就业班集合
        HashMap<String, String> javaee = new HashMap<String, String>();
        // 向班级集合中,存储学生信息
        javase.put("001", "张三");
        javase.put("002", "李四");

        javaee.put("001", "王五");
        javaee.put("002", "赵六");
        // 定义传智播客集合容器,键是班级名字,值是两个班级容器
        HashMap<String, HashMap<String, String>> czbk = new HashMap<String, HashMap<String, String>>();
        czbk.put("基础班", javase);
        czbk.put("就业班", javaee);
        System.out.println("第一种方法++++++++++++++++++++++++++++++++++++++++");
        keySet(czbk);
        System.out.println("第二中方法++++++++++++++++++++++++++++++++++++++++");
        entrySet(czbk);

    }

    public static void entrySet(HashMap<String, HashMap<String, String>> czbk) {
        // 调用czbk集合方法entrySet方法,将czbk集合的键值对关系对象,存储到Set集合
        Set<Map.Entry<String, HashMap<String, String>>> classNameSet = czbk.entrySet();
        // 迭代器迭代Set集合
        Iterator<Map.Entry<String, HashMap<String, String>>> classNameIt = classNameSet.iterator();
        while (classNameIt.hasNext()) {
            // classNameIt.next方法,取出的是czbk集合的键值对关系对象
            Map.Entry<String, HashMap<String, String>> classNameEntry = classNameIt.next();
            // classNameEntry方法 getKey,getValue
            String classNameKey = classNameEntry.getKey();
            // 获取值,值是一个Map集合
            HashMap<String, String> classMap = classNameEntry.getValue();
            // 调用班级集合classMap方法entrySet,键值对关系对象存储Set集合
            Set<Map.Entry<String, String>> studentSet = classMap.entrySet();
            // 迭代Set集合
            Iterator<Map.Entry<String, String>> studentIt = studentSet.iterator();
            while (studentIt.hasNext()) {
                // studentIt方法next获取出的是班级集合的键值对关系对象
                Map.Entry<String, String> studentEntry = studentIt.next();
                // studentEntry方法 getKey getValue
                String numKey = studentEntry.getKey();
                String nameValue = studentEntry.getValue();
                System.out.println(classNameKey + ".." + numKey + ".." + nameValue);
            }
        }
        System.out.println("==================================");

        for (Map.Entry<String, HashMap<String, String>> me : czbk.entrySet()) {
            String classNameKey = me.getKey();
            HashMap<String, String> numNameMapValue = me.getValue();
            for (Map.Entry<String, String> nameMapEntry : numNameMapValue.entrySet()) {
                String numKey = nameMapEntry.getKey();
                String nameValue = nameMapEntry.getValue();
                System.out.println(classNameKey + ".." + numKey + ".." + nameValue);
            }
        }
    }

    public static void keySet(HashMap<String, HashMap<String, String>> czbk) {
        // 调用czbk集合方法keySet将键存储到Set集合
        Set<String> classNameSet = czbk.keySet();
        // 迭代Set集合
        Iterator<String> classNameIt = classNameSet.iterator();
        while (classNameIt.hasNext()) {
            // classNameIt.next获取出来的是Set集合元素,czbk集合的键
            String classNameKey = classNameIt.next();
            // czbk集合的方法get获取值,值是一个HashMap集合
            HashMap<String, String> classMap = czbk.get(classNameKey);
            // 调用classMap集合方法keySet,键存储到Set集合
            Set<String> studentNum = classMap.keySet();
            Iterator<String> studentIt = studentNum.iterator();

            while (studentIt.hasNext()) {
                // studentIt.next获取出来的是classMap的键,学号
                String numKey = studentIt.next();
                // 调用classMap集合中的get方法获取值
                String nameValue = classMap.get(numKey);
                System.out.println(classNameKey + ".." + numKey + ".." + nameValue);
                
            }
        }

        System.out.println("==================================");
        for (String className : czbk.keySet()) {
            HashMap<String, String> hashMap = czbk.get(className);
            for (String numKey : hashMap.keySet()) {
                String nameValue = hashMap.get(numKey);
                System.out.println(className + ".." + numKey + ".." + nameValue);
            }
        }
    }

}

7.Map按键排序

jdk内置的java.util包下的TreeMap<K,V>既可满足此类需求，向其构造方法 TreeMap(Comparator<? super K> comparator)  传入我们自定义的比较器即可实现按键排序。

方法1：

package cn.jxufe.java.chapter7;

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

public class Test20SortByKey {

    public static void main(String[] args) {
        Map<String, String> map = new TreeMap<String, String>();

        map.put("KFC", "kfc");
        map.put("WNBA", "wnba");
        map.put("NBA", "nba");
        map.put("CBA", "cba");

        Map<String, String> resultMap = sortMapByKey(map); // 按Key进行排序

        for (Map.Entry<String, String> entry : resultMap.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }

    /**
     * 使用 Map按key进行排序
     * 
     * @param map
     * @return
     */
    public static Map<String, String> sortMapByKey(Map<String, String> map) {
        if (map == null || map.isEmpty()) {
            return null;
        }

        Map<String, String> sortMap = new TreeMap<String, String>(new MapKeyComparator());

        sortMap.putAll(map);

        return sortMap;
    }

}

//比较器类
class MapKeyComparator implements Comparator<String> {

    @Override
    public int compare(String str1, String str2) {

        return str2.compareTo(str1);// 按字母降序
//        return str1.compareTo(str2);// 按字母升序
    }
}

方法2：

package cn.jxufe.java.chapter7;

import java.util.Comparator;
import java.util.TreeMap;

public class Test21SortByKey {

    private static void sortByKeyDesc() {
        TreeMap<String, String> tm = new TreeMap<String, String>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        tm.put("a", "ddd");
        tm.put("b", "ccc");
        tm.put("c", "bbb");
        tm.put("d", "aaa");
        for (String key : tm.keySet()) {
            System.out.println("key :" + key + ",对应的value：" + tm.get(key));
        }
    }

    public static void main(String[] args) {
        sortByKeyDesc();
    }
}

8.Map按值排序

方法1：

按值排序就相对麻烦些了，貌似没有直接可用的数据结构能处理类似需求，需要我们自己转换一下。
Map本身按值排序是很有意义的，很多场合下都会遇到类似需求，可以认为其值是定义的某种规则或者权重。

原理：将待排序Map中的所有元素置于一个列表中，接着使用Collections的一个静态方法 sort(List<T> list, Comparator<? super T> c) 
来排序列表，同样是用比较器定义比较规则。排序后的列表中的元素再依次装入Map，为了肯定的保证Map中元素与排序后的List中的元素的顺序一致，使用了LinkedHashMap数据类型。

package cn.jxufe.java.chapter7;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
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;

public class Test22SortByValue {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Map<String, String> map = new TreeMap<String, String>();

        map.put("KFC", "kfc");
        map.put("WNBA", "wnba");
        map.put("NBA", "nba");
        map.put("CBA", "cba");

        Map<String, String> resultMap = sortMapByValue(map); // 按Value进行排序

        for (Map.Entry<String, String> entry : resultMap.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }

    /**
     * 使用 Map按value进行排序
     * 
     * @param map
     * @return
     */
    public static Map<String, String> sortMapByValue(Map<String, String> oriMap) {
        if (oriMap == null || oriMap.isEmpty()) {
            return null;
        }
        Map<String, String> sortedMap = new LinkedHashMap<String, String>();
        List<Map.Entry<String, String>> entryList = new ArrayList<Map.Entry<String, String>>(oriMap.entrySet());
        Collections.sort(entryList, new MapValueComparator());

        Iterator<Map.Entry<String, String>> iter = entryList.iterator();
        Map.Entry<String, String> tmpEntry = null;
        while (iter.hasNext()) {
            tmpEntry = iter.next();
            sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue());
        }
        return sortedMap;
    }
}

class MapValueComparator implements Comparator<Map.Entry<String, String>> {

    @Override
    public int compare(Entry<String, String> me1, Entry<String, String> me2) {

        return me1.getValue().compareTo(me2.getValue());
    }
}

方法2：

上面的例子是根据TreeMap的可以值来进行排序的，但是有时我们需要根据TreeMap的value来进行排序。对于value排序我们就需要借助于Collection的sort（List<T> list,Comparator<?super T>c）方法，该方法根据指定比较器产生的顺序对指定列表进行排序。但是有一个前提，那就是所有的元素都必须能够根据所提供的比较器来进行比较，如下：

package cn.jxufe.java.chapter7;

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

public class Test23SortByValue {
    
    private static void sortByValueDesc() {
        Map<String, String> tm = new TreeMap<String, String>();
        tm.put("a", "ddd");
        tm.put("b", "ccc");
        tm.put("c", "bbb");
        tm.put("d", "aaa");
        // 这里将map.entrySet()转换成list
        List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>(tm.entrySet());
        // 然后通过比较器来实现排序
        Collections.sort(list, new Comparator<Map.Entry<String, String>>() {
            // 降序排序
            @Override
            public int compare(Entry<String, String> o1, Entry<String, String> o2) {
                return o2.getValue().compareTo(o1.getValue());
            }
        });

        for (Map.Entry<String, String> mapping : list) {
            System.out.println(mapping.getKey() + ":" + mapping.getValue());
        }
    }

    public static void main(String[] args) {
        sortByValueDesc();
    }

}

方法3：

package cn.jxufe.java.chapter7;

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

public class Test24SortByVBalue {
    // Map的value值降序排序
    public static <K, V extends Comparable<? super V>> Map<K, V> sortDescend(Map<K, V> map) {
        List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                int compare = (o1.getValue()).compareTo(o2.getValue());
                return -compare;
            }
        });

        Map<K, V> returnMap = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            returnMap.put(entry.getKey(), entry.getValue());
        }
        return returnMap;
    }

    // Map的value值升序排序
    public static <K, V extends Comparable<? super V>> Map<K, V> sortAscend(Map<K, V> map) {
        List<Map.Entry<K, V>> list = new ArrayList<Map.Entry<K, V>>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                int compare = (o1.getValue()).compareTo(o2.getValue());
                return compare;
            }
        });

        Map<K, V> returnMap = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            returnMap.put(entry.getKey(), entry.getValue());
        }
        return returnMap;
    }

    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("设计与制作", "52");
        map.put("创作表现", "15");
        map.put("基本元素", "482");
        map.put("艺术作品", "551");
        map.put("理解与概念", "56");

        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++字符串+++++++++++++++++++++++++++++++++++++++++++");
        System.out.println("排序前------------->" + map);

        map = sortDescend(map);// 降序排序
        System.out.println("降序后------------->" + map);

        map = sortAscend(map);// 升序排序
        System.out.println("升序后------------->" + map);
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++数字+++++++++++++++++++++++++++++++++++++++++++");
        Map<String, Integer> map2 = new HashMap<>();
        map2.put("设计与制作", 52);
        map2.put("创作表现", 15);
        map2.put("基本元素", 482);
        map2.put("艺术作品", 551);
        map2.put("理解与概念", 56);

        System.out.println("排序前------------->" + map2);

        map2 = sortDescend(map2);// 降序排序
        System.out.println("降序后------------->" + map2);

        map2 = sortAscend(map2);// 升序排序
        System.out.println("升序后------------->" + map2);

    }

}

总结：如果你的value值是字符串，它就按字符比大小排序，如果是数字，它就按数字比大小排序。