集合、List、Set、Map、Collections、queue、deque

概述

相同类型的数据进行统一管理操作，使用数据结构、链表结构，二叉树

分类：Collection、Map、Iterator

集合框架

List接口

有序的Collection接口，可以对列表中的每一个元u尿素的插入位置进行精确的控制，用户可以根据元素的整数索引访问元素，并搜索列表中的元素

有序，允许多个null元素

常用类：ArrayList、Vector、LinkedList

ArrayList

实现原理：采用动态对象数组实现，默认构造方法构造了一个空数组

第一次添加元素，扩容为10，之后的扩容算法为原来的数组大小+原理啊数组的一半

不适合插入和删除操作

为了防止数组动态扩充太多，建议给你一个初始容量，

线程不安全，适合在单线程使用

Vector

实现原理采用动态数组实现，默认的初始容量为10动态数组

扩容算法：当增量为0时，原来的两倍，当增量大于0时，扩容为原来的大小+增量

不适合插入和删除操作

对于数组扩充太多的建议使用Vector，有初始容量

线程安全，效率低，多线程下使用

LinkedList

底层实现采用双向链表，高效、无序，插入和删除的特性，性能高，

实际开发中如何选择？

1.安全性？Vector

2.是否频繁插入和操作 LinkedList

3.是否存储后遍历 ArrayList

Set接口

一个不包含重复元素的Collection，set不不包含相同元素，并且最多包含一个null元素、无序

HashSet、TreeSet、LinkedHashSet，底层实现与Map关联

HashSet

实现Set类，由哈希表支持，不保证set的迭代顺序，特别时不保证改顺序恒久不变，运行使用null元素

实现原理：基于哈希表（HashMap）实现

不允许重复元素，可以有一个null元素

不保证恒久不变的顺序

添加元素时，把元素作为hashMap的key，value使用一个固定的object对象

排除重复元素使用的时equlas()，如何判断对象是否重复，hashCode()和equals()进行判断

判断两个元素是否相同，先判断两个对象的hashCode是否相同，（如果相同，不一定是同一个对象，不同一定不是同一个对象），相同在比较equals，相同，才相同。

自定义对象哟啊任务属性值都是相同为同一个对象，有这种需求时，重写对象所在类的HashCode和eqals方法

存储结构：数组+链表，数组的元素以链表的形式存储

要把数据存储到哈希表中，首先是计算HashCode的值，再对数组取余，最终决定数据存储的位置

TreeSet

基于TreeMap的NavigableSet实现，让元素的自然顺序进行排序，或者根据创建set提供的Comparator进行排序，取决于构造方法

有序的，基于TreeMap实现（二叉树结构实现），对象需要比较大小，通过比较器来实现，去除重复数，如果自定义的类没有实现比较器结构，将无法添加到treeSet集合中

LinkedHashSet

哈希表和链表的实现

维护着一个运行于所哟条目的双重链表接列表，链表定义迭代顺序，按照元素插入到set的顺序进行迭代

区别：

要排序：TreeSet

不排序，不用保证顺序hashSet

不排序，要顺序LinkedHashSet

Iterator 接口

package com.ty.collectionPackage;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class IteratorDemo {
    public static void main(String[] args) {
        List<Cat> list = new ArrayList<>();
        Cat c1 = new Cat("oo", 2, 1);
        Cat c2 = new Cat("dd", 3, 2);
        Cat c3 = new Cat("uu", 4, 3);
        Cat c4 = new Cat("oo", 2, 4);
        list.add(c1);
        list.add(c2);
        list.add(c3);
        list.add(c4);
        foreachIterator(list);
        System.out.println("==========");
        IteratorDemo(list);
        System.out.println("=========");
        foreachLambda();

    }
    private static void foreachIterator(Collection<Cat> cats){
        for (Cat cat : cats) {
            System.out.println(cat);
        }
        System.out.println("foreach遍历了");
    }
    private static void IteratorDemo(Collection<Cat> cats){
        Iterator<Cat> iterator = cats.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("Iterator 遍历了");
    }

    private static void foreachLambda(){
        List<Cat> list = new ArrayList<>();
        Cat c1 = new Cat("oo", 2, 1);
        Cat c2 = new Cat("dd", 3, 2);
        Cat c3 = new Cat("uu", 4, 3);
        Cat c4 = new Cat("oo", 2, 4);
        list.add(c1);
        list.add(c2);
        list.add(c3);
        list.add(c4);
        list.forEach((Cat cat) ->{
            System.out.println(cat);
        });

       // list.forEach(cat -> System.out.println(cat));
    }
}

