Collection&Map

视频地址：https://www.bilibili.com/video/BV1Kb411W75N?p=513

**

一、集合框架的概述

1、（此时的存储，主要是指的是内存方面的存储，不涉及持久化的存储（.txt、.jpg、.aavi））
2.1、数组在存储多个数据方面的特点：
数组一旦初始化以后其长度就确定了
数组一旦定义好，其元素类型就确定了，我们也只能操作指定类型的数据了。
比如 String[] arr; int[] arr1
2.2、数组在存储多个数据方面的缺点：
一旦初始化以后，其长度就不可修改。
数组中提供的方法非常有限，删除、插入操作非常不便，效率不高
获取数组中实际元素个数的需求，数组没有现成的属性和方法可用
数组存储的特点：有序、可重复。对于无序、不可重复的需求，不能满足
Java集合可分为两个体系：Collection、Map
Collection接口：单列数据，定义了存取一组对象的方法的集合
List: 元素有序、可重复的集合
Set： 元素无序、不可重复的集合
Map接口：双列数据，保存具有映射关系“key-value”对的集合。

二、集合框架

  |---Collection接口：单列集合，用来存储一个一个对象
		|---List接口：存储有序的、可重复的数据   动态数组
			|---ArrayList、LinkedList、Vector
		|---Set接口：存储无序的、不可重复的数据   高中讲的集合
			|---HashSet、LinkedHashSet、TreeSet
|---Map接口：双列集合，用来存储一对（key-value）  高中函数：y=f（x）
			|---HashMap、LinkedHashMap、Hashtable、Properties

三、Collection

1、Collectiob 方法

要求obj所在类重写equals()方法。
Collectio coll = new ArrayList();
1、 Contains(obj) 判断是否包含obj对象，判断是根据obj对象所在类的equals()方法。即将coll中的全部元素传入到obj对象所在类的equals方法一个一个比较，找到则停止打印true，否则找完全部停止打印false。

常用

Int size() 返回此集合中的元素数。
Boolean equals(Object o) 比较指定对象与此集合是否相等。
Int hashCode() 返回此集合的哈希码值。
Object[] toArray() 返回一个包含此集合中所有元素的数组。

1、增
修饰符和类型 方法 描述
boolean add(E e) 确保此集合包含指定的元素（可选操作）。
boolean addAll(Collection<? extends E> c) 将指定集合中的所有元素添加到此集合（可选操作）。
2、删
boolean remove(Object o)
从此集合中移除指定元素的单个实例（如果存在）（可选操作）。
boolean removeAll(Collection<?> c)
删除也包含在指定集合中的所有此集合的元素（可选操作）。
void clear() 从此集合中删除所有元素（可选操作）。
3、改

4、查
boolean contains(Object o)
返回true此集合是否包含指定的元素。
boolean containsAll(Collection<?> c)
返回true此集合是否包含指定集合中的所有元素。
boolean isEmpty()
true如果此集合不包含元素，则返回。

boolean retainAll(Collection<?> c)
仅保留此列表中包含在指定集合中的元素

5、遍历
Iterator iterator() 返回此集合中元素的迭代器。

2、Iterator

Iterator对象称为迭代器(设计模式的一种)，主要用于遍历Collection 集合中的元素。GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。
Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。Iterator 仅用于遍历集合，Iterator本身并不提供承装对象的能力。如果需要创建terator 对象，则必须有一个被迭代的集合。
集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

迭代Iterator
Iterator iterator = coll.iterator();
while(iterator.hasNext()){
    System.out.println(iterator.next());}
for(Object obj : coll){
    System.out.println(obj);
}

3、List源码

3.1、ArrayList
https://www.bilibili.com/video/BV1Kb411W75N?p=528&spm_id_from=pageDriver

鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组。List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
JDKAPI中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

ArrayList、LinkedList、Vector三者的异同

|—Collection接口：单列集合，用来存储一个一个对象
|—List接口：存储有序的、可重复的数据  动态数组
|—ArrayList 作为List接口的主要实现类；线程不安全、效率高；底层使用
Object[] elementData存储
|—LinkedList 底层使用双向链表存储。对于频繁插入删除操作，使用此类效率比ArrayList高
|—Vector 作为List的古老实现类，线程安全;
底层使用Object[] elementData存储

