1 - 概述
所有的集合类和集合接口都在java.util包下。
在内存中申请一块空间用来存储数据，在Java中集合就是替换掉定长的数组的一种引用数据类型。
2 - 集合与数组的区别
长度区别
数组长度固定，定义长了造成内存空间的浪费，定义短了不够用。
集合大小可以变，用多少空间拿多少空间。
内容区别
数组可以存储基本数据类型和引用数据类型
集合中能存储引用数据类型（存储的为对象的内存地址）
list.add(100);//为自动装箱，100为Integer包装的
元素区别
数组中只能存储同一种类型成员
集合中可以存储不同类型数据（一般情况下也只存储同一种类型的数据）
集合结构
在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中
存储元素，等于将数据放到了不同的数据结构当中。什么是数据结构？数据存储的
结构就是数据结构。不同的数据结构，数据存储方式不同。
单列集合 Collection
List可以重复：ArrayList/LinkedList
Set不可重复：HashSet/TreeSet
（大量文字插入会导致图片不清，所以在此进行更详细的描述）
List特点：此处顺序并不是大小顺序，而是存入数据的先后顺序。有序因为List集合都有下标，下标从0开始，以递增。
Set特点：取出顺序不一定为存入顺序，另外Set集合没有下标。
ArrayList是非线程安全的。
HashSet集合在new的时候，底层实际上new了一个HashMap集合。向HashSet集合中存储元素，实际上是存储到了HashMap的key中了。HashMap集合是一个Hash表数据结构。
SortedSet集合存储元素的特点：由于继承了Set集合，所以他的特点也是无序不可重复，但是放在SortedSet集合中的元素可以自动排序。放到该集合中的元素是自动按照大小顺序排序的。
TreeSet集合底层实际上是TreeMap。TreeSet集合在new的时候，底层实际上new了一个TreeMap集合。向TreeSet集合中存储元素，实际上是存储到了TreeMap的key中了。TreeMap集合是一个二叉树数据结构。
双列集合Map:HashMap/TreeMap
粗体是接口 斜体是实现类
3 - Collection集合
3.1 - 概述
单列集合的顶层接口，既然是接口就不能直接使用，需要通过实现类！~
3.2 - Collection集合的的常用方法
| 方法名 | 说明 |
|---|---|
boolean add(E e) | 添加元素到集合的末尾（追加） |
boolean remove(Object o) | 删除指定的元素，成功则返回true（底层调用equles） |
void clear() | 清空集合 |
boolean contains(Object o) | 判断元素在集合中是否存在，存在则返回true（底层调用equles） |
boolean isEmpty() | 判断集合是否为空，空则返回true |
int size() | 返回集合中元素个数 |
import java.util.ArrayList;import java.util.Collection;/** * @author Mr.乐 * @Description */public class Collection_01 { public static void main(String[] args) { //父类的引用指向子类的对象，形成多态 Collection<String> con = new ArrayList<>(); //追加的方式添加元素 con.add("东邪"); con.add("西毒"); con.add("南帝"); con.add("北丐"); con.add("中神通"); //删除,通过元素名称删除元素 System.out.println(con.remove("西毒")); //判断集合中是否包含指定参数元素 System.out.println(con.contains("西毒")); //false System.out.println(con.contains("东邪")); //true //获取集合中元素个数 System.out.println(con.size()); //判断是否为空 System.out.println(con.isEmpty());//false //清空集合 con.clear(); //判断是否为空 System.out.println(con.isEmpty());//true System.out.println(con);//打印集合的元素 }}3.3 - Collection集合的遍历
以下迭代方式，是所有Collection通用的一种方式。在Map集合中不能使用，在所有的Collection以及子类中使用。
import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;/** * @author Mr.乐 * @Description Collection 集合的遍历 */public class Connection_02 { public static void main(String[] args) { //多态 Collection<String> con = new ArrayList<>(); //添加元素 con.add("abc"); con.add("def"); con.add("100"); con.add("444"); //Collection集合的遍历方式 //因为没有索引的概念，所以Collection集合不能使用fori进行遍历 //增强版for循环，其实底层使用的也是迭代器，在字节码文件中查看 for (String str : con) { System.out.print(str + "\t"); } System.out.println();//换行 //迭代器，集合专属的遍历工具 Iterator<String> it = con.iterator();//创建迭代器对象 while (it.hasNext()){//判断下一个位置是否有元素 System.out.print(it.next() + "\t");//获取到下一个位置的元素 } }}3.4 - Iterator的remove
import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;/** * @author Mr.乐 * @Description */public class Connection_remove { public static void main(String[] args) { // 创建集合 Collection c = new ArrayList(); // 注意：此时获取的迭代器，指向的是那是集合中没有元素状态下的迭代器。 // 一定要注意：集合结构只要发生改变，迭代器必须重新获取。 // 当集合结构发生了改变，迭代器没有重新获取时，调用next()方法时：java.util.ConcurrentModificationException Iterator it = c.iterator(); // 添加元素 c.add(1); // Integer类型 c.add(2); c.add(3); // 获取迭代器 //Iterator it = c.iterator(); /*while(it.hasNext()){ // 编写代码时next()方法返回值类型必须是Object。 // Integer i = it.next(); Object obj = it.next(); System.out.println(obj); }*/ Collection c2 = new ArrayList(); c2.add("abc"); c2.add("def"); c2.add("xyz"); Iterator it2 = c2.iterator(); while(it2.hasNext()){ Object o = it2.next(); // 删除元素 // 删除元素之后，集合的结构发生了变化，应该重新去获取迭代器 // 但是，循环下一次的时候并没有重新获取迭代器，所以会出现异常：java.util.ConcurrentModificationException // 出异常根本原因是：集合中元素删除了，但是没有更新迭代器（迭代器不知道集合变化了） //c2.remove(o); // 直接通过集合去删除元素，没有通知迭代器。（导致迭代器的快照和原集合状态不同。） // 使用迭代器来删除可以吗？ // 迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）。 it2.remove(); // 删除的一定是迭代器指向的当前元素。 System.out.println(o); } System.out.println(c2.size()); //0 }}4 -List
原型ArrayList<E>
ArrayList是一个List接口的实现类，底层使用的是一个可以调整大小的数组实现的。
<E>:是一种特殊的数据类型（引用数据类型） -- 泛型
ArrayList<String> 或者 ArrayList<Integer> 或者 ArrayList<Student>
4.1 - ArrayList构造和添加方法
| 方法名 | 说明 |
|---|---|
public ArrayList<E>() | 创建一个空集合 |
public boolean add(E e) | 将指定的参数元素追加到集合的末尾 |
public void add(int index ,E e) | 在集合的指定位置添加指定的元素（插入元素） |
public void addAll(E object) | 用于将指定集合中所有元素添加到当前集合中 |
/** * @author Mr.乐 * @Description ArrayList构造和添加方法 */public class ArrayList_01 { public static void main(String[] args) { //创建空集合 ArrayList<String> list = new ArrayList<>();//泛型定义为String //采用默认追加的方式添加元素 System.out.println(list.add("刘德华")); System.out.println(list.add("张学友")); System.out.println(list.add("郭富城")); System.out.println(list.add("黎明")); //插入的方式添加元素// list.add(10,"谭咏麟");//插入元素方法索引值不能大于集合中元素个数// list.add(4,"谭咏麟");//表示在集合中最后位置插入元素，与追加相同 list.add(1,"谭咏麟");//指定位置插入元素，索引位置之后的元素会自动向后进行移动 ArrayList<String> newList = new ArrayList<>();//创建新的集合 newList.add("小沈阳"); newList.add("宋小宝"); newList.add("赵四"); newList.add("刘能"); //查看集合中的元素 System.out.println("原集合内部元素：" + list); System.out.println("新集合内部元素：" + newList); list.addAll(newList); //将新集合全部元素添加到原集合中 System.out.println("原集合内部元素：" + list); }}4.2 - ArrayList集合常用方法
| 方法名 | 说明 |
|---|---|
public boolean remove(Object o) | 删除指定的元素，成功则返回true |
public E remove(int index) | 删除指定索引位置的元素，返回被删除的元素 |
public E set(int index,E e) | 修改指定索引位置的元素，返回修改前的元素 |
public E get(int index) | 获取指定索引对应的元素 |
public int size() | 获取结合中元素个数 |
import java.util.ArrayList;import java.util.Iterator;/** * @author Mr.乐 * @Description ArrayList集合常用方法 */public class ArrayList_02 { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); //追加方式添加元素 list.add("东邪"); list.add("西毒"); list.add("南帝"); list.add("北丐"); list.add("中神通"); //删除 System.out.println(list.remove("西毒"));//通过元素名称删除，返回boolean System.out.println(list.remove(1));//通过索引删除元素，返回被删除元素名 //修改 System.out.println(list.set(1,"西毒"));//指定索引位置修改元素，并返回被修改元素 System.out.println("原集合中元素有：" + list); //获取方法 System.out.println(list.get(1));//通过指定索引位置获取集合元素 //获取集合元素个数 System.out.println(list.size()); //集合的遍历,普通for循环 for (int i = 0; i < list.size(); i++) { System.out.print(list.get(i) + "\t"); } System.out.println(); //增强版for循环 for (String name : list) { System.out.print(name+ "\t"); } System.out.println(); //迭代器 Iterator<String> it = list.iterator();//创建迭代器 while (it.hasNext()){//判断下一个位置是否有元素 System.out.print(it.next() + "\t"); //next方法表示获取下一个位置的元素 } System.out.println(); //Stream流 list.stream().forEach(System.out::println); }}4.3 -ArrayList实现原理
底层代码：
属性：
DEFAULT_CAPACITY = 10 默认长度，初始化容量为10Object[] EMPTY_ELEMENTDATA = {} //有参构造所创建Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {} //无参构造所创建的Object[] elementData;底层为Object类型的数组，存储的元素都在此。int size 实际存放的个数 构造方法 ：
//一个参数的构造public ArrayList(int initialCapacity) { if (initialCapacity > 0) { this.elementData = new Object[initialCapacity]; } else if (initialCapacity == 0) { this.elementData = EMPTY_ELEMENTDATA; } else { throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); } }//参数如果大于零，则为创建数组的长度；//参数如果等于零，EMPTY_ELEMENTDATA；//参数如果小于0，抛出异常。//无参构造 public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }//DEFAULTCAPACITY_EMPTY_ELEMENTDATA new对象时默认为0 当添加第一个元素的时候，数组扩容至10add方法源码：（jdk1.8与之不同，此处为jdk16）
//源码public boolean add(E e) { modCount++;//操作次数 add(e, elementData, size);//e 操作对象; elementData 底层操作的数组;size 默认大小0 return true; }------------------------------------------------ private void add(E e, Object[] elementData, int s) { if (s == elementData.length)//ture elementData = grow(); elementData[s] = e; //存数据 size = s + 1; //最小需要长度 }---------------------------------------------------------- private Object[] grow() { return grow(size + 1); }----------------------------------------------------- private Object[] grow(int minCapacity) { //初始传入为size+1 为1 int oldCapacity = elementData.length; //初始为0 if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //if条件为初始数组长度>0或者数组不是无参构造构建的 int newCapacity = ArraysSupport.newLength(oldCapacity, //旧数组的长度 minCapacity - oldCapacity, /* minimum growth */ //最小需要长度-旧数组的长度 大于0代表空间不足 oldCapacity >> 1 /* preferred growth */); //二进制位右移1位 位旧数组长度/2 return elementData = Arrays.copyOf(elementData, newCapacity); 将数据放入新数组中 } else { return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)]; //数组长度 DEFAULT_CAPACITY为10 此处代表无参构造默认长度为10 } }---------------------------------------------------- public static int newLength(int oldLength, int minGrowth, int prefGrowth) { // assert oldLength >= 0 // assert minGrowth > 0 int newLength = Math.max(minGrowth, prefGrowth) + oldLength; //如果prefGrowth>minGrowth 扩容1.5倍 minGrowth>prefGrowth为需要多少给多少 if (newLength - MAX_ARRAY_LENGTH <= 0) { //MAX_ARRAY_LENGTH为int最大值 表示新数组长度如果小于int的最大值 return newLength; } return hugeLength(oldLength, minGrowth); //返回int最大值 }ArrayList集合底层是数组，怎么优化？ 尽可能少的扩容。因为数组扩容效率比较低，建议在使用ArrayList集合 的时候预估计元素的个数，给定一个初始化容量。数组优点： 检索效率比较高。（每个元素占用空间大小相同，内存地址是连续的，知道首元素内存地址， 然后知道下标，通过数学表达式计算出元素的内存地址，所以检索效率最高。）数组缺点： 随机增删元素效率比较低。 另外数组无法存储大数据量。（很难找到一块非常巨大的连续的内存空间。）向数组末尾添加元素，效率很高，不受影响。
4.4 -LinkedList实现原理
底层代码
属性：
transient int size = 0;//初始长度 transient Node<E> first;//头节点 transient Node<E> last;//尾节点add方法源码：（jdk1.8与之不同，此处为jdk16）
public boolean add(E e) { linkLast(e); return true; }--------------------------------------void linkLast(E e) { final Node<E> l = last; //初始为null final Node<E> newNode = new Node<>(l, e, null); //参数1：位上一个节点的内存地址,参数2：e为插入的数据,参数3：下一个节点的内存地址 last = newNode; // 最后节点为新节点 if (l == null) //如果newNode的前一个节点为null,则将新节点赋给first first = newNode; else l.next = newNode; //尾节点下一个节点为新节点 size++;//大小 modCount++;//操作数 }4.5 -LinkedList和ArrayList
LinkedList和ArrayList方法一样，只是底层实现不一样。ArrayList底层为数组存储，LinkedList是以双向链表存储。LinkedList集合没有初始化容量。最初这个链表中没有任何元素。first和last引用都是null。
链表的优点： 由于链表上的元素在空间存储上内存地址不连续。 所以随机增删元素的时候不会有大量元素位移，因此随机增删效率较高。 在以后的开发中，如果遇到随机增删集合中元素的业务比较多时，建议 使用LinkedList。链表的缺点： 不能通过数学表达式计算被查找元素的内存地址，每一次查找都是从头 节点开始遍历，直到找到为止。所以LinkedList集合检索/查找的效率 较低。 ArrayList：把检索发挥到极致。（末尾添加元素效率还是很高的。） LinkedList：把随机增删发挥到极致。 加元素都是往末尾添加，所以ArrayList用的比LinkedList多。
4.6 -Vector
1、底层也是一个数组。2、初始化容量：103、怎么扩容的？ 扩容之后是原容量的2倍。 10--> 20 --> 40 --> 804、Vector中所有的方法都是线程同步的，都带有synchronized关键字，是线程安全的。效率比较低，使用较少了。5、怎么将一个线程不安全的ArrayList集合转换成线程安全的呢？ 使用集合工具类： java.util.Collections; java.util.Collection 是集合接口。 java.util.Collections 是集合工具类。Collections.synchronizedList();//将及格转换为线程安全的。
5 -Set
5.1 -概述
Set集合也是一个接口，继承自Collection，与List类似，都需要通过实现类来进行操作。
特点
不允许包含重复的值
没有索引（就不能使用普通的for循环进行遍历）
import java.util.HashSet;import java.util.Set;/** * @author Mr.乐 * @Description Set集合 */public class Demo01 { public static void main(String[] args) { //使用多态，父类的引用指向子类对象 Set<String> set = new HashSet<>(); //添加元素 set.add("黄固"); set.add("欧阳锋"); set.add("段智兴"); set.add("洪七公"); set.add("段智兴"); System.out.println(set);//打印集合 //[洪七公, 黄固, 欧阳锋, 段智兴] //HashSet集合对于元素的读写顺序不做保证 //相同的元素，多次存储，只能保留一个，并且不会报错 //List集合可以存储重复元素，Set集合不行 }}例：双色球
import java.util.Random;import java.util.TreeSet;/** * @author Mr.乐 * @Description 双色球 -Set版 */public class Demo02 { public static void main(String[] args) { Random ran = new Random();//创建随机类对象 int blueBall = ran.nextInt(16) + 1;// HashSet<Integer> redBalls = new HashSet<>();//创建集合用来存储红球 TreeSet<Object> redBalls = new TreeSet<>();//TreeSet集合自带排序规则 while (redBalls.size() < 6){ redBalls.add(ran.nextInt(33) + 1);//将当前生成的红球直接存进集合中 //因为Set集合不能存储重复的元素，所以去重的操作可以省略不做。 } System.out.println("红球：" + redBalls + "篮球 [" + blueBall + "]"); }}5.2 -哈希值
Set集合的去重原理使用的是哈希值。
哈希值就是JDK根据对象地址 或者 字符串 或者数值 通过自己内部的计算出来的一个整数类型数据
public int hashCode() - 用来获取哈希值，来自于Object顶层类
对象的哈希值特点
同一个对象多次调用hashCode()方法，得到的结果是相同的。
默认情况下，不同的对象的哈希值也是不同的（特殊情况除外）
/** * @author Mr.乐 * @Description 哈希值 */public class Demo03 { public static void main(String[] args) { //相同对象哈希值相同 System.out.println("张三".hashCode());//774889 System.out.println("张三".hashCode());//774889 //不同对象哈希值不同 System.out.println(new Object().hashCode()); System.out.println(new Object().hashCode()); //不同的对象的哈希值也有可能相同，例外情况 System.out.println("辂鹅".hashCode());//1179395 System.out.println("较鸦".hashCode());//1179395 System.out.println("辄鸇".hashCode());//1179395 System.out.println("辅鷨".hashCode());//1179395 }}5.3 -HashSet去重原理
HashSet集合的特点
底层结构是“哈希表”
集合对于读写顺序不做保证
没有索引
Set集合中的内容不能重复
/** * @author Mr.乐 * @Description HashSet去重原理 */public class Demo04 { public static void main(String[] args) { HashSet<Student> set = new HashSet<>(); //添加元素 set.add(new Student("黄固",28)); set.add(new Student("欧阳锋",38)); set.add(new Student("段智兴",48)); set.add(new Student("洪七公",40)); set.add(new Student("段智兴",48)); //从程序的角度来考虑，两个段智兴不是同一个对象，都有自己的存储空间，所以哈希值也不一样。 for (Student stu : set) { System.out.println(stu); } /* 重写hashcode和equals Student{name='段智兴', age=48} Student{name='欧阳锋', age=38} Student{name='洪七公', age=40} Student{name='黄固', age=28} */ }}5.4 -LinkedHashSet
特点
LinkedHashSet是哈希表和链表实现的Set接口，具有可预测的读写顺序。
有链表来保证元素有序
有哈希表来保证元素的唯一性
/** * @author Mr.乐 * @Description LinkedHashSet */public class Demo05 { public static void main(String[] args) { LinkedHashSet<String> set = new LinkedHashSet<>(); //添加元素 set.add("黄固"); set.add("欧阳锋"); set.add("段智兴"); set.add("洪七公"); set.add("段智兴");//重复的元素不能存进去 System.out.println(set);//打印集合 [黄固, 欧阳锋, 段智兴, 洪七公] }}5.5 -TreeSet
1、TreeSet集合底层实际上是一个TreeMap
2、TreeMap集合底层是一个二叉树。
3、放到TreeSet集合中的元素，等同于放到TreeMap集合key部分了。
4、TreeSet集合中的元素：无序不可重复，但是可以按照元素的大小顺序自动排序。
import java.util.TreeSet;public class TreeSetTest02 { public static void main(String[] args) { // 创建一个TreeSet集合 TreeSet<String> ts = new TreeSet<>(); // 添加String ts.add("zhangsan"); ts.add("lisi"); ts.add("wangwu"); ts.add("zhangsi"); ts.add("wangliu"); // 遍历 for(String s : ts){ // 按照字典顺序，升序！ System.out.println(s); } /* lisi wangliu wangwu zhangsan zhangsi */ TreeSet<Integer> ts2 = new TreeSet<>(); ts2.add(100); ts2.add(200); ts2.add(900); ts2.add(800); ts2.add(600); ts2.add(10); for(Integer elt : ts2){ // 升序！ System.out.println(elt); } }}5.5.1 -自定义排序规则
对于自定义的类无法排序，因为类中对象之间没有比较规则，不知道谁大谁小。
/** * @author Mr.乐 * @Description 自定义比较器 */import java.util.TreeSet;public class TreeSetTest04 { public static void main(String[] args) { Customer c1 = new Customer(32); Customer c2 = new Customer(20); Customer c3 = new Customer(30); Customer c4 = new Customer(25); // 创建TreeSet集合 TreeSet<Customer> customers = new TreeSet<>(); // 添加元素 customers.add(c1); customers.add(c2); customers.add(c3); customers.add(c4); // 遍历 for (Customer c : customers){ System.out.println(c); } }}// 放在TreeSet集合中的元素需要实现java.lang.Comparable接口。// 并且实现compareTo方法。equals可以不写。class Customer implements Comparable<Customer>{ int age; public Customer(int age){ this.age = age; } // 需要在这个方法中编写比较的逻辑，或者说比较的规则，按照什么进行比较！ // k.compareTo(t.key) // 拿着参数k和集合中的每一个k进行比较，返回值可能是>0 <0 =0 // 比较规则最终还是由程序员指定的：例如按照年龄升序。或者按照年龄降序。 @Override public int compareTo(Customer c) { // c1.compareTo(c2); return c.age - this.age; } public String toString(){ return "Customer[age="+age+"]"; }}匿名内部类方式
public class TreeSetTest05 { public static void main(String[] args) {// TreeSet<Student> ts = new TreeSet<>();//默认排序规则 TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() { @Override public int compare(Student o1, Student o2) { int res = o1.getAge() - o2.getAge(); return 0 == res ? o1.getName().compareTo(o2.getName()) : res; //三目运算符 等于零用姓名排序 } });//默认排序规则 //添加元素 ts.add(new Student("Andy",19)); ts.add(new Student("Jack",18)); ts.add(new Student("Tom",21)); ts.add(new Student("Lucy",17)); ts.add(new Student("Bob",21)); //当年龄相同时，按照姓名的字典顺序排序 for (Student stu : ts) { System.out.println(stu); } }}Comparable和Comparator怎么选择呢？ 当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口。 如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口。
6 -Map
6.1 -概述
双列集合：用来存储键值对的集合。
interface Map<K,V> : K(key)键 ，V(value)值
将键映射到值的对象，不能出现重复的键，每个键最多可以映射到一个值
1、Map和Collection没有继承关系。2、Map集合以key和value的方式存储数据：键值对 key和value都是引用数据类型。 key和value都是存储对象的内存地址。 key起到主导的地位，value是key的一个附属品。
例子：
| 学号（Key） | 姓名(Value) |
|---|---|
| STU001 | 张三 |
| STU002 | 李四 |
| STU003 | 张三 |
6.2 -Map的基本方法
| 方法名 | 说明 |
|---|---|
V put(K key,V value) | 设置键值对 |
V remove(Object key) | 删除元素 |
void clear() | 清空集合 |
boolean containsKey(Object key) | 判断键是否存在，存在则返回true |
boolean containsValue(Object value) | 判断值是否存在，存在则返回true |
boolean isEmpty() | 判断集合是否为空 |
int size() | 获取集合元素个数 |
import java.util.HashMap;import java.util.Map;/** * @author Mr.乐 * @Description 集合的基本方法 */public class Map01 { public static void main(String[] args) { Map<String,String> map = new HashMap<>(); map.put("STU001","Andy"); map.put("STU002","Jack"); map.put("STU003","Tom"); map.put("STU004","Bob"); map.put("STU004","Smith");//设置（修改） //如果键不存在，则表示添加元素。如果键存在，则表示设置值。 //删除 System.out.println(map.remove("STU003")); //Tom //判断是否包含 System.out.println(map.containsKey("STU003")); //false System.out.println(map.containsKey("STU004")); //true System.out.println("-----------------------"); System.out.println(map.containsValue("Tom")); //false System.out.println(map.containsValue("Smith")); //true System.out.println("-----------------------"); System.out.println(map.isEmpty());//判断集合是否为空 false map.clear();//清空集合 System.out.println(map.isEmpty()); //true System.out.println(map); //{} }}6.3 -Map集合的获取功能
import java.util.Collection;import java.util.HashMap;import java.util.Map;import java.util.Set;/** * @author Mr.乐 * @Description */public class map_get { public static void main(String[] args) { Map<String,String> map = new HashMap<>(); map.put("STU001","Andy"); map.put("STU002","Jack"); map.put("STU003","Tom"); map.put("STU004","Bob"); //get通过键获取值 System.out.println(map.get("STU003")); System.out.println("------------------"); //keySet 获取所有键的Set集合 Set<String> keySet = map.keySet(); System.out.println(keySet); //values 获取所有值的Collection集合 Collection<String> values = map.values(); System.out.println(values); //entrySet 获取所有键值对对象的Set集合 Set<Map.Entry<String, String>> es = map.entrySet(); //Map集合通过entrySet()方法转换成的这个Set集合，Set集合中元素的类型是 Map.Entry<K,V> //Map.Entry和String一样，都是一种类型的名字，只不过：Map.Entry是静态内部类，是Map中的静态内部类 System.out.println(es); //[STU001=Andy, STU003=Tom, STU002=Jack, STU004=Bob] for (Map.Entry<String, String> entry:es){ System.out.println("key:"+entry.getKey()+" "+"value:"+entry.getValue()); } /* key:STU001 value:Andy key:STU003 value:Tom key:STU002 value:Jack key:STU004 value:Bob */ }}6.4 -哈希表
通过 数组 + 链表 实现的一种数据结构
哈希表的构造方法的参数是一个长度为16个元素的数组，通过哈希值 % 16 的值，作为头节点在数组中选择对应的位置，就形成了哈希表。
注：图转自动力节点。
6.5 -HashMap
6.5.1 -底层源码
public class HashMap{ // HashMap底层实际上就是一个数组。（一维数组） Node<K,V>[] table; // 静态的内部类HashMap.Node static class Node<K,V> { final int hash; // 哈希值（哈希值是key的hashCode()方法的执行结果。hash值通过哈希函数/算法，可以转换存储成数组的下标。） final K key; // 存储到Map集合中的那个key V value; // 存储到Map集合中的那个value Node<K,V> next; // 下一个节点的内存地址。 } }6.5.2 -特点
1、无序，不可重复。 为什么无序？ 因为不一定挂到哪个单向链表上。 不可重复是怎么保证的？ equals方法来保证HashMap集合的key不可重复。 如果key重复了，value会覆盖。2、放在HashMap集合key部分的元素其实就是放到HashSet集合中了。 所以HashSet集合中的元素也需要同时重写hashCode()+equals()方法。
3、HashMap集合的默认初始化容量是16，默认加载因子是0.75 这个默认加载因子是当HashMap集合底层数组的容量达到75%的时候，数组以二叉树开始扩容。 重点，记住：HashMap集合初始化容量必须是2的倍数，这也是官方推荐的， 这是因为达到散列均匀，为了提高HashMap集合的存取效率，所必须的。
6.5.3 -注意
1.向Map集合中存，以及从Map集合中取，都是先调用key的hashCode方法，然后再调用equals方法！
equals方法有可能调用，也有可能不调用。
拿put(k,v)举例，什么时候equals不会调用？ k.hashCode()方法返回哈希值， 哈希值经过哈希算法转换成数组下标。 数组下标位置上如果是null，equals不需要执行。 拿get(k)举例，什么时候equals不会调用？ k.hashCode()方法返回哈希值， 哈希值经过哈希算法转换成数组下标。 数组下标位置上如果是null，equals不需要执行。
4.假设将所有的hashCode()方法返回值固定为某个值，那么会导致底层哈希表变成了 纯单向链表。
这种情况我们成为：散列分布不均匀。
什么是散列分布均匀？
假设有100个元素，10个单向链表，那么每个单向链表上有10个节点，这是最好的， 是散列分布均匀的。假设将所有的hashCode()方法返回值都设定为不一样的值，可以吗，有什么问题？ 不行，因为这样的话导致底层哈希表就成为一维数组了，没有链表的概念了。 也是散列分布不均匀。散列分布均匀需要你重写hashCode()方法时有一定的技巧。
7 -Properties
Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型。 Properties被称为属性类对象。 Properties是线程安全的。
7.1 -方法
import java.io.IOException;import java.util.Properties;import java.util.Set;/** * @author Mr.乐 * @Description Properties特有方法 */public class Properties01 { public static void main(String[] args) throws IOException { Properties prop = new Properties(); final String SRC = "./myConf.ini";//定义配置信息存储路径// mySave(prop,SRC);//存储配置文件 myLoad(prop,SRC);//加载配置文件信息 //PASSWORD<--->123456 //DATABASE<--->YX2115 //PORT<--->3306 //USERNAME<--->root } private static void myLoad(Properties prop, String src) throws IOException { FileReader fr = new FileReader(src); prop.load(fr);//通过流，加载指定路径的配置文件 fr.close(); //遍历 Set<String> keySet = prop.stringPropertyNames();//获取对象键的Set集合 for (String key : keySet) { System.out.println(key + "<--->" + prop.getProperty(key));//通过键拿到值 } } private static void mySave(Properties prop, String src) throws IOException { //将配置信息存储到对象中 prop.setProperty("USERNAME","root"); prop.setProperty("PASSWORD","123456"); prop.setProperty("DATABASE","YX2115"); prop.setProperty("PORT","3306"); //写入文件 FileWriter fw = new FileWriter(src);//创建输出流对象 prop.store(fw,"MyDataBase Configure!~"); fw.close(); }}8 -总结
本篇文章介绍了集合的常用方法以及个别集合的底层是如何实现的。介绍了集合的继承与实现结构。各个集合的扩容方式及扩容大小以及各个集合的优点和用途。希望大家可以根据本篇文章可以更加深刻的理解java中的集合。
