Java集合类

Collection接口

Collection接口是单个集合保存的最大父接口
只是一个存储数据的标准
我们通常使用其子类 List Set

List 接口 可以存放重复数据

方法1 list.get(index) 根据索引取得保存数据
方法2 list.set(index,value) 修改数据
由于LIst也是接口，我们想取得实例化对象，就必须有子类，ArrayList，Vector，LinkedList实现了List接口

ArrayList

 //ArrayList实现
        List<String> stringArrayList=new ArrayList<>();
        stringArrayList.add("ArrayList 的第一个元素");
        stringArrayList.add("ArrayList 的第2个元素");
        stringArrayList.add("ArrayList 的第2个元素");
        System.out.println(stringArrayList);
        stringArrayList.add("ABC");
        stringArrayList.add("hello");
        System.out.println(stringArrayList.isEmpty());
        System.out.println(stringArrayList.get(1));
        System.out.println(stringArrayList.contains("ABC"));
        for(int i=0;i<stringArrayList.size();i++){
            System.out.println("元素为"+ stringArrayList.get(i));
        }
结果：
[ArrayList 的第一个元素, ArrayList 的第2个元素, ArrayList 的第2个元素]
false
ArrayList 的第2个元素
true
元素为ArrayList 的第一个元素
元素为ArrayList 的第2个元素
元素为ArrayList 的第2个元素
元素为ABC
元素为hello

List 可以保存重复数据
此时List输出可以用get方法获取元素，而Collection只能转换成Object数组操作
Collection list = new ArrayList<>() ;
Object[] result=list.toArray();
System.out.println(Arrays.toString(result));

Vector

 //Vector实现
        List<String >  stringVector=new Vector<>();
        stringVector.add("hello");
        stringVector.add("aaa");
        stringVector.add("aaa");
        System.out.println(stringVector);

ArrayList和Vector区别
1.他们都是实现了List接口
2.ArrayList是异步通信，性能更高。Vector是同步处理，性能较低
3.ArrayList是线程不安全的，Vector采用synchronize加锁，线程安全

LinkedList

 //LinkedList实现
        List<String >  stringList=new LinkedList<String>();
        stringList.add("ABC");
        ((LinkedList<String>) stringList).addLast("ABC");
        stringList.add("ABC");
        System.out.println(stringList);

LinkedList是采用链表实现
LinkedList与ArrayList区别
ArrayList是基于数组实现的，如果实例化时传入了数组大小，则会开辟一个定长数组，如果长度不够，会进行动态扩容。
LinkedList是基于链表实现的。

Set 集合

HashSet

保存不重复元素 哈希表结构
HashSet中存储自定义对象需要重写hashCode（）和equals()方法。
存元素时，会调用对象的hashCode方法计算出存储位置，然后和该位置上所有的元素进行equals比较

TreeSet

保存不重复元素，TreeSet子类可以进行排序
可以对set集合中的元素进行排序，默认按照asic码表的自然顺序排序
TreeSet中存储自定义对象需要实现comparable接口

HashCode和equals的区别

hashcode是一个对象的哈希码。equals是比较两个对象是否相等。
hashcode相同的对象，equlas不一定相等。
equals相同的话hashcode一定相同。

集合输出

迭代输出 Iterator

hasNext（）
next（）
remove（）

Iterator<String > iterator=stringArrayList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

 Iterator<String > iterator1=stringArrayList.iterator();
        while (iterator1.hasNext()){
            if(iterator1.next().equals("ABC")){
                iterator.remove();
                //使用Iterator的remove方法则不会产生异常
                continue;
            }
            System.out.println(iterator1.next());
        }

双向迭代接口ListIterator

而如果要想进行双向迭代，那么就必须依靠Iterator的子接口：ListIterator来实现。
1. 判断是否有上一个元素：public boolean hasPrevious();
2. 取得上一个元素:public E previous();

 ListIterator<String >  iterator2=stringArrayList.listIterator();
        while (iterator2.hasPrevious()){
            System.out.println(iterator2.previous());
        }

Map集合 <key,Value>

实现接口的子类1.HashMap 基于红黑树和哈希表

实现接口的子类2.HashTable 基于哈希表

实现接口的子类3.ConcurrentHashmap

实现接口的子类4.TreeMap 基于红黑树

解决哈希冲突

1.开放定址法：如果冲突 寻找下一个null
2.再散列法：将冲突元素使用不用的哈希算法
3.链地址法，HashMap使用此方法。通过链表存储重复元素

HashMap

  //HashMap基本操作
        Map<String ,Integer> hashMap=new HashMap<>();
        hashMap.put("张三",19);
        hashMap.put("李四",19);
        hashMap.put("王五",19);
        hashMap.put("张三",19);
        System.out.println(hashMap.get("王五"));
        System.out.println(hashMap);

HashMap内部实现

