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 + "\n"); 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 + "\n"); 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("[ \n\t\r.,;:!]");//注意\n和[之间有个空格
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值是字符串，它就按字符比大小排序，如果是数字，它就按数字比大小排序。
07java进阶——集合框架3（Map）的更多相关文章
- 07java进阶——集合框架（set）
1.list接口中常用的特有方法 package cn.jxufe.java.chapter7; import java.util.ArrayList; import java.util.List; ...
- Java集合框架之map
Java集合框架之map. Map的主要实现类有HashMap,LinkedHashMap,TreeMap,等等.具体可参阅API文档. 其中HashMap是无序排序. LinkedHashMap是自 ...
- 第19章 集合框架(3)-Map接口
第19章 集合框架(3)-Map接口 1.Map接口概述 Map是一种映射关系,那么什么是映射关系呢? 映射的数学解释 设A,B是两个非空集合,如果存在一个法则,使得对A中的每一个元素a,按法则f,在 ...
- Java集合框架之Map接口浅析
Java集合框架之Map接口浅析 一.Map接口综述: 1.1java.util.Map<k, v>简介 位于java.util包下的Map接口,是Java集合框架的重要成员,它是和Col ...
- 【JAVA集合框架之Map】
一.概述.1.Map是一种接口,在JAVA集合框架中是以一种非常重要的集合.2.Map一次添加一对元素,所以又称为“双列集合”(Collection一次添加一个元素,所以又称为“单列集合”)3.Map ...
- 十七、Java基础---------集合框架之Map
前两篇文章中介绍了Collection框架,今天来介绍一下Map集合,并用综合事例来演示. Map<K,V> Map<K,V>:Map存储的是键值对形式的元素,它的每一个元素, ...
- Java集合框架中Map接口的使用
在我们常用的Java集合框架接口中,除了前面说过的Collection接口以及他的根接口List接口和Set接口的使用,Map接口也是一个经常使用的接口,和Collection接口不同,Map接口并不 ...
- [黑马程序员] 集合框架2——Map系 & 集合工具类(Collections、Arrays)
---------------------- ASP.Net+Android+IO开发..Net培训.期待与您交流! ---------------------- 0. 集合框架按其所实现的接口, 大 ...
- 集合框架以及Map(一)
集合又称容器,编程思想中对其的定义为持有对象 我们在使用集合或者数组时得到最多的异常就是数组下表越界异常 Java.lang.ArrayIndexOutOfBoundsException这篇文章我们不 ...
随机推荐
- JDBC API访问数据库的基本步骤。
JDBC本质:官方定义了一套操作所有关系型数据库的规则(接口),各个数据库厂商实现这个接口,提供数据库驱动jar包. 我们可以使用这套接口(JDBC)编程,真正执行的代码是驱动jar包中的实现类. 任 ...
- Fatal error: Class 'think\db' not found
在model层写了一个查询语句结果报错 Fatal error: Class 'think\db' not found $list= Db::table('m_my_reserve_assess' ...
- 获取免费的https证书
可以通过网站获取免费的https证书 首先到https://freessl.org注册一个账号 然后就可以开始创建免费证书了 获取的证书里面通常只有pem后缀文件 nodejs使用的时候需要crt文件 ...
- jvm内存模型学习心得
昨天面试了两家,备受打击,问的多的就是jvm内存,然额真的是一头雾水.工作中用到的真是少之又少,面试还得问道, 今天恶补了下,在此作以下总结: jvm分为5部分 1.程序计数器 jvm支持多线程运行, ...
- mysql执行拉链表操作
拉链表需求: 1.数据量比较大 2.变化的比例和频率比较小,例如客户的住址信息,联系方式等,比如有1千万的用户数据,每天全量存储会存储很多不变的信息,对存储也是浪费,因此可以使用拉链表的算法来节省存储 ...
- App测试工具选择
一.功能测试自动化 a) 轻量接口自动化测试: jmeter, b) APP UI层面的自动化 android:UI Automator Viewer,Android Junit,Instrument ...
- 系统分析与设计HW8
描述软件架构与框架之间的区别与联系 软件架构是有关软件整体结构与组件的抽象描述,用于指导大型软件系统各个方面的设计.架构模式(style)是特定领域常见问题的解决方案. 框架是特定语言和技术的架构应用 ...
- Gradle之Gradle 源码分析（四）
Gradle 的启动 constructTaskGraph runTasks finishBuild gradle 脚本如何编译和执 插件调用流程 一.Gradle 的启动 1.1 整体实现图 1.2 ...
- yield(),sleep()以及wait()的区别
往往混淆了这三个函数的使用. 从操作系统的角度讲,os会维护一个ready queue(就绪的线程队列).并且在某一时刻cpu只为ready queue中位于队列头部的线程服务. 但是当前正在被服务的 ...
- ionic3构建过程中遇到的找不到AndroidManifest.xml的问题
问题如下: Failed to install 'ionic-plugin-keyboard': Error: ENOENT: no such file or directory, open '/Us ...