ArrayList源码分析：jdk7情况下
ArrayList list= new ArrayList(); //底层创建了长度为10的Object[] 数组elementData
List.add(123); elementData[0] = new Integer(123);
…
list.add(11); //如果此次的添加导致底层elemenData数组容量不够，则扩容。默认情况下，扩容为原来容 量的1.5倍。同时需要将原来数组中的数据复制到新的数组中。

Jdk1.8
ArrayList list= new ArrayList(); //底层 Object[] elementData初始化为{}，并没有创建长度为10的数组
list.add(123); // 第一次调用add() 时，底层才创建长度为10的数组，并将123添加到elementData

2.3小节 jdk1.7的ArrayList的对象的创建类似于单例的饿汉式，而jdk1.8中的ArrayList的对象的创建类似于单例的饿汉式，延迟了数组的创建，节省内存。

3.2、LinkedList
LinkedList list = new LinkedList(); // 内部声明了Node类型的first和last属性，默认值为null。
list.add(123); // 将123封装到Node中，创建了Node对象

其中Node定义为：

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

3.3 Vector
Jdk7和jdk8中通过Vector()构造器创建对象时，底层创建长度为10的数组。默认情况下，扩容为原来容 量的2倍。

3.4 ArrayList特有方法
https://www.bilibili.com/video/BV1Kb411W75N?p=532&spm_id_from=pageDriver

**

4、总结 常用方法

**

增 add(Object obj)
删 remove(int index)  remove(Object obj)
改 set(int index,Object else)
查 get(int index)
插 add(int index, Object else)
长度 size()
遍历 ① Itearator迭代器方式
	 ② 普通的循环
	 ③ 增强for循环

5、Set

5.1、Set特点

|---Collection接口：单列集合，用来存储一个一个对象
		|---Set接口：存储无序的、不可重复的数据   高中讲的集合
			|---HashSet 作为Set接口的主要实现类；线程不安全；可以存储null值
				|---LinkedHashSet 作为HashSet的子类，遍历其内部数据时，可以安装添加的顺序遍历
								对于频繁的遍历操作，LinkedHashSet效率高于HashSet。
			|---TreeSet：可以按照添加的对象的指定属性，进行排序
				
|---Set接口：存储无序的、不可重复的数据

1、 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值存储。
2、 不可查重复性：保证添加的元素按照equals()判断时，不能返回true。即相同的元素只能添加一个。

5.2、添加元素的过程
以HashSet为例：
我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的的存放位置（即为索引位置），判断数组此位置上是否已经有元素:
如果此位置上没有其他元素，则元素添加成功。 情况1
如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a和元素b的哈希值：
如果哈希值不相同则元素a添加成功 情况2
如果哈希值相同，进而需要调用元素a所在类的equals方法
equals（）返回True，则元素a添加失败，
equals（）返回false，则元素a添加成功。 情况3

对于添加成功的情况2和情况3而言：元素a与已经存在指定索引位置上数据以链表的方式存储。
Jdk7：元素a放到数组中指向原来的元素
Jdk8：原来的元素在数组中，指向元素a
总结：七上八下

HashSet底层：数组+链表的结构

5.3、HashSet方法及注意事项

1、Set接口中没有额外定义的新方法，使用的都是Collection中申明过的方法
2、要求：向Set中添加的数据，其所在的类一定要重写hashCode()和equals()
要求：重写的hashCode()和equals()尽可能的保持一致。
重写两个方法的小技巧：对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。

重写 hashCode() 方法的基本原则
在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值。
 当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode()
方法的返回值也应相等。
 对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。

5.4、LinkedHashSet
LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据，
优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet。

5.5 TreeSet

5.5.1两种排序

1、向TreeSet中添加的数据，要求是相同类的对象。
2、两者排序方式;自然排序（implements Comparable）和定制排序（Comparator）
3、自然排序中，比较两个对象是否是相同的标准为：compareTo()返回0，不再是equals()方法。
5.5.1.1自然排序

