1_Map集合概述和特点

• A:Map接口概述

  • 查看API可以知道：

    • 将键映射到值的对象
    • 一个映射不能包含重复的键
    • 每个键最多只能映射到一个值

• B:Map接口和Collection接口的不同

  • Map是双列的,Collection是单列的
  • Map的键唯一,Collection的子体系Set的元素是唯一的

  • Map集合的数据结构只针对键有效，跟值无关;Collection集合的数据结构是针对元素有效

    • HashMap: 键是哈希算法
    • TreeMap: 键是二叉树算法
  • 问: Set集合底层依赖Map,还是Map集合底层依赖Set?

2_Map集合的功能概述

• A: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()：返回集合中的键值对的个数

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class Demo1_Map {public static void main(String[] args) {
//        demo1();
//        demo2();Map<String, Integer> map = new HashMap<>();Integer i1 = map.put("张三", 23);Integer i2 = map.put("李四", 24);Integer i3 = map.put("王五", 25);Collection<Integer> c = map.values();System.out.println(c);System.out.println(map.size());}private static void demo2() {Map<String, Integer> map = new HashMap<>();map.put("张三", 23);map.put("李四", 24);map.put("王五", 25);//        Integer value = map.remove("张三");            //根据键删除键值对元素，并把值返回
//        System.out.println(value);System.out.println(map.containsKey("张三"));//判断集合是否包含指定的键System.out.println(map.containsValue(23));    //判断集合是否包含指定的值System.out.println(map);}private 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);            //相同的键不存储，值覆盖System.out.println(map);System.out.println(i1);}
}

3_Map集合的遍历之键找值

• A:键找值思路：

  • 获取所有键的集合
    *Set<K> keySet():获取集合中所有键的集合
  • 遍历键的集合，获取到每一个键
  • 根据键找值
    *V get(Object key):根据键获取值

• B:案例演示

  • Map集合的遍历之键找值

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;public class Demo2_Iterator {public static void main(String[] args) {Map<String, Integer> map = new HashMap<>();Integer i1 = map.put("张三", 23);Integer i2 = map.put("李四", 24);Integer i3 = map.put("王五", 25);//        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()) {System.out.println(key + "..." + map.get(key));}}
}

4_Map集合的第二种迭代，根据键值对对象找键和值（双列集合不能直接迭代）

• A:键值对对象找键和值思路：(画图演示)

  • 获取所有键值对对象的集合
  • 遍历键值对对象的集合，获取到每一个键值对对象
  • 根据键值对对象找键和值

• B:案例演示

  • Map集合的遍历之键值对对象找键和值
  • Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的Set视图

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;public class Demo3_Iterator {    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();    //父类引用指向子类对象//Entry<String, Integer> en = it.next();    //直接获取的是子类对象String key = en.getKey();                    //根据键值对对象获取键Integer value = en.getValue();                //根据键值对对象获取值System.out.println(key + "..."  + value);}//使用增强for循环迭代for (Map.Entry<String, Integer> en : map.entrySet()) {System.out.println(en.getKey() + "..." + en.getValue());}}
}

interface Inter {interface Inter2 {public void show();}
}class Demo implements Inter.Inter2 {@Overridepublic void show() {}
}

5_HashMap集合键是Student值是String的案例

• A:案例演示

  • HashMap集合键是Student值是String的案例

import java.util.HashMap;
import net.allidea.bean.StudentMap;
public class Demo5_HashMap {//键是学生对象,代表每一个学生//值是String，代表学生籍贯public static void main(String[] args) {HashMap<StudentMap, String> hm = new HashMap<>();hm.put(new StudentMap("张三", 23), "北京");hm.put(new StudentMap("张三", 23), "上海");hm.put(new StudentMap("李四", 24), "武汉");hm.put(new StudentMap("王五", 25), "天津");System.out.println(hm);}
}

package net.allidea.bean;
public class StudentMap {private String name;private int age;@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;StudentMap other = (StudentMap) 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;}public StudentMap() {super();}public StudentMap(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;}@Overridepublic String toString() {return "StudentMap [name=" + name + ", age=" + age + "]";}
}

6_LinkedHashMap的概述和使用

• A:案例演示

  • LinkedHashMap的特点

    • 底层是链表实现的可以保证怎么存就怎么取

import java.util.LinkedHashMap;
public class Demo6_LinkedHashMap {public static void main(String[] args) {LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();lhm.put("张三",23);lhm.put("赵六",26);lhm.put("李四",24);lhm.put("王五",25);    System.out.println(lhm);}
}

7_TreeMap集合键是Student值是String的案例)