jdk8新特性之Stream

是元素的集合，支持顺序和并行的对原Stream进行汇聚操作

Stream当成高版本的iterator，Iterator用户只能一个一个的遍历严肃并对其操作，而Stream只需要给出需要对其包含元素的操作，这些才做如何对应到每个元素上，由Stream完成

Map接口

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

Map：键值对的形式存在

key唯一，value可以重复

具体实现类：hashMap、TreeMap、HashTable、LinkedHashMap

HashMap

基于哈希表的Map接口，提供可选的映射操作，运行使用null值和null键，不保证映射的顺序，特别不保证该顺序恒久不变。

package com.ty.collectionPackage;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo {
    public static void main(String[] args) {
        HashMapDemo();
    }
    private static void HashMapDemo(){
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"tt");
        map.put(2,"yy");
        map.put(3,"zz");
        map.put(4,"cc");
        map.put(5,"pp");
        System.out.println(map.size());
        System.out.println("===========");
        //迭代
        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        for (Map.Entry e : entrySet) {
            System.out.print(e.getKey()+"-->"+e.getValue()+" ");
        }
        //迭代
        System.out.println("================");
        Set<Integer> keySet = map.keySet();
        for (Integer i : keySet) {
            String value = map.get(i);
            System.out.print(i+"-->"+value+" ");
        }
        //遍历值
        System.out.println("=============");
        Collection<String> values = map.values();
        for (String value:values){
            System.out.print(value+" ");
        }
        //foreach
        System.out.println("==========");
        map.forEach((key,value)->{
            System.out.print(key+"-->"+value +" ");
        });
    }
}

1.实现原理：基于哈希表（数组+链表+二叉树（红黑树））

2.默认加载因子0.75，默认数组是16

3.把对象存储到哈希表中，把key对象通过hash()方法计算hash值，然后用hash值对数组取余数（默认是16），来决定该key在数组存储的位置，当有多个值时，以链表的形式存储，在jdk8后，当链表大于8时，链表转为红黑树，为了取值更快，存储的数据量越大，性能的表现越明显

4.扩容原理：当数组的容量大于0.75，扩充算法：当前数组容量 << 1（相当于*2，）扩大1倍，扩充次数过多，会影响性能，重新散列，每次扩充代表哈希表散列（重新计算每个hash值的存储位置），开发中尽量减少扩充次数。

5.线程不安全，适合单线程

Hashtable

实现一个哈希表，映射到相应的值，任何非null对象都可以作为键值对，为了成功在哈希表中存储和获取对象，用作键的对象必须实现hashCode方法和equals方法。

1.jdk1开始使用

2.基于哈希表实现（数组+链表）

3.默认数组大小11，加载因子0.75

4.扩容方式原数组大小<<1 （*2）+1

5.线程安全，用在多线程

**** HasMap和Hashtable区别？？？

LinkedHashMap

哈希表和链接列表实现，可预知的迭代顺序，保证顺序。

是HashMap的子类，由于HashMap无法保证顺序，此类使用双重列表保证元素顺序。

jdk8中map的新方法

Conllections类

大量针对Collection和Map操作，分为四类，都是静态方法

1.排序操作，针对List接口

队列Queue

是一种特殊的线性表，先进先出的数据结构，只允许在表的前端front进行删除操作，在表的后端进行删除操作，进行插入操作的叫队尾，删除操作的端叫队头，队列中没有元素时，称为空队列

LinkedList实现了Queue接口

请求队列，雄安锡队列、任务

Deque

一个线性collection，支持在两端插入和移除元素。支持有容量限制的双端对了，支持没有固定限制的双端队列

接口定义在双端对了两端访问元素的方法，提供插入、移除、查询 Stack 堆栈：先进后出