5.5.1.2定制排序

四、Collection题及复习

https://www.bilibili.com/video/BV1Kb411W75N?p=543
https://www.bilibili.com/video/BV1Kb411W75N?p=544
https://www.bilibili.com/video/BV1Kb411W75N?p=545

1、集合Collection中存储的如果是自定义类的对象，需要自定义类重写哪个方法？为什么？
equals()方法 contains()/remove()/remainsAll()……

List：equals()方法
Set：(HashSet、LinkedHashSet) equals()、hashCode()
(TreeSet为例)：Comparable：compareTo(Object obj)
Comparator：compare(Object o1, Object 02)

2、 ArrayList、LinkedList、Vector三者的相同点和不同点？（面试题）
答：都实现了List接口。ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
ArrayList初始化为？个数组元素，每扩容一次为原来的1.5倍，Vector为2倍

3、 List接口的常用方法有哪些？（增、删、改、查、插、长度、遍历）

add(Object obj)
remove(Object obj)/remove(int index)/clear()
set(int index, Object obj)
get(int index)
add(int index,Object obj)
size()

4、 如何使用Iterator和增强for循环遍历List。举例说明

for (Object obj:set) {
    System.out.println(obj);
}
Iterator iterator = set.iterator();
while(iterator.hasNext()){
    System.out.println(iterator.next());
}

5、Set存储数据的特点是什么？常见的实现类有什么？说明一下彼此特点。
HashSet、LinkedHashSet、TreeSet
6、Collection常用方法

add(Object obj)、addAll(Collection coll)、size()、isEmpty()、clear()、
contains(Object obj)、containsAll(Collection coll)、remove(Object obj)、
removeAll(Collection coll)、retainsAll(Collection coll)、equals(Object obj)、
hasCode()、toArray()、iteartor()

7、Collection和数组的转换

8、

9、List各实现类源码分析

10、Set

Set测试题

public void test3(){
        HashSet set = new HashSet();
        Person p1 = new Person(1001,"AA");
        Person p2 = new Person(1002,"BB");

        set.add(p1);
        set.add(p2);
        System.out.println(set);

        p1.name = "CC";
        set.remove(p1);
        System.out.println(set);
        set.add(new Person(1001,"CC"));
        System.out.println(set);
        set.add(new Person(1001,"AA"));
        System.out.println(set);4
}

答案：
[Person{id=1002, name='BB'}, Person{id=1001, name='AA'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}]
[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}]

五、Map

**5.1、Map的实现类的结构情况**
|---Map接口：双列数据，用来存储一对（key-value）  高中函数：y=f（x）
			|---HashMap 作为Map的主要实现类；线程不安全，效率高，可以存储null的key和value
				|---LinkedHashMap  保证在遍历map元素时，可以按照添加的顺序实现遍历。
								  原因：在原有的HashMap底层结构基础上，添加了一对指针，指向										前一个元素和后一个元素。
								  对于频繁的遍历操作，此类执行效率高于HashMap，
			|---TreeMap   保证按照添加的key-value对进行排序，实现排序遍历此时考虑key的定制排							 序或自然排序。底层使用红黑树。
			|---Hashtable   作为Map的古老实现类；线程安全的，效率低，不能存储null的key和value
				|---Properties：常用来处理配置文件。key和value都是String类
HashMap的底层： 数组+链表  （jdk7之前）
				  数组+链表+红黑树  （jdk8）

面试题：
1、 HashMap的底层实现
2、 HashMap和Hashtable实现异同
3、 CurrentHashMap 与 Hashtable异同

5.2、Map结构的理解
Map中的key：无序的、不可重复的，使用Set存储所有的key key所在的类要重写equals()、hashCode()
(以HashMap为例)
Map中的value：无序的、可重复的，使用Collection存储所有的value  value所在类重写equals()方法
一个键值对:key-value构成了一个Entry对象。Map中的entry：无序的、不可重复的，使用Set存储所有的entry
5.3、HashMap底层实现原理
以jdk7为例说明