• A:案例演示

  • TreeMap集合键是Student值是String的案例

import java.util.Comparator;
import java.util.TreeMap;
import net.allidea.bean.StudentMap;
public class Demo7_TreeMap {public static void main(String[] args) {
//        demo1();TreeMap<StudentMap, String> tm = new TreeMap<>(new Comparator<StudentMap>() {@Overridepublic int compare(StudentMap s1, StudentMap s2) {int num = s1.getName().compareTo(s2.getName());        //按照姓名比较        return num == 0 ? s1.getAge() - s2.getAge() : num;}});tm.put(new StudentMap("张三", 23), "北京");tm.put(new StudentMap("赵六", 26), "深圳");    tm.put(new StudentMap("王五", 25), "广州");tm.put(new StudentMap("李四", 24), "上海");System.out.println(tm);}private static void demo1() {TreeMap<StudentMap, String> tm = new TreeMap<>();tm.put(new StudentMap("张三", 23), "北京");tm.put(new StudentMap("李四", 24), "上海");tm.put(new StudentMap("王五", 25), "广州");tm.put(new StudentMap("赵六", 26), "深圳");    System.out.println(tm);}
}

public class StudentMap implements Comparable<StudentMap>{private String name;private int age;@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;result = prime * result + ((name == null) ? 0 : name.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;StudentMap other = (StudentMap) 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;}public StudentMap() {super();}public StudentMap(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;}@Overridepublic String toString() {return "StudentMap [name=" + name + ", age=" + age + "]";}@Overridepublic int compareTo(StudentMap o) {int num = this.age - o.age;                //以年龄为主要条件return num == 0 ? this.name.compareTo(o.name) : num;}
}

8_统计字符串中每个字符出现的次数

• A:案例演示

  • 需求：统计字符串中每个字符出现的次数

import java.util.HashMap;
public class Demo8_test1 {public static void main(String[] args) {//1.定义一个字符串String s = "aaaaabbbbbcccccc";//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(ket)根据键获取值}}
}

9_集合嵌套之HashMap嵌套HashMap

• A:案例演示

  • 集合嵌套之HashMap嵌套HashMap
  • 需求: javaSE有A班和B班,定义成双列集合,键是学生对象,值是学生的归属地,为了便于管理,把a和b期都归属JavaSE这个大的集合中.

import java.util.HashMap;
import net.allidea.bean.StudentMap;
public class Demo9_HashMapHashMap {public static void main(String[] args) {HashMap<StudentMap, String> hmA = new HashMap<>();hmA.put(new StudentMap("张三", 23), "北京");hmA.put(new StudentMap("李四", 24), "北京");hmA.put(new StudentMap("王五", 25), "上海");hmA.put(new StudentMap("赵六", 26), "杭州");HashMap<StudentMap, String> hmB = new HashMap<>();hmB.put(new StudentMap("唐三", 32), "北京");hmB.put(new StudentMap("悟空", 15), "北京");hmB.put(new StudentMap("悟能", 10), "上海");hmB.put(new StudentMap("悟净", 20), "杭州");HashMap<HashMap<StudentMap, String>, String> hm = new HashMap<>();hm.put(hmA, "班级A");hm.put(hmB, "班级B");//遍历双列结合for (HashMap<StudentMap, String> h : hm.keySet()) {            //hm.keySet()代表的是双列集合中键的集合String value = hm.get(h);                            //get(h)根据键对象获取值对象//遍历键的双列集合对象for (StudentMap key : h.keySet()) {                    //h.keySet()获取集合中所有的学生键对象String value2 = h.get(key);System.out.println(key + "..." + value2 + "..." + value);}        }}
}

10_HashMap和Hashtable的区别)

• A:共同点：

  • 底层都是哈希算法，都是双列集合

• B:区别

  • 1.Hashtable是JDK1.0版本出现的,是线程安全的,效率低; HashMap是JDK1.2版本出现的,是线程不安全的,效率高
  • 2.Hashtable不可以存储null键和null值; HashMap可以存储null键和null值(目的是为了让后续代码可以继续执行)

• C:案例演示

  • HashMap和Hashtable的区别

    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);}

11_Collections工具类的概述和常见方法讲解

• A:Collections类概述