内部实现是数组和链表结合
数组可以看成一个个同bucket，通过哈希值决定了键值对在这个数组的寻址，哈希值相同，则以链表形式存储。如果链表的大小超过阈值，链表会被改成树形结构
懒加载方式
resize方法进行初始化存储表格，和扩容
hash实现
hash=（key.hahscode()）^（ h >>> 16）
首先先右移十六位，这样会减少内存开销。
存储位置为 i=（n-1）&hash
有些数据计算出的哈希值差异主要在高位，而 HashMap 里的哈希寻址是忽略容量以上的高位的。所以为了避免哈希碰撞。进行异或运算。
n：哈希表长度 必须为2^n 保证n-1 保证低位都可以存储元素
如果不是2^n n-1&hash 0000 1110 末尾为0 无法存储元素
容量和负载因子
空桶太多会导致空间浪费，空桶太少会导致操作性能低下。
负载因子通常是0.75
太小会进行频繁扩容，太大会导致冲突明显。
树化
如果不树化，链表长度过长会导致查找时间为On，树化会保持在Ologn
当链表长度大于8时，并且当前哈希表长度达到64才会树化，会进行树化，
否则只进行扩容。
当红黑节点个数在扩容或删除元素时减少为6以下，在下次resize过程中会将红黑树退化为链表，以节省空间。解除树化阈值
默认大小是16，超过12则会扩容为原来的两倍。

HashTable

不能为空，同步处理，性能低，安全

ConcurrentHashMap

虽然 HashTable安全，但是性能低下，因为Hashtab加锁加的是整张表，读读都互斥。
ConcurrentHashMap锁的个数更多，粒度更细

1.7版本的ConcurrenentHashMap

采用16个Segment+哈希表
锁的个数是16个，Segement后是16组哈希表。是ReentrantLock子类，用来保证线程安全。
支持的并发线程人数增加。扩容的话只是对单个segment

1.8版本的ConcurrentHashMap

采用哈希表数组+红黑树
锁的是哈希表的每个元素，也就是每个头结点元素，如果扩容的话，会增加锁的个数。
采用CAS+synchronize代码块保证线程安全。
取消了segment的使用，采用懒加载的方式，大大减小了开销。

快速失败策略 保证多线程场景下不产生脏读

会优先考虑异常情况，如果产生异常，直接抛出异常，程序终止。
产生fail-fast原因 里面有modCount计数器记录List集合的修改次数。还有一个程序期望的计数器，由内部迭代器保存正修改次数。。如果这两个数值不相等，则会产生异常

TreeMap

是一个可以排序的Map子类，按照key的内容做的，Set底层实现也是Map
如果是自定义排序依旧是实现Comparable接口。然后依据compareTo（）方法完成。

List Map Set存取元素时有什么特点
List 以索引方式存取元素，可以有重复元素
Set 不能存放重复元素，基于哈希表。
Map 保存键值对映射，基于红黑树。
讲讲ArrayList Vector LinkedList 特性
ArrayList：数组方式存储，查找元素快。
LinkedList：采用双向链表实现存储，内存利用率高。 插入速度较快
Vector：采用Synchronize，线程安全。
List Set Map继承谁
List Set 继承Collection接口，Map是键值映射。
常用集合类有哪些
List：链表 包含ArrayList 和Vector。他们是可变大小的，适合按索引访问，
Map 是键值对。
Collection与Collections区别
Collection是集合类的接口。子类有list和Set
Collections是集合类的一个帮助类，提供一系列静态方法，只要是实现搜索排序等。
LinkedList和ArrayList区别
都实现了List接口
ArrayList：基于数组，访问元素时O（1）
LinkedList：基于双链表，访问元素O（n）插入 删除 添加更快，不需要像数组一样重新计算大小。或更新索引。
但是内存空间占用大，保存前后元素节点。
HashMap和Hashtable的区别
都实现了Map接口，map允许键值为空，而table不允许
HashMap适用于单线程，Hashtable适用于多线程，
什么是迭代器
Collection接口实现Iterable接口，Iterator提供了统一遍历集合元素的接口，
每个集合通过Iterable中的iterator()方法返回Iterator接口的对象，然后进行迭代操作，在迭代的时候不能进行删除元素，否则会抛出并发异常concurrentModificationException异常。可以使用remove()方法删除。
什么是TreeMap
TreeMap实现Map接口 保存键值对。允许value为空。基于红黑树实现。
ArrayList是否会越界
是基于动态数组实现，ArrayList并发add（）可能出现数组越界异常。
HashMap的容量为什么是2的n次幂
因为HashMap的默认负载因子 是0.75,2^n是为了让散列更加均匀
保证n-1 保证低位都可以存储元素
如果不是2^n n-1&hash 0000 1110 末尾为0 无法存储元素
ArrayList和LinkedList区别
ArrayList采用数组实现，查找 效率高，LinkedList采用双链表，插入和删除效率高。
如果一直在尾部插入，小于千万级别的时候，大部分是LinkedList效率高，而当数据量大于千万级别的时候，当数据量很大的时候，new对象的时间大于扩容的时间，就会出现ArrayList的效率比较高了。
如果hashMap的key是自定义的类，怎么办
如果key是自定义的，则必须重写hashco（）和equals（）