10-集合（核心类库）

感谢你的路过，希望学生的笔记能给你一点微不足道的参考（2/100）
Java基础思维导图，完整Java体系的链接

目录标题

一，集合
- 1.1为什么要有集合？什么是集合？
二，数据结构
- 2.1链表
- 2.2二叉树
- 2.3栈（联系一下内存）
- 2.4queue
三，集合框架
- 3.1Collection集合
四，List 接口
- 4.1什么是List接口？
- 4.2List接口特点：
- 4.3List功能及其子类：
五，Set接口
- 5.1Set接口介绍？
- 5.2Set接口的特点？
- 5.3Set集合存储元素不重复的原理
- 5.4HashSet集合
六，Map集合
- 6.1为什么要有Map集合？
- 6.2Map 接口下的集合与 Collection 接口下的集合的存储数据图？
- 6.3Map集合的特点？
- 6.4map的特性
- 6.5使用Map集合的注意：？
- 6.6Map常用子类有哪些？
- 6.7Map接口中的常用方法有？（Map的子类同样适用于这些方法）
- 6.8Map集合各子类的区别分析？
七，其他：
- 7.1Iterator迭代器：
- 7.2增强for
- 7.3Comparable接口
- 7.4哈希表
- 7.5 JDK9的集合新特性（省略）
八，综合练习

一，集合

1.1为什么要有集合？什么是集合？

我们在学习Java的时候始终在跟数据打交道，如何传输数据，如何接收数据，如何存储数据。在生活中我们有各种各样的容器，比如袋子，碗，水果篮，箱子，甚至车的后备箱都能看作是一个容器。同样的，在java中也存在各种各样的‘容器’，我们把java中所有的‘容器’的总称叫做集合。集合是Java对数据结构成熟的实现。

二，数据结构

2.1链表