  • 针对集合操作 的工具类
• B:Collections成员方法
  public static <T> void sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。
  public static <T> int binarySearch(List<?> list,T key) 使用二分搜索法搜索指定列表，以获得指定对象
  public static <T> T max(Collection<?> coll) 根据元素的自然顺序，返回给定 collection 的最大元素。
  public static void reverse(List<?> list) 反转指定列表中元素的顺序。
  public static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。

import java.util.ArrayList;
import java.util.Collections;
public class Demo1_Collections {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("a");list.add("c");list.add("d");list.add("e");Collections.sort(list);            //将集合排序System.out.println(Collections.binarySearch(list, "e"));//使用二分搜索法搜索指定列表，以获得指定对象System.out.println(Collections.max(list));    //根据元素的自然顺序，返回给定 collection 的最大元素。Collections.reverse(list);                    //反轉集合Collections.shuffle(list);                    //随机置换，洗牌System.out.println(list);                    }
}

12_模拟斗地主洗牌和发牌

• A:案例演示

  • 模拟斗地主洗牌和发牌，牌没有排序

import java.util.ArrayList;
import java.util.Collections;
public class Demo2_test {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> dushen = new ArrayList<>();ArrayList<String> dusheng = new ArrayList<>();ArrayList<String> duxia = 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) {dushen.add(poker.get(i));} else if(i % 3 == 1) {dusheng.add(poker.get(i));} else{duxia.add(poker.get(i));}}//4.看牌System.out.println(dushen);System.out.println(dusheng);System.out.println(duxia);System.out.println(dipai);}
}

14_模拟斗地主洗牌和发牌并对牌进行排序的代码实现

• A:画图演示

  • 画图说明排序原理

• B:案例演示

  • 模拟斗地主洗牌和发牌并对牌进行排序的代码实现

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;
public class Demo3_test {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);                        //将索引0-51添加到list集合中index++;}}//将小王添加到双列集合中hm.put(index, "小王");list.add(index);                        //将索引52添加到list集合中index++;hm.put(index, "大王");list.add(index);                        //将索引53添加到list集合中//洗牌Collections.shuffle(list);//发牌TreeSet<Integer> dushen = new TreeSet<>();TreeSet<Integer> dusheng = new TreeSet<>();TreeSet<Integer> duxia = 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) {dushen.add(list.get(i));}else if(i % 3 == 1) {dusheng.add(list.get(i));}else{duxia.add(list.get(i));}}//看牌lookPoker(hm, dushen, "赌神");lookPoker(hm, dusheng, "赌圣");lookPoker(hm, duxia, "赌侠");lookPoker(hm, dipai, "底牌");}//返回值类型void,参数列表HashMap、TreeSet、String namepublic 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();}
}

15_集合框架(泛型固定下边界)

• ? super E

public class Demo4_Genric {public static void main(String[] args) {TreeSet<StudentMap> ts1 = new TreeSet<>(new CompareByAge());ts1.add(new StudentMap("张三", 23));ts1.add(new StudentMap("李四", 14));ts1.add(new StudentMap("王五", 23));ts1.add(new StudentMap("赵六", 33));TreeSet<Student> ts2 = new TreeSet<>(new CompareByAge());ts2.add(new Student("张三", 23));ts2.add(new Student("李四", 14));ts2.add(new Student("王五", 23));ts2.add(new Student("赵六", 33));System.out.println(ts2);}
}class CompareByAge implements Comparator<StudentMap> {@Overridepublic int compare(StudentMap s1, StudentMap s2) {int num = s1.getAge() - s2.getAge();return num == 0 ? s1.getName().compareTo(s2.getName()) : num;}
}

16_集合总结

• Collection

  • List(存取有序,有索引,可以重复)

    • ArrayList

      • 底层是数组实现的,线程不安全,查找和修改快,增和删比较慢

    • LinkedList

      • 底层是链表实现的,线程不安全,增和删比较快,查找和修改比较慢

    • Vector

      • 底层是数组实现的,线程安全的,无论增删改查都慢
    • 如果查找和修改多,用ArrayList
    • 如果增和删多,用LinkedList
    • 如果都多,用ArrayList

  • Set(存取无序,无索引,不可以重复)

    • HashSet

      • 底层是哈希算法实现

    • LinkedHashSet

      • 底层是链表实现,但是也是可以保证元素唯一,和HashSet原理一样

    • TreeSet

      • 底层是二叉树算法实现
    • 一般在开发的时候不需要对存储的元素排序,所以在开发的时候大多用HashSet,HashSet的效率比较高
    • TreeSet在面试的时候比较多,问你有几种排序方式,和几种排序方式的区别

  • Map

    • HashMap

      • 底层是哈希算法,针对键

    • LinkedHashMap

      • 底层是链表,针对键

    • TreeMap

      • 底层是二叉树算法,针对键
    • 开发中用HashMap比较多