一.Map集合简介
Java中的Map是一种键值对的集合类型，它允许将键映射到值。在Map中，键的值是唯一的，而值则可重复。Map定义了一些方法，可以通过键来操作值。
二.Map集合的特点和遍历方式
1.特点和方法：
增删改查
获取获取Map中键值对的数量：size()
containsKey(key)方法判断Map中是否包含某个键
containsValue(value)方法判断Map中是否包含某个值
2.遍历方式
a.通过keyset转为set集合进行遍历
b.通过entryset转换为set集合遍历
代码展示
package com.ctb.map; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; /** * map集合的特点：增删改查 * * map集合的遍历：1.转ketset遍历 2.entryset遍历 * * @author biao * */ public class Demo1 { public static void main(String[] args) { Map<Object, String> map=new HashMap<Object, String>(); //增加 map.put("name", "东哥"); map.put("hobby", "掉找天"); map.put("age", "芜湖"); map.put("address", "奥迪噶多"); //删除-以键删除整体 map.remove("hobby"); //修改--即覆盖 map.put("age", "34"); //查询 System.out.println(map); //containsKey(key)方法判断Map中是否包含某个键 boolean hasKey = map.containsKey("name"); //containsValue(value)方法判断Map中是否包含某个值 boolean hasValue = map.containsValue("female"); System.out.println(hasKey); // 输出: true System.out.println(hasValue); // 输出: false //获取Map中键值对的数量 int size = map.size(); System.out.println(size); System.out.println("-------------keyset遍历-------------"); //遍历1--KeySet Set<Object> keySet = map.keySet(); for (Object key : keySet) { System.out.println(key+":"+map.get(key)); } System.out.println("------------entrySet遍历-----------"); //遍历2--entryset Set<Entry<Object, String>> entrySet = map.entrySet(); for (Entry<Object, String> entry : entrySet) { System.out.println(entry.getKey()+":"+entry.getValue()); } } }
输出结果：
三.通过Map集合统计一串字符串的数量
package com.ctb.map; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; /** * 统计字符串的数量 * @author biao * */ public class Demo2 { public static void main(String[] args) { //定义一窜字符串 String s = "adfjakjdflkajlfajsalkfjdklqajwlekrjlkamfdklasjklrfejqkfnmsfdakhjfdklawjerklwjmfl"; //转换成数组 char[] chars = s.toCharArray(); Map<Character, Integer> map = new HashMap<Character, Integer>(); //遍历 for (char c : chars) { Integer o = map.get(c); if (o == null){//如果为空，则只有一个 map.put(c,1); }else { map.put(c,o+1);//不为空，则+1 } } //将map集合转为set集合 Set<Entry<Character, Integer>> entrySet = map.entrySet(); for (Entry<Character, Integer> entry : entrySet) { System.out.println(entry.getKey()+"出现了"+entry.getValue()+"次"); } } }
输出结果：
四.泛型的作用
1.可将运行时的异常转换为编译期的错误
2.提高代码的健壮性
package com.ctb.map; import java.util.HashMap; import java.util.Map; /** * 泛型的作用 * * @author biao * */ public class Demo3 { public static void main(String[] args) { Map<String, Integer> map = new HashMap<String, Integer>(); map.put("as", 12); map.put("rf", 43); map.put("haha", 24); // map.put(12, 21);会报错，若不添加异常，则以下方法会报异常错误 //指定泛型后则 1.可将运行时的异常转换为编译期的错误 2.提高代码的健壮性 for (Integer value : map.values()) { if (value != null){ if (value % 2 == 0){ System.out.println(value);//打印结果：12 24 } } } } }
五.Treemap排序
按照自然顺序排序
package com.ctb.map; import java.util.Map; import java.util.TreeMap; /** * treemap排序 * 默认按照自然顺序排序 * @author biao * */ public class Demo6 { public static void main(String[] args) { Map<Integer, String> treeMap = new TreeMap<>(); treeMap.put(3, "c"); treeMap.put(1, "a"); treeMap.put(2, "b"); treeMap.put(4, "d"); //排序 for (Map.Entry<Integer, String> entry : treeMap.entrySet()) { System.out.println(entry.getKey() + " : " + entry.getValue()); } } }
输出结果：
六. LinkedHashMap排序
按照插入顺序排序
package com.ctb.map; import java.util.Map; import java.util.LinkedHashMap; /** * LinkedHashMap * 默认按照插入顺序排序 * @author biao * */ public class Demo7 { public static void main(String[] args) { Map<String, String> linkedHashMap = new LinkedHashMap<>(); linkedHashMap.put("a", "A"); linkedHashMap.put("c", "C"); linkedHashMap.put("b", "B"); for (Map.Entry<String, String> entry : linkedHashMap.entrySet()) { System.out.println(entry.getKey() + " : " + entry.getValue()); } } }
输出结果：
七.WeakHashMap弱引用
当某个键没有任何引用时，对应的键值对会被从Map中删除
package com.ctb.map; import java.util.Map; import java.util.WeakHashMap; /** * WeakHashMap 弱引用 * * @author biao * */ public class Demo8 { public static void main(String[] args) { // WeakHashMap 当某个键没有任何引用时，对应的键值对会被从Map中删除 Map<Object, String> weakHashMap = new WeakHashMap<>(); // weak：弱的 Object key = new Object(); weakHashMap.put(key, "value"); System.out.println(weakHashMap.get(key)); key = null; System.gc();// 垃圾回收 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(weakHashMap.get(key)); } }
输出结果：
八.Collections的使用
1.Collections.sort(list);默认升序
2.Collections.sort(list, Collections.reverseOrder()); 字符串降序排序
3.Collections.sort(ll, (a, b) -> b - a);数字类型降序排序
4.collections比较器排序
5.list比较器排序
6.list集合转数组（转字符串数组，转Object类型数组，转integer类型数组）
7.set集合转数组（转integer类型数组）--同list
8.map集合转数组（转object类型数组，转换为指定类型数组，将键(key)转为指定类型数组，将值(value)转为指定类型数组）
9.将集合中的元素进行翻转操作
10.将集合中的元素打乱
11.在集合中进行二分查找
12.获取集合中的最大值和最小值
13.将集合中的所有元素替换成？？？
14.将集合中的元素进行复制到另一个集合
package com.ctb.map; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; /** * collection的使用 * * @author biao * */ public class Demo4 { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("a"); list.add("d"); list.add("b"); list.add("f"); list.add("h"); list.add("e"); System.out.println("打印前：" + list); // 排序--对象同操作 Collections.sort(list); System.out.println("Collections排序(默认升序):" + list); Collections.sort(list, Collections.reverseOrder()); // 对集合进行降序排序 System.out.println("字符串降序："+list); List<Integer> ll=new ArrayList<>(); ll.add(2); ll.add(4); ll.add(42); ll.add(5); ll.add(7); Collections.sort(ll, (a, b) -> b - a); // 对集合进行降序排序 System.out.println("数字类型降序："+ll); // collections比较器排序 Collections.sort(list, new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.compareTo(o2); } }); System.out.println("collections比较器排序:" + list); // list比较器排序 list.sort(new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.compareTo(o2); } }); System.out.println("list比较器排序:" + list); System.out.println("-----------------list集合转数组-------------------"); // 转换为字符串数组 String[] array1 = list.toArray(new String[0]); System.out.println("转换为字符串数组:"+Arrays.toString(array1)); // 转换为Object类型数组 Object[] array2 = list.toArray(); System.out.println("转换为Object类型数组:"+Arrays.toString(array2)); // 转换为integer类型数组 List<Integer> list1 = new ArrayList<Integer>(); list1.add(12); list1.add(4); list1.add(3); Integer[] array = list1.toArray(new Integer[0]); System.out.println("转换为integer类型数组:"+Arrays.toString(array)); System.out.println("-------------------set集合转数组------------------"); // 转换为integer类型数组--其它数组类型同上 Set<Integer> set = new HashSet<>(); set.add(1); set.add(2); set.add(5); int[] arr = set.stream().mapToInt(Integer::intValue).toArray(); System.out.println("转换为integer类型数组:"+Arrays.toString(arr)); // 输出: [1, 2, 5] System.out.println("----------------------map集合转数组--------------------------"); Map<String, Integer> map = new HashMap<>(); map.put("A", 1); map.put("B", 2); map.put("C", 3); Set<Entry<String, Integer>> entrySet = map.entrySet(); // 转换为object类型数组 Object[] array11 = entrySet.toArray(); System.out.println("转换为object类型数组:"+Arrays.toString(array11)); //转换为指定类型数组 Map.Entry<String, Integer>[] array21 = entrySet.toArray(new Map.Entry[0]); System.out.println("转换为指定类型数组:"+Arrays.toString(array21)); //将键(key)转为指定类型数组 String[] keys = map.keySet().toArray(new String[0]); System.out.println("将键(key)转为指定类型数组:"+Arrays.toString(keys)); // 输出: [A, B, C] //将值(value)转为指定类型数组 Integer[] values = map.values().toArray(new Integer[0]); System.out.println("将值(value)转为指定类型数组:"+Arrays.toString(values)); // 输出: [1, 2, 3] //------------------------------------------------ System.out.println("============================================"); List li=new ArrayList<>(); li.add("花花"); li.add("文文"); li.add("琳琳"); li.add("安安"); System.out.println("原数据:"+li); // 将集合中的元素进行翻转操作 Collections.reverse(li); System.out.println("将集合中的元素进行翻转:"+li); // 将集合中的元素打乱 Collections.shuffle(li); System.out.println("将集合中的元素打乱:"+li); System.out.println("---------------------------"); List<Integer> lt=new ArrayList<>(); lt.add(2); lt.add(4); lt.add(6); lt.add(8); lt.add(10); System.out.println("原数据："+lt); //在集合中进行二分查找 int index = Collections.binarySearch(lt, 8); // 在集合中查找元素8 System.out.println("二分查找:"+index); int max = Collections.max(lt); // 获取集合中的最大值 int min = Collections.min(lt); // 获取集合中的最小值 System.out.println("最大值:"+max); // 输出: 10 System.out.println("最大值:"+min); // 输出: 2 List<Integer> lis =new ArrayList<>(); lis.add(3); lis.add(1); lis.add(12); lis.add(23); lis.add(45); System.out.println(lis); Collections.copy(lis, lt); // 将lt中的元素复制到lis中 System.out.println("复制："+lis); // 将集合中的所有元素替换成0 Collections.fill(lt, 0); System.out.println("将集合中的所有元素替换成0:"+lt); } }
输出结果：
九.Arrays的使用
1.数组排序--升序
2.对数组进行降序排序
3.复制一个数组的一部分或全部到一个新数组中
4.复制一个数组的一部分到一个新数组中
5.判断两个数组是否相等
6.将数组全部元素替换成？？？
7.将数组转换为List集合
package com.ctb.map; import java.util.Arrays; import java.util.Collections; import java.util.List; /** * arrays的使用 * * @author biao * */ public class Demo5 { public static void main(String[] args) { Integer[] arr = { 2, 3, 4, 7, 456, 32, 12 }; Arrays.sort(arr); // 数组排序--默认升序 System.out.println("数组排序--默认升序:" + Arrays.toString(arr)); // 对数组进行降序排序 Arrays.sort(arr, Collections.reverseOrder()); System.out.println("对数组进行降序排序:" + Arrays.toString(arr)); // 用于复制一个数组的一部分或全部到一个新数组中 Integer[] copyArr = Arrays.copyOf(arr, 3); // 复制数组前3个元素到新数组中 System.out.println("复制数组前3个元素到新数组中:" + Arrays.toString(copyArr)); //用于复制一个数组的一部分到一个新数组中 Integer[] copyArr1 = Arrays.copyOfRange(arr, 1, 4); // 复制数组索引1到3的元素到新数组中 System.out.println("复制数组索引1到3的元素到新数组中:"+Arrays.toString(copyArr1)); int[] arr1 = {1, 2, 3, 4, 5}; int[] arr2 = {1, 2, 3, 4, 5}; // 判断两个数组是否相等 boolean isEqual = Arrays.equals(arr1, arr2); System.out.println("判断两个数组是否相等:"+isEqual); // 输出: true // 将数组全部元素替换成0 Arrays.fill(arr, 3); System.out.println("将数组全部元素替换成3:"+Arrays.toString(arr)); // 将数组转换为List集合 List<Integer> list = Arrays.asList(arr); System.out.println("将数组转换为List集合:"+list); } }
输出结果：