2.1.1什么是链表？
      链表:linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时i动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
   2.1.2链表的特点？
      多个结点之间，通过地址进行连接。
      查找元素慢：
      增删元素快：只需要修改连接下个元素的地址即可。
   2.1.3链表共分几类？
      链表常用的有 3 类：单链表、双向链表、循环链表。
      链表的核心操作集有 3 种：插入、删除、查找(遍历）

2.2二叉树

2.2.1什么是二叉树
      二叉树是树的一种，每个节点最多可具有两个子树，即结点的度最大为 2（结点度：结点拥有的子树数）。

      例：二叉树.png 树的一些概念

      二叉树就是每个节点不能多于有两个儿子，上面的图就是一颗二叉树，而且还是一种特殊的二叉树：二叉查找树(binary search tree)。
         二叉树的遍历方式二叉树的遍历方式，一般分为先序遍历，中序遍历，后序遍历。
            • 先序遍历 o 先访问根节点，然后访问左节点，最后访问右节点(根->左->右)
            • 中序遍历 o 先访问左节点，然后访问根节点，最后访问右节点(左->根->右)
            • 后序遍历 o 先访问左节点，然后访问右节点，最后访问根节点(左->右->根)

            先序遍历(根-左-右):1-2-4-8-9-5-10-3-6-7
            中序遍历:(左-根-右):8-4-9-2-10-5-1-6-3-7
            后序遍历(左-右-根):8-9-4-10-5-2-6-7-3-1
     补充红黑树（本质还是二叉查找树）
        红黑树的约束:
            1. 节点可以是红色的或者黑色的
            2. 根节点是黑色的
            3. 叶子节点(特指空节点)是黑色的
            4. 每个红色节点的子节点都是黑色的
            5. 任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同
        特点:
            速度特别快,趋近平衡树,查找叶子元素最少和最多次数不多于二倍

2.3栈（联系一下内存）

栈（stack）是限定仅在表尾进行插入和删除操作的线性表。我们把允许插入和删除的一端称为栈顶，另一端称为栈底，不含任何数据元素的栈称为空栈。栈又称为先进后出的线性表。

简单的说：采用该结构的集合，对元素的存取有如下的特点先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。
例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。栈的入口、出口的都是栈的顶端位置。
队列：

2.4queue

简称队，队列是一种特殊的线性表，是运算受到限制的一种线性表，只允许在表的一端进行插入，而在另一端进行删除元素的线性表。队尾(rear)是允许插入的一端。队头(front)是允许删除的一端。空队列是不含元素的空表。

三，集合框架

3.1Collection集合

Collection 接口是在整个 Java 类集中保存单值的最大操作父接口，里面每次操作的时候都只能保存一个对象的数据。定义在 java.util 包中。
      此接口的常用方法如下所示：

         集合框架
            单列集合java.util.Collection
               java.util.List
               java.util.Set
            双列集合java.util.Map
代码：

package com.wyh;import java.util.Collection;
import java.util.HashSet;/*java.util.Collection接口所有单列集合的最顶层的接口,里边定义了所有单列集合共性的方法任意的单列集合都可以使用Collection接口中的方法共性的方法:public boolean add(E e)：  把给定的对象添加到当前集合中 。public void clear() :清空集合中所有的元素。public boolean remove(E e): 把给定的对象在当前集合中删除。public boolean contains(E e): 判断当前集合中是否包含给定的对象。public boolean isEmpty(): 判断当前集合是否为空。public int size(): 返回集合中元素的个数。public Object[] toArray(): 把集合中的元素，存储到数组中。*/
public class Demo01_Collection {public static void main(String[] args) {//创建集合对象,可以使用多态//Collection<String> coll = new ArrayList<>();Collection<String> coll = new HashSet<>();System.out.println(coll);//重写了toString方法  []/*public boolean add(E e)：  把给定的对象添加到当前集合中 。返回值是一个boolean值,一般都返回true,所以可以不用接收*/boolean b1 = coll.add("张三");System.out.println("b1:"+b1);//b1:trueSystem.out.println(coll);//[张三]coll.add("李四");coll.add("李四");coll.add("赵六");coll.add("田七");System.out.println(coll);//[张三, 李四, 赵六, 田七]/*public boolean remove(E e): 把给定的对象在当前集合中删除。返回值是一个boolean值,集合中存在元素,删除元素,返回true集合中不存在元素,删除失败,返回false*/boolean b2 = coll.remove("赵六");System.out.println("b2:"+b2);//b2:trueboolean b3 = coll.remove("赵四");System.out.println("b3:"+b3);//b3:falseSystem.out.println(coll);//[张三, 李四, 田七]/*public boolean contains(E e): 判断当前集合中是否包含给定的对象。包含返回true不包含返回false*/boolean b4 = coll.contains("李四");System.out.println("b4:"+b4);//b4:trueboolean b5 = coll.contains("赵四");System.out.println("b5:"+b5);//b5:false//public boolean isEmpty(): 判断当前集合是否为空。 集合为空返回true,集合不为空返回falseboolean b6 = coll.isEmpty();System.out.println("b6:"+b6);//b6:false//public int size(): 返回集合中元素的个数。int size = coll.size();System.out.println("size:"+size);//size:3//public Object[] toArray(): 把集合中的元素，存储到数组中。Object[] arr = coll.toArray();for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}//public void clear() :清空集合中所有的元素。但是不删除集合,集合还存在coll.clear();System.out.println(coll);//[]System.out.println(coll.isEmpty());//true}
}

四，List 接口

4.1什么是List接口？

java.util.List 接口继承自 Collection 接口，是单列集合的一个重要分支，习惯性地会将实现了 List 接口的对象称为List集合。
在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。

4.2List接口特点：

1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、 22、33的顺序完成的）。
2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
代码：

package com.wyh.List;
import java.util.ArrayList;
//import java.util.Iterator;
import java.util.List;/*  List接口中常用方法java.util.List接口 extends Collection接口List接口的特点:1.有序的集合,存储元素和取出元素的顺序是一致的(存储123 取出123)2.有索引,包含了一些带索引的方法3.允许存储重复的元素List接口中带索引的方法(特有)- public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。- public E get(int index):返回集合中指定位置的元素。- public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。- public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。注意:操作索引的时候,一定要防止索引越界异常IndexOutOfBoundsException:索引越界异常,集合会报ArrayIndexOutOfBoundsException:数组索引越界异常StringIndexOutOfBoundsException:字符串索引越界异常*/
public class Demo02_List {public static void main(String[] args) {//创建一个List集合对象,多态List<String> list = new ArrayList<>();//使用add方法往集合中添加元素list.add("a");list.add("b");list.add("c");list.add("d");list.add("a");//打印集合System.out.println(list);//[a, b, c, d, a]  不是地址，重写了toString//public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。//在c和d之间添加一个itheimalist.add(3,"itheima");//[a, b, c, itheima, d, a]System.out.println(list);//public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。//移除元素String removeE = list.remove(2);System.out.println("被移除的元素:"+removeE);//被移除的元素:cSystem.out.println(list);//[a, b, itheima, d, a]//public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。//把最后一个a,替换为AString setE = list.set(4, "A");System.out.println("被替换的元素:"+setE);//被替换的元素:aSystem.out.println(list);//[a, b, itheima, d, A]//List集合遍历有3种方式//使用普通的for循环for(int i=0; i<list.size(); i++){//public E get(int index):返回集合中指定位置的元素。String s = list.get(i);System.out.println(s);}System.out.println("-----------------");/* //使用迭代器Iterator<String> it = list.iterator();while(it.hasNext()){String s = it.next();System.out.println(s);}*/System.out.println("-----------------");//使用增强forfor (String s : list) {System.out.println(s);}String r = list.get(5);//IndexOutOfBoundsException: Index 5 out-of-bounds for length 5System.out.println(r);}
}

4.3List功能及其子类：

代码：

package com.wyh.List;
import java.util.LinkedList;/*  LinkedList集合中的方法（与List特性相对）java.util.LinkedList集合 implements List接口LinkedList集合的特点:1.底层是一个链表结构:查询慢,增删快2.里边包含了大量操作首尾元素的方法注意:使用LinkedList集合特有的方法,不能使用多态- public void addFirst(E e):将指定元素插入此列表的开头。- public void addLast(E e):将指定元素添加到此列表的结尾。- public void push(E e):将元素推入此列表所表示的堆栈。- public E getFirst():返回此列表的第一个元素。- public E getLast():返回此列表的最后一个元素。- public E removeFirst():移除并返回此列表的第一个元素。- public E removeLast():移除并返回此列表的最后一个元素。- public E pop():从此列表所表示的堆栈处弹出一个元素。- public boolean isEmpty()：如果列表不包含元素，则返回true。*/
public class Demo03_LinkedList {public static void main(String[] args) {show03();}/*- public E removeFirst():移除并返回此列表的第一个元素。- public E removeLast():移除并返回此列表的最后一个元素。- public E pop():从此列表所表示的堆栈处弹出一个元素。此方法相当于 removeFirst*/private static void show03() {//创建LinkedList集合对象LinkedList<String> linked = new LinkedList<>();//使用add方法往集合中添加元素linked.add("a");linked.add("b");linked.add("c");System.out.println(linked);//[a, b, c]//String first = linked.removeFirst();String first = linked.pop();System.out.println("被移除的第一个元素:"+first);String last = linked.removeLast();System.out.println("被移除的最后一个元素:"+last);System.out.println(linked);//[b]}/*- public E getFirst():返回此列表的第一个元素。- public E getLast():返回此列表的最后一个元素。*/private static void show02() {//创建LinkedList集合对象LinkedList<String> linked = new LinkedList<>();//使用add方法往集合中添加元素linked.add("a");linked.add("b");linked.add("c");//linked.clear();//清空集合中的元素 在获取集合中的元素会抛出NoSuchElementException//public boolean isEmpty()：如果列表不包含元素，则返回true。if(!linked.isEmpty()){String first = linked.getFirst();System.out.println(first);//aString last = linked.getLast();System.out.println(last);//c}}/*- public void addFirst(E e):将指定元素插入此列表的开头。- public void addLast(E e):将指定元素添加到此列表的结尾。- public void push(E e):将元素推入此列表所表示的堆栈。此方法等效于 addFirst(E)。*/private static void show01() {//创建LinkedList集合对象LinkedList<String> linked = new LinkedList<>();//使用add方法往集合中添加元素linked.add("a");linked.add("b");linked.add("c");System.out.println(linked);//[a, b, c]//public void addFirst(E e):将指定元素插入此列表的开头。//linked.addFirst("www");linked.push("www");System.out.println(linked);//[www, a, b, c]//public void addLast(E e):将指定元素添加到此列表的结尾。此方法等效于 add()linked.addLast("com");System.out.println(linked);//[www, a, b, c, com]}
}

五，Set接口

5.1Set接口介绍？

java.util.Set 接口和 java.util.List 接口一样，同样继承自 Collection 接口，它与 Collection 接口中的方法基本一致，并没有对 Collection 接口进行功能上的扩充，只是比 Collection 接口更加严格了。与 List 接口不同的是， Set 接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

5.2Set接口的特点？

1.不允许存储重复的元素
2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
代码：

package com.wyh.Set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;/*HashSet及TreeSetjava.util.Set接口 extends Collection接口Set接口的特点:1.不允许存储重复的元素2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历java.util.HashSet集合 implements Set接口HashSet特点:1.不允许存储重复的元素2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历3.是一个无序的集合,存储元素和取出元素的顺序有可能不一致4.底层是一个哈希表结构(查询的速度非常的快)*/
public class Demo06_Set {public static void main(String[] args) {/* HashSet<Integer> set = new HashSet<>();//使用add方法往集合中添加元素set.add(1);set.add(3);set.add(2);set.add(1);//使用迭代器遍历set集合Iterator<Integer> it = set.iterator();while (it.hasNext()){Integer n = it.next();System.out.println(n);//1,2,3}//使用增强for遍历set集合System.out.println("-----------------");for (Integer i : set) {System.out.println(i);}*/// 例子：HashSet的无序及TreeSet的有序HashSet<String> set01 = new HashSet<>();//使用add方法往集合中添加元素set01.add("使用add方法");set01.add("往集合中添加");set01.add("使用迭代器遍");set01.add("使用增强for");//使用增强for遍历set集合Iterator<String> it01 = set01.iterator();System.out.println("-----------------");for (String i : set01) {System.out.println(i);}TreeSet<String> set = new TreeSet<>();//使用add方法往集合中添加元素set.add("b");set.add("c");set.add("a");set.add("d");//使用迭代器遍历set集合Iterator<String> it = set.iterator();while (it.hasNext()){String n = it.next();System.out.println(n);//1,2,3}}
}

5.3Set集合存储元素不重复的原理

代码：

package com.wyh.Set;
import java.util.HashSet;/*Set集合不允许存储重复元素的原理*/
class Demo07_SetSave {public static void main(String[] args) {//创建HashSet集合对象HashSet<String> set = new HashSet<>();String s1 = new String("abc");String s2 = new String("abc");set.add(s1);set.add(s2);set.add("重地");set.add("通话");set.add("abc");System.out.println(set);//[重地, 通话, abc]}
}

package com.wyh.Set;
import java.util.HashSet;/*HashSet存储自定义类型元素set集合报错元素唯一:存储的元素(String,Integer,...Student,Person...),必须重写hashCode方法和equals方法要求:同名同年龄的人,视为同一个人,只能存储一次*/
public class Demo08_SetSavePerson {public static void main(String[] args) {//创建HashSet集合存储PersonHashSet<Person> set = new HashSet<>();Person p1 = new Person("小美女",18);Person p2 = new Person("小美女",18);Person p3 = new Person("小美女",19);System.out.println(p1.hashCode());//734175839System.out.println(p2.hashCode());//734175839System.out.println(p1==p2);//falseSystem.out.println(p1.equals(p2));//falseset.add(p1);set.add(p2);set.add(p3);System.out.println(set);}
}

package com.wyh.Set;
import java.util.Objects;public class Person {private String name;private int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Person person = (Person) o;return age == person.age &&Objects.equals(name, person.name);}@Overridepublic int hashCode() {return Objects.hash(name, 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;}
}

5.4HashSet集合

5.4.1什么是HashSet集合？
      java.util.HashSet 是 Set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。 HashSet 是据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于： hashCode 与 equals 方法。
   5.4.2特点:
      1.不允许存储重复的元素
      2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
      3.是一个无序的集合,存储元素和取出元素的顺序有可能不一致
      4.底层是一个哈希表结构(查询的速度非常的快)
   5.4.3HashSet集合存储数据的结构（哈希表-见后文）
   5.4.4HashSet存储自定义类型元
      给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一
   补充：单列集合何时使用

六，Map集合

6.1为什么要有Map集合？

为了解决映射关系。什么是映射关系？
现实生活中，我们常会看到这样的一种集合：
IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即 java.util.Map 接口

6.2Map 接口下的集合与 Collection 接口下的集合的存储数据图？

      Collection 中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储
      Map 中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值
      Collection 中的集合称为单列集合， Map 中的集合称为双列集合
      需要注意的是， Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值

6.3Map集合的特点？

1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)
      2.Map集合中的元素,key和value的数据类型可以相同,也可以不同
      3.Map集合中的元素,key是不允许重复的,value是可以重复的
      4.Map集合中的元素,key和value是一一对应

6.4map的特性

HashMap的实例有两个影响其性能的参数：初始容量和负载因子。容量是哈希表中的桶数，初始容量只是创建哈希表时的容量。加载因子是在自动增加容量之前允许哈希表获取的完整程度的度量。当哈希表中的条目数超过加载因子和当前容量的乘积时，哈希表将被重新哈希（即，重建内部数据结构），以便哈希表具有大约两倍的桶数。
      而负载因子表示一个散列表的空间的使用程度，有这样一个公式：initailCapacity*loadFactor=HashMap的容量。
      所以负载因子越大则散列表的装填程度越高，也就是能容纳更多的元素，元素多了，链表大了，所以此时索引效率就会降低。
      反之，负载因子越小则链表中的数据量就越稀疏，此时会对空间造成烂费，但是此时索引效率高。
代码：

package com.wyh.Map;
import java.util.Objects;public class Person03 {private String name;private  int age;public Person03() {}public Person03(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Person03 person = (Person03) o;return age == person.age &&Objects.equals(name, person.name);}@Overridepublic int hashCode() {return Objects.hash(name, 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;}
}

package com.wyh.Map;
import java.util.HashMap;
import java.util.Map;/*java.util.Map<k,v>集合Map集合的特点:1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)2.Map集合中的元素,key和value的数据类型可以相同,也可以不同3.Map集合中的元素,key是不允许重复的,value是可以重复的4.Map集合中的元素,key和value是一一对应java.util.HashMap<k,v>集合 implements Map<k,v>接口HashMap集合的特点:1.HashMap集合底层是哈希表:查询的速度特别的快JDK1.8之前:数组+单向链表JDK1.8之后:数组+单向链表|红黑树(链表的长度超过8):提高查询的速度2.hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致java.util.LinkedHashMap<k,v>集合 extends HashMap<k,v>集合LinkedHashMap的特点:1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素的顺序是一致的*/
public class Demo11_Map {public static void main(String[] args) {show04();}/*boolean containsKey(Object key) 判断集合中是否包含指定的键。包含返回true,不包含返回false*/private static void show04() {//创建Map集合对象Map<String,Integer> map = new HashMap<>();map.put("赵丽颖",168);map.put("杨颖",165);map.put("林志玲",178);boolean b1 = map.containsKey("赵丽颖");System.out.println("b1:"+b1);//b1:trueboolean b2 = map.containsKey("赵颖");System.out.println("b2:"+b2);//b2:false}/*public V get(Object key) 根据指定的键，在Map集合中获取对应的值。返回值:key存在,返回对应的value值key不存在,返回null*/private static void show03() {//创建Map集合对象Map<String,Integer> map = new HashMap<>();map.put("赵丽颖",168);map.put("杨颖",165);map.put("林志玲",178);Integer v1 = map.get("杨颖");System.out.println("v1:"+v1);//v1:165Integer v2 = map.get("迪丽热巴");System.out.println("v2:"+v2);//v2:null}/*public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。返回值:Vkey存在,v返回被删除的值key不存在,v返回null*/private static void show02() {//创建Map集合对象Map<String,Integer> map = new HashMap<>();map.put("赵丽颖",168);map.put("杨颖",165);map.put("林志玲",178);System.out.println(map);//{林志玲=178, 赵丽颖=168, 杨颖=165}Integer v1 = map.remove("林志玲");System.out.println("v1:"+v1);//v1:178System.out.println(map);//{赵丽颖=168, 杨颖=165}//int v2 = map.remove("林志颖");//自动拆箱  NullPointerExceptionInteger v2 = map.remove("林志颖");System.out.println("v2:"+v2);//v2:nullSystem.out.println(map);//{赵丽颖=168, 杨颖=165}}/*public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。返回值:v存储键值对的时候,key不重复,返回值V是null存储键值对的时候,key重复,会使用新的value替换map中重复的value,返回[被替换的value值]*/private static void show01() {//创建Map集合对象,多态Map<String,String> map = new HashMap<>();String v1 = map.put("李晨", "范冰冰1");System.out.println("v1:"+v1);//v1:nullString v2 = map.put("李晨", "范冰冰2");System.out.println("v2:"+v2);//v2:范冰冰1System.out.println(map);//{李晨=范冰冰2}map.put("冷锋","龙小云");map.put("杨过","小龙女");map.put("尹志平","小龙女");System.out.println(map);//{杨过=小龙女, 尹志平=小龙女, 李晨=范冰冰2, 冷锋=龙小云}}
}

6.5使用Map集合的注意：？

Map接口中的集合都有两个泛型变量,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量的数据类型可以相同，也可以不同。

6.6Map常用子类有哪些？

HashMap：
      存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
   源码分析：

   特点：
      1.HashMap集合底层是哈希表:查询的速度特别的快
         JDK1.8之前:数组+单向链表
          JDK1.8之后:数组+单向链表|红黑树(链表的长度超过8):提高查询的速度
      2.hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致
   LinkedHashMap：
      HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的 hashCode()方法、equals()方法。
         特点：
            1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)
            2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素的顺序是一致的

6.7Map接口中的常用方法有？（Map的子类同样适用于这些方法）

public V put(K key, V value) : 把指定的键与指定的值添加到Map集合中。
   public V remove(Object key) :把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
   public V get(Object key)：根据指定的键，在Map集合中获取对应的值。
   boolean containsKey(Object key)：判断集合中是否包含指定的键。包含返回true,不包含返回false
   public Set keySet() : 获取Map集合中所有的键，存储到Set集合中。
   public Set<Map.Entry<K,V>> entrySet() :获取到Map集合中所有的键值对对象的集合(Set集合)。
代码：

 package com.wyh.Map;
import java.util.HashMap;
import java.util.Map;/*java.util.Map<k,v>集合Map集合的特点:1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)2.Map集合中的元素,key和value的数据类型可以相同,也可以不同3.Map集合中的元素,key是不允许重复的,value是可以重复的4.Map集合中的元素,key和value是一一对应java.util.HashMap<k,v>集合 implements Map<k,v>接口HashMap集合的特点:1.HashMap集合底层是哈希表:查询的速度特别的快JDK1.8之前:数组+单向链表JDK1.8之后:数组+单向链表|红黑树(链表的长度超过8):提高查询的速度2.hashMap集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致java.util.LinkedHashMap<k,v>集合 extends HashMap<k,v>集合LinkedHashMap的特点:1.LinkedHashMap集合底层是哈希表+链表(保证迭代的顺序)2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素的顺序是一致的*/
public class Demo11_Map {public static void main(String[] args) {show04();}/*boolean containsKey(Object key) 判断集合中是否包含指定的键。包含返回true,不包含返回false*/private static void show04() {//创建Map集合对象Map<String,Integer> map = new HashMap<>();map.put("赵丽颖",168);map.put("杨颖",165);map.put("林志玲",178);boolean b1 = map.containsKey("赵丽颖");System.out.println("b1:"+b1);//b1:trueboolean b2 = map.containsKey("赵颖");System.out.println("b2:"+b2);//b2:false}/*public V get(Object key) 根据指定的键，在Map集合中获取对应的值。返回值:key存在,返回对应的value值key不存在,返回null*/private static void show03() {//创建Map集合对象Map<String,Integer> map = new HashMap<>();map.put("赵丽颖",168);map.put("杨颖",165);map.put("林志玲",178);Integer v1 = map.get("杨颖");System.out.println("v1:"+v1);//v1:165Integer v2 = map.get("迪丽热巴");System.out.println("v2:"+v2);//v2:null}/*public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。返回值:Vkey存在,v返回被删除的值key不存在,v返回null*/private static void show02() {//创建Map集合对象Map<String,Integer> map = new HashMap<>();map.put("赵丽颖",168);map.put("杨颖",165);map.put("林志玲",178);System.out.println(map);//{林志玲=178, 赵丽颖=168, 杨颖=165}Integer v1 = map.remove("林志玲");System.out.println("v1:"+v1);//v1:178System.out.println(map);//{赵丽颖=168, 杨颖=165}//int v2 = map.remove("林志颖");//自动拆箱  NullPointerExceptionInteger v2 = map.remove("林志颖");System.out.println("v2:"+v2);//v2:nullSystem.out.println(map);//{赵丽颖=168, 杨颖=165}}/*public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。返回值:v存储键值对的时候,key不重复,返回值V是null存储键值对的时候,key重复,会使用新的value替换map中重复的value,返回[被替换的value值]*/private static void show01() {//创建Map集合对象,多态Map<String,String> map = new HashMap<>();String v1 = map.put("李晨", "范冰冰1");System.out.println("v1:"+v1);//v1:nullString v2 = map.put("李晨", "范冰冰2");System.out.println("v2:"+v2);//v2:范冰冰1System.out.println(map);//{李晨=范冰冰2}map.put("冷锋","龙小云");map.put("杨过","小龙女");map.put("尹志平","小龙女");System.out.println(map);//{杨过=小龙女, 尹志平=小龙女, 李晨=范冰冰2, 冷锋=龙小云}}
}

6.8Map集合各子类的区别分析？

TreeMap: 能够把它保存的记录根据key排序,默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。
   Hashtable: 与 HashMap类似,不同的是:key和value的值均不允许为null;它支持线程的同步，即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢，只有hashtable是继承自Dictionary抽象类的，hashMap和treeMap都继承自AbstractMap抽象类，LinkedHashMap继承自hashMap。
   LinkedHashMap: 保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空，非同步的。
      这就意味着:
         Hashtable是线程安全的，HashMap不是线程安全的。
         HashMap效率较高，Hashtable效率较低。
         如果对同步性或与遗留代码的兼容性没有任何要求，建议使用HashMap。
         查看Hashtable的源代码就可以发现，除构造函数外，Hashtable的所有 public 方法声明中都有 synchronized关键字，而HashMap的源码中则没有。
         Hashtable不允许null值，HashMap允许null值（key和value都允许）
         父类不同：Hashtable的父类是Dictionary，HashMap的父类是AbstractMap
   Map集合遍历键找值方式
      步骤：
         1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示: keyset()
         2. 遍历键的Set集合，得到每一个键
         3. 根据键，获取键所对应的值。方法提示: get(K key)
图解:

   Entry键值对对象
      获取对应键和对应值得方法：
         public K getKey() ：获取Entry对象中的键
         public V getValue() ：获取Entry对象中的值
      Map集合中也提供了获取所有Entry对象的方法：
         public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)
   Map集合遍历键值对方式
      键值对方式：
         即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值
      操作步骤：
         1. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示: entrySet()
         2. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象
         3. 通过键值对(Entry)对象，获取Entry对象中的键与值。方法提示: getkey() getValue()
      注意：
         Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

七，其他：

7.1Iterator迭代器：

为什么要有Iterator迭代器？Iterator迭代器是什么？
      在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作。
   Iterator接口的常用方法有？
      public Iterator iterator()`: 获取集合对应的迭代器，用来遍历集合中的元素的。

public E next()`:返回迭代的下一个元素。

public boolean hasNext()`:如果仍有元素可以迭代，则返回 true。
   Iterator迭代器的使用步骤？
      1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
       2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
       3.使用Iterator接口中的方法next取出集合中的下一个元素
   迭代器的实现原理是什么？
   我们在之前案例已经完成了Iterator遍历集合的整个过程。当遍历集合时，首先通过调用t集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。
   Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，为了让初学者能更好地理解迭代器的工作原理，接下来通过一个图例来演示Iterator对象迭代元素的过程：

   在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。
代码：

package com.wyh;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.ListIterator;/*java.util.Iterator接口:迭代器(对集合进行遍历)有两个常用的方法boolean hasNext() 如果仍有元素可以迭代，则返回 true。判断集合中还有没有下一个元素,有就返回true,没有就返回falseE next() 返回迭代的下一个元素。取出集合中的下一个元素Iterator迭代器,是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。迭代器的使用步骤(重点):1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)2.使用Iterator接口中的方法hasNext判断还有没有下一个元素3.使用Iterator接口中的方法next取出集合中的下一个元素*/
public class Demo04_Iterator {public static void main(String[] args) {//创建一个集合对象Collection<String> coll = new ArrayList<>();//往集合中添加元素coll.add("姚明");coll.add("科比");coll.add("麦迪");coll.add("詹姆斯");coll.add("艾弗森");/*1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)注意:Iterator<E>接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型*/Iterator<String> it = coll.iterator();/*发现使用迭代器取出集合中元素的代码,是一个重复的过程所以我们可以使用循环优化不知道集合中有多少元素,使用while循环循环结束的条件,hasNext方法返回false*/while(it.hasNext()){String e = it.next();System.out.println(e);}System.out.println(coll.size()); //打印长度System.out.println("----------------------");ListIterator<String> it01 = ((ArrayList<String>) coll).listIterator();it01.add("帅哥"); // 添加// ListIterator里：next()是箭头往下走，pervious()是箭头往上走。it01.next();it01.set("易建联"); //修改while(it01.hasNext()){String e = it01.next();System.out.println(e);/*输出结果为科比，麦迪，詹姆斯，艾弗森*原因：（把存储模拟成栈）添加帅哥是在最顶上添加。修改则是修改下一位姚明。*此时循环hasNext()往下走，以科比开始走到最后*/}System.out.println(it01.previous()); //这里联系一下栈就可以知道循环。结束后指针指向了最后数据的下一个坐标it01.previous();it01.previous();it01.previous();it01.previous();it01.previous();System.out.println("----------------------");while(it01.hasNext()){String a = it01.next();System.out.println(a);}}
}

7.2增强for

是什么？
      增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
   格式如何？
      for(元素的数据类型变量 : Collection集合or数组){
       //写操作代码
       }
   用来做什么？
      它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。
   注意：
      新for循环必须有被遍历的目标。目标只能是Collection或者是数组。新式for仅仅作为遍历操作出现。
代码：

package com.wyh;
import java.util.ArrayList;/*增强for循环:底层使用的也是迭代器,使用for循环的格式,简化了迭代器的书写是JDK1.5之后出现的新特性Collection<E>extends Iterable<E>:所有的单列集合都可以使用增强forpublic interface Iterable<T>实现这个接口允许对象成为 "foreach" 语句的目标。增强for循环:用来遍历集合和数组格式:for(集合/数组的数据类型 变量名: 集合名/数组名){sout(变量名);}*/
public class Demo05_Foreachjava {public static void main(String[] args) {demo01();}//使用增强for循环遍历集合private static void demo02() {ArrayList<String> list = new ArrayList<>();list.add("aaa");list.add("bbb");list.add("ccc");list.add("ddd");for(String s : list){System.out.println(s);}}//使用增强for循环遍历数组private static void demo01() {int[] arr = {1,2,3,4,5};for (int i = 1; i <= arr.length; i++) {System.out.println(i);}System.out.println("--------------");for(int i:arr){System.out.println(i);}}
}

7.3Comparable接口

什么是Comparable接口?
      此接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序，类的 compareTo方法被称为它的自然比较方法。
   实现什么方法?
   int compareTo(T o)
       比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
      参数：o - 要比较的对象。
      返回：负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。
       抛出：ClassCastException - 如果指定对象的类型不允许它与此对象进行比较。
   Comparator接口
      Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足要求时，可写一个比较器来完成两个对象之间大小的较。Comparator体现了一种策略模式(strategy design pattern)，就是不改变对象自身，而用一个策略对象(strategy object)来改变它的行为。
      与上面的Comparable接口不同的是：
         （ 1）、Comparator位于包java.util下，而Comparable位于包java.lang下。
         （2）、Comparable接口将比较代码嵌入需要进行比较的类的自身代码中，而Comparator接口在一个独立的类中实现比较。
         （ 3）、如果前期类的设计没有考虑到类的Compare问题而没有实现Comparable接口，后期可以通过Comparator接口来实现比较算法进行排序，并且为了使用不同的排序标准做准备，比如：升序、降序。
         （ 4）、Comparable接口强制进行自然排序，而Comparator接口不强制进行自然排序，可以指定排序顺序。
代码：

package com.wyh.Set;import java.util.TreeSet;/*** @Deacription Comparable比较方法* @Author 王宇辉* @Date 2021/9/2 9:13* @Version 1.0**/
public class Demo09_Comparable {public static void main(String[] args) {TreeSet<Person> data = new TreeSet<>();Person p1 = new Person("张三",18);Person p2 = new Person("李四",19);data.add(p1);data.add(p2);for (Person p:data){System.out.println(p);}}public static class Person implements Comparable<Person> {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}/*** 实现Comparable接口，在类的内部实现比较o逻辑，通过覆盖compareTo方法，如此一来，自定义的两个类可以比较大小* 将自定义的类放在集合类中，可以使用Collections的sort来自然排序，不用提供比较器。自然排序的实现即compareTo方法*/@Overridepublic int compareTo(Person o) {if(this.age > o.getAge()) {return 1;}else if(this.age < o.getAge()) {return -1;}else{return 0;}}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;}public String toString() {return "[ name：" + name + ", age：" + age + " ]";}}
}

package com.wyh.Set;import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;/*** @Deacription Comparator比较方法* @Author 王宇辉* @Date 2021/9/2 9:29* @Version 1.0**/
public class Demo10_Comparator {public static void main(String[] args) {List<Cat> list = new ArrayList<Cat>();list.add(new Cat("xiaohong", 12));list.add(new Cat("xiaohua", 32));list.add(new Cat("dahua", 33));list.add(new Cat("dahuang", 45));list.add(new Cat("dahua", 7));list.add(new Cat("xiaohong", 45));list.add(new Cat("xiaohei", 22));System.out.println("初始列表：");for(Cat cat : list) {System.out.print(cat + "\t");}System.out.println();System.out.println("排序后：");Collections.sort(list, new CatComparator());for(Cat cat : list) {System.out.print(cat + "\t");}}public static class CatComparator implements Comparator<Cat> {/*** 实现Comparator接口，在类的外部实现比较逻辑，通过覆盖compare方法，* 将自定义的类放在集合类中，使用Collections的sort来排序时，需要提供集合类本身，以及该比较器。*/@Overridepublic int compare(Cat cat1, Cat cat2) {return cat1.getAge() - cat2.getAge(); //按照年龄排序：}}public static class Cat{private String name;private int age;public Cat(String name, int age) {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;}public String toString() {return "[ name：" + name + ", age：" + age + " ]";}}}

7.4哈希表

散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
   结构
       哈希表的结构可以使用数组+链表实现，也可以使用数组+二叉树来实现，这里我们就使用数组+链表来实现。这样一个哈希表的结构如下：

           我们可以看到，哈希表其实就是一个存放着链表的数组构成的，可以理解为就是一个数组，而这个数组中的元素又是一个链表。
   注意：
       当链表长度超过阈值（8）时，将链表转换为红黑树
       链表长度小于阈值（6）时，将红黑树转换为链表

7.5 JDK9的集合新特性（省略）

在JDK9版本中加入的快速向List、Map、Set内添加固定长度内容的方法。
代码：

package com.wyh;import java.util.List;
import java.util.Map;
import java.util.Set;/*** @Deacription Jdk9新特性* @Author 王宇辉* @Date 2021/9/2 16:22* @Version 1.0**/
public class DEmo13_Jdk9 {public static void main(String[] args) {/*List<String> list = List.of("黑", "白");for (String s:list) {System.out.print(s+" ");}*//* Set<String> set = Set.of("黑", "白");for (String s:set) {System.out.print(s+" ");}*/Map<String,String> set = Map.of("黑", "白");Set<String> set1 = set.keySet();for (String s:set1) {System.out.println(s+" "+set.get(s));}}
}

八，综合练习

有点多，不列了。直接看资料吧

参考：距离记笔记的时候过了一段时间，如果我的笔记有明显借鉴了您的内容，请见谅。（我记忆力很差的，当初写笔记的时候，参考文档记录的可能不全）
哈希表可参考：
https://blog.csdn.net/pre_tender/article/details/102505531
https://blog.csdn.net/qq_41230365/article/details/81058217
如果遇到了UnsupportedOperationException问题
参考：https://blog.csdn.net/qq_39416311/article/details/83688591
资料下载链接（笔记+代码+其他）：百度网盘
链接：https://pan.baidu.com/s/16Ois0qEmbTx15zf4SS3tyw
提取码：1111
感谢阅读，祝你从此一帆风顺。