HashMap map = new HashMap();
在实例化以后，底层创建了长度为16的一维数组Entry[] table
…….可能已经执行多次put。。。
map.put(key1,value1):

首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
如果此位置上的数据为空，此时的key1-value1添加成功。情况1
如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存放）），比较key1和已存在的一个或多个数据的哈希值。
	如果key1的哈希值与已经存在的数据的哈希值不相同，此时key1-value1添加成功。 情况2
	如果key1的哈希值和已经存在的某一个数据（key2-value2）的哈希值相同，继续比较：调用key1所在类的equals（）	方法比较；
		如果equals（）返回false：此时的key1-value1添加成功。  情况3
		如果equals（）返回true：使用value1替换value2。

补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。
在不断的添加过程中，会涉及扩容问题，当超出临界值且要存放的位置非空，默认的扩容方式：扩容为原来的2倍，并将原有的数据复制过来

jdk8 相较于jdk7在底层实现方面的不同：
1. new HashMap():底层没有创建一个长度为16的数组
2. jdk 8底层的数组是：Node[],而非Entry[]
3. 首次调用put()方法时，底层创建长度为16的数组
4. jdk7底层结构只有：数组+链表。jdk8中底层结构：数组+链表+红黑树。
4.1 形成链表时，七上八下（jdk7:新的元素指向旧的元素。jdk8：旧的元素指向新的元素）
4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。

 *      DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
 *      DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
 *      threshold：扩容的临界值，=容量*填充因子：16 * 0.75 => 12
 *      TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8
 *      MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64

public V put(K key, V value) {
       if (key == null)
           return putForNullKey(value);
       int hash = hash(key);
       int i = indexFor(hash, table.length);
       for (Entry<K,V> e = table[i]; e != null; e = e.next) {
           Object k;
           if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
               V oldValue = e.value;
               e.value = value;
               e.recordAccess(this);
               return oldValue;
           }
       }

       modCount++;
       addEntry(hash, key, value, i);
       return null;
   }

jdk8
   final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)   //首次添加，建数组
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)     //计算新添加元素的位置且该位置没有元素
            tab[i] = newNode(hash, key, value, null);
        else {
            HashMap.Node<K,V> e; K k;
            if (p.hash == hash &&  // 加入位置链表第一个元素的哈希值相等且eauals()
                    ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;  //拿到这个新加入的元素
            else if (p instanceof HashMap.TreeNode)
                e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {         // 加入位置链表第一个元素的哈希值不等，或者哈希值相等但eauals()不等
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        } 
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
}

5.4、LinkedHashMap
LinkedHashMap 是 HashMap 的子类
在HashMap存储结构的基础上，使用了一对双向链表来记录添加
元素的顺序
与LinkedHashSet类似，LinkedHashMap 可以维护 Map 的迭代
顺序：迭代顺序与 Key-Value 对的插入顺序一致

HashSet底层实现为HashMap，Map中的所有value都指向了一个私有的静态对象
5.5 Map常用方法

总结常用方法：

添加：put(Object obj,Object value) / putAll(Map m)
删除：Object remove(Object key) / void clear()
修改：put(Object key,Object value)
查询：get(Object key)
长度：size()
遍历：keySet() / values() / entryset()

5.6、TreeMap
//向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
//因为要按照key进行排序：自然排序 、定制排序
//自然排序

5.7、Properties
Properties 类是 Hashtable 的子类，该对象用于处理属性文件
由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key 和 value 都是字符串类型
存取数据时，建议使用setProperty(String key,String value)方法和 getProperty(String key)方法

Properties pros = new Properties();
fis = new FileInputStream("jdbc.properties");
pros.load(fis);//加载流对应的文件
String name = pros.getProperty("name");
String password = pros.getProperty("password");
System.out.println("name = " + name + ", password = " + password);

六、Collection工具类

• Collections:操作Collection、Map的工具类
• 面试题：Collection 和 Collections的区别？
  Collections方法

reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

List dest = Arrays.asList(new Object[list.size()]);
System.out.println(dest.size());//list.size();
Collections.copy(dest,list);
System.out.println(dest);