Map集合
Map集合的概述和特点：
A：概述
将键映射到值的对象
一个映射不能包含重复的键
每个 键最多只能映射到一个值
B：Map接口和Collection接口的不同
Map是双列的，Collection是单列的
Map的键唯一，Collection的子体系Set是唯一的
Map集合的数据结构值针对键有效，跟值无关；Collection集合的数据结构是针对元素有效
Map集合的功能概述：
a：添加功能
V put（K key，V value）：添加元素
如果键是第一次存储，就直接存储元素，返回null
如果键不是第一次存储，就用值把以前的值替换掉，返回以前的值
b：删除功能
void clear（）：移除所有的键值对元素
V remove（Object key）：根据键删除键值对元素，并把值返回
c：判断功能
boolean containsKey（Object key）：判断集合是否包含指定的键
boolean containsValue（Object value）：判断集合是否包含指定的值
boolean isEmpty（）：判断集合是否为空
d：获取功能
Set<Map.Entry<K，V>> entrySet（）：
V get（Object key）：根据键获取值
Set<K> keySet（）：获取集合中所有键的集合
Collection<V> values()：获取集合中所有值得集合
e：长度功能
int size（）：返回集合中的键值对的个数
Demo：
package com.map; import java.util.Collection; import java.util.HashMap; import java.util.Map; public class Demo1 { public static void main(String[] args) { // demo1(); // demo2(); Map<String, Integer> map = new HashMap<>(); map.put("张三", 23); map.put("李四", 24); map.put("王五", 25); map.put("赵六", 26); Collection<Integer> c = map.values(); System.out.println(c); System.out.println(map.size()); } public static void demo2() { Map<String, Integer> map = new HashMap<>(); map.put("张三", 23); map.put("李四", 24); map.put("王五", 25); map.put("赵六", 26); //Integer value = map.remove("张三"); //根据键删除元素，返回键对应的值 //System.out.println(value); System.out.println(map.containsKey("张三")); //判断是否包含传入的键 System.out.println(map.containsValue(100)); //判断是否包含传入的 System.out.println(map); } public static void demo1() { Map<String, Integer> map = new HashMap<>(); Integer i1 = map.put("张三", 23); Integer i2 = map.put("李四", 24); Integer i3 = map.put("王五", 25); Integer i4 = map.put("赵六", 26); Integer i5 = map.put("张三", 26); //相同的键不存储，值覆盖，吧覆盖的值返回 System.out.println(map); System.out.println(i1); System.out.println(i2); System.out.println(i3); System.out.println(i4); System.out.println(i5); } }
Map集合的遍历之键找值：
A：键找值思路
获取所有键的集合
遍历键的集合，获取到每一个键
根据键找值
B：Demo
package com.map; import java.util.HashMap; import java.util.Map; public class Demo2 { public static void main(String[] args) { Map<String, Integer> map = new HashMap<>(); map.put("张三", 23); map.put("李四", 24); map.put("王五", 25); map.put("赵六", 26); //Integer i = map.get("张三"); //根据键获取值 //System.out.println(i); //获取所有的键 /*Set<String> keySet = map.keySet(); //获取所有键的集合 Iterator<String> it = keySet.iterator(); //获取迭代器 while (it.hasNext()) { //判断集合中是否有元素 String key = it.next(); //获取每一个键 Integer value = map.get(key); //根据键获取值 System.out.println(key + "=" +value); }*/ //使用增强for循环遍历 for (String key : map.keySet()) { //map.keySet()是所有键的集合 System.out.println(key + "=" + map.get(key)); } } }
Map集合的遍历值键值对对象找键和值：
A：键值对对象找键和值思路
获取所有键值对对象的集合
遍历键值对对象的集合，获取到每一个键值对对象
根据键值对对象找键和值
B：Demo
package com.map; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class Demo3 { /** * Map集合的第二种迭代，根据键值对对象，获取键和值 */ public static void main(String[] args) { Map<String, Integer> map = new HashMap<>(); map.put("张三", 23); map.put("李四", 24); map.put("王五", 25); map.put("赵六", 26); // Map.Entry说明Entry是Map的内部接口，将键和值封装成了Entry对象，并存储在Set中 Set<Map.Entry<String, Integer>> entrySet = map.entrySet(); //获取每一个对象 /*Iterator<Map.Entry<String, Integer>> it = entrySet.iterator(); while (it.hasNext()) { //获取每一个Entry对象 Map.Entry<String, Integer> en = it.next(); String key = en.getKey(); //根据键值对对象获取键 Integer value = en.getValue(); //根据键值对对象获取值 System.out.println(key + "=" + value); }*/ for (Map.Entry<String, Integer> en : entrySet) { System.out.println(en.getKey() + "=" + en.getValue()); } } }
HashMap集合键是Student值是String的案例：
package com.map; import java.util.HashMap; import com.bean.Student; public class Demo4 { /** * HashMap集合键是Student值是String的案例： * 键是学生对象，代表每一个学生 * 值是字符串对象，代表学生归属地 */ public static void main(String[] args) { HashMap<Student,String> hm = new HashMap<>(); hm.put(new Student("张三",23),"北京" ); hm.put(new Student("李四",23),"上海" ); hm.put(new Student("王五",25),"广州" ); hm.put(new Student("赵六",26),"深圳" ); System.out.println(hm); } }
LinkedHashMap的概述和使用：
特点：
底层是链表实现的可以保证怎么存就怎么取
package com.map; import java.util.LinkedHashMap; public class Demo5 { public static void main(String[] args) { LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>(); lhm.put("张三", 23); lhm.put("李四", 24); lhm.put("王五", 25); lhm.put("赵六", 26); System.out.println(lhm); } }
TreeMap集合键是Student值是String的案例：
package com.map; import java.util.Comparator; import java.util.TreeMap; import com.bean.Student; public class Demo6 { public static void main(String[] args) { TreeMap<Student, String> tm = new TreeMap<>(new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { int num = s1.getName().compareTo(s2.getName()); //按照姓名排序 return num == 0 ? s1.getAge() - s2.getAge() : num; } }); tm.put(new Student("张三",23),"北京" ); tm.put(new Student("王五",35),"广州" ); tm.put(new Student("李四",13),"上海" ); tm.put(new Student("赵六",46),"深圳" ); System.out.println(tm); } }
统计字符串中每个字符出现的次数：
package com.test; import java.util.HashMap; public class Test1 { /** * 需求：统计字符串中每个字符出现的次数 * 分析： * 1、定义一个需要被统计字符的字符串 * 2、将字符串转换为字符数组 * 3、定义双列集合，存储字符串中字符一级字符出现的次数 * 4、遍历字符数组获取每一个字符，并将字符存储在双列集合中 * 5、存储过程中要做判断，如果集合中不包含这个键，就将该字符当作键，值为1存储，如果集合中包含这个键，就将值加1存储 * 6、打印双列集合获取字符出现的次数 */ public static void main(String[] args) { //1、定义一个需要被统计字符的字符串 String s = "aaaaaabbbbbcccccccc"; //2、将字符串转换为字符数组 char[] arr = s.toCharArray(); //3、定义双列集合，存储字符串中字符一级字符出现的次数 HashMap<Character, Integer> hm = new HashMap<>(); //4、遍历字符数组获取每一个字符，并将字符存储在双列集合中 for (char c : arr) { //5、存储过程中要做判断，如果集合中不包含这个键，就将该字符当作键，值为1存储，如果集合中包含这个键，就将值加1存储 /*if (!hm.containsKey(c)) { //如果不包含这个键 hm.put(c, 1); }else { hm.put(c, hm.get(c) + 1); }*/ hm.put(c, !hm.containsKey(c) ? 1 : hm.get(c) + 1); } //6、打印双列集合获取字符出现的次数 for (Character key : hm.keySet()) { //hm.keySet()代表所有键的集合 System.out.println(key + "=" + hm.get(key));//hm.get(key)根据键获取值 } } }
HashMap和Hashtable的区别：
A：面试题
区别：
Hashtable是JDK1.0版本出现的，是线程安全的，效率低，HashMap是JDK1.2版本出现的，是线程不安全的，效率高
Hashtable不可以存储null键和null值，HashMap可以存储null键和null值
B：Demo
package com.map; import java.util.HashMap; import java.util.Hashtable; public class Demo7 { public static void main(String[] args) { HashMap<String, Integer> hm = new HashMap<>(); hm.put(null, 23); hm.put("张三", null); System.out.println(hm); Hashtable<String, Integer> ht = new Hashtable<>(); ht.put(null, 23); ht.put("张三", null); System.out.println(ht); } }
Collection工具类的概述和常见方法：
A：概述
针对集合操作的工具类
B：成员方法
public static <T> void sort(List<T> list)
public static <T> int binarySearch(List<?> list,T key)
public static <T> T max(Collection<?> coll)
public static void reverse(List<?> list)
public static void shuffle(List<?> list)
C：Demo
package com.collection; import java.util.ArrayList; import java.util.Collections; public class Demo1 { public static void main(String[] args) { // demo1(); // demo2(); ArrayList<String> list = new ArrayList<>(); list.add("a"); list.add("c"); list.add("h"); list.add("f"); list.add("g"); System.out.println(Collections.max(list)); //根据默认排序结果获取集合中的最大值 // Collections.reverse(list); //反转集合 Collections.shuffle(list); //随机置换，可以用来洗牌 System.out.println(list); } public static void demo2() { ArrayList<String> list = new ArrayList<>(); list.add("a"); list.add("c"); list.add("d"); list.add("f"); list.add("g"); System.out.println(Collections.binarySearch(list, "c")); System.out.println(Collections.binarySearch(list, "b")); } public static void demo1() { ArrayList<String> list = new ArrayList<>(); list.add("c"); list.add("d"); list.add("a"); list.add("c"); list.add("b"); list.add("c"); System.out.println(list); Collections.sort(list); //将集合排序 System.out.println(list); } }
模拟斗地主洗牌和发牌
模拟斗地主洗牌和发牌，牌没有排序：
package com.test; import java.util.ArrayList; import java.util.Collections; public class Test2 { /** * 模拟斗地主洗牌和发牌，牌没有排序 * * 分析： * 1、买一副扑克，自己创建一个集合对象，将扑克牌存储进去 * 2、洗牌 * 3、发牌 * 4、看牌 */ public static void main(String[] args) { //1、买一副扑克，自己创建一个集合对象，将扑克牌存储进去 String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"}; String[] color = {"红桃","黑桃","方块","梅花"}; ArrayList<String> poker = new ArrayList<>(); //拼接花色和数字 for (String s1 : color) { for (String s2 : num) { poker.add(s1.concat(s2)); //concat连接两个字符串 } } poker.add("小王"); poker.add("大王"); //2、洗牌 Collections.shuffle(poker); //3、发牌 ArrayList<String> tan = new ArrayList<>(); ArrayList<String> zhou = new ArrayList<>(); ArrayList<String> chen = new ArrayList<>(); ArrayList<String> dipai = new ArrayList<>(); for (int i = 0; i < poker.size(); i++) { if (i >= poker.size() - 3) { dipai.add(poker.get(i)); //将三张底牌存储在底牌集合中 }else if (i % 3 == 0) { tan.add(poker.get(i)); }else if (i % 3 == 1) { zhou.add(poker.get(i)); }else { chen.add(poker.get(i)); } } //4、看牌 System.out.println(tan); System.out.println(zhou); System.out.println(chen); System.out.println(dipai); } }
模拟斗地主洗牌和发牌并对牌进行排序：
package com.test; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.TreeSet; public class Test3 { /** * 模拟斗地主洗牌和发牌，牌没有排序 * * 分析： * 1、买一副扑克，自己创建一个集合对象，将扑克牌存储进去 * 2、洗牌 * 3、发牌 * 4、看牌 */ public static void main(String[] args) { //1、买一副扑克，自己创建一个集合对象，将扑克牌存储进去 String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"}; String[] color = {"方块","梅花","红桃","黑桃"}; HashMap<Integer, String> hm = new HashMap<>(); //存储索引和扑克牌 ArrayList<Integer> list = new ArrayList<>(); //存储索引 int index = 0; //拼接扑克牌并索引和扑克牌存储在hm中 for (String s1 : num) { //获取数字 for (String s2 : color) { //获取颜色 hm.put(index, s2.concat(s1)); list.add(index); index++; } } //将小王添加到双列集合中 hm.put(index, "小王"); list.add(index); //将52索引添加到集合中 index++; hm.put(index, "大王"); list.add(index); //将53索引添加到集合中 //2、洗牌 Collections.shuffle(list); //3、发牌 TreeSet<Integer> tan = new TreeSet<>(); TreeSet<Integer> zhou = new TreeSet<>(); TreeSet<Integer> chen = new TreeSet<>(); TreeSet<Integer> dipai = new TreeSet<>(); for (int i = 0; i < list.size(); i++) { if (i >= list.size() - 3) { dipai.add(list.get(i)); //将三张底牌存储在底牌集合中 }else if (i % 3 == 0) { tan.add(list.get(i)); }else if (i % 3 == 1) { zhou.add(list.get(i)); }else { chen.add(list.get(i)); } } //4、看牌 lookPoker(hm, tan, "谭"); lookPoker(hm, zhou, "周"); lookPoker(hm, chen, "陈"); lookPoker(hm, dipai, "底牌"); } /** * 看牌 * 分析： * 1、返回值类型void * 2、参数列表HashMap，TreeSet，String name */ public static void lookPoker(HashMap<Integer, String> hm,TreeSet<Integer> ts , String name){ System.out.print(name + "的牌是："); for (Integer i : ts) { //i代表双列集合中的每一个键 System.out.print(hm.get(i) + " "); } System.out.println(); } }
泛型固定下边界：
package com.collection; import java.util.ArrayList; import java.util.Comparator; import java.util.TreeSet; import com.bean.BaseStudent; import com.bean.Student; public class Demo2 { /** * 泛型固定下边界 * ？ super E * * 泛型固定上边界 * ？ extends E */ public static void main(String[] args) { // demo1(); TreeSet<Student> ts1 = new TreeSet<>(new CompareByAge()); ts1.add(new Student("张三",32)); ts1.add(new Student("李四",12)); ts1.add(new Student("王五",42)); ts1.add(new Student("赵六",22)); TreeSet<BaseStudent> ts2 = new TreeSet<>(new CompareByAge()); ts2.add(new BaseStudent("张三",32)); ts2.add(new BaseStudent("李四",12)); ts2.add(new BaseStudent("王五",42)); ts2.add(new BaseStudent("赵六",22)); System.out.println(ts2); } public static void demo1() { ArrayList<Student> list1 = new ArrayList<>(); list1.add(new Student("张三",23)); list1.add(new Student("李四",24)); ArrayList<BaseStudent> list2 = new ArrayList<>(); list2.add(new BaseStudent("王五",25)); list2.add(new BaseStudent("赵六",26)); list1.addAll(list2); } } class CompareByAge implements Comparator<Student> { @Override public int compare(Student s1, Student s2) { int num = s1.getAge() - s2.getAge(); return num == 0 ? s1.getName().compareTo(s2.getName()) : num; } }
Student.java
package com.bean; import javax.swing.plaf.nimbus.NimbusLookAndFeel; public class Student implements Comparable<Student> { private String name; private int age; public Student() { super(); } public Student(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Student [name=" + name + ", age=" + age + "]"; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Student other = (Student) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } @Override public int compareTo(Student o) { int num = this.age - o.age; return num == 0 ? this.name.compareTo(o.name) : num; } }
BaseStudent.java
package com.bean; public class BaseStudent extends Student { public BaseStudent() { } public BaseStudent(String name, int age) { super(name, age); } }