Java中的集合

容器|集合 : 存储多个数据

数组 : 存储多个数据，（一段连续的内存空间）

数组的特点:1.引用数据类型；2.定长,长度一旦确定不可改变；3.存储数据的类型相同；4.有序,有索引；

集合:存储任意引用类型数据；集合的长度可变,可以根据需求动态的增删数据,长度随之改变

容器中的接口层次结构

Collection : 单个值的集合（ 1、Set 无序不可重复；2、List 有序可重复,有索引）

Map : 键值对的集合(KEY-VALUE)

Collection：集合层次结构中的根接口。 集合表示一组对象，称为其元素

常用方法

遍历方式（foreach，iterator迭代器）

泛型: jdk1.5

参数化类型 : 数据类型作为参数传递（只能配置引用数据类型）

<>定义泛型

1、泛型的行为发生在编译期间,运行期间发型配置的所有内容无效,泛型擦除

2、要求先定义泛型,才能使用泛型

3、泛型类 : 类型的后面定义泛型,在使用类型的时候可以通过泛型传递具体的类型,类中可以进行使用

泛型方法

泛型的优点:（1、代码简单简洁；2、增强程序健壮性,避免类型转换异常的出现；3、增强稳定性与可读性）

List : 有序,可重复；

 Set : 无序,不可重复|唯一的

List : 有序集合（也称为序列 ）。 该接口的用户可以精确控制列表中每个元素的插入位置。

新增: 一些列根据索引操作的方法

遍历方式 :（1、for普通for循环；2、foreach 增强for循环；3、iterator迭代器）

有序,可重复的

ArrayList : 实现所有可选列表操作，并允许所有元素，包括null 。

底层结构: 数组  Object[] elementData;

特点: 根据索引查询遍历效率较高,增删效率低

应用场景: 适合应用在大量做查询,少量做增删的位置

扩容问题:

初始容量 : 默认初始容量为10 ,在第一次添加add的时候进行构建  private static final int DEFAULT_CAPACITY = 10;

扩容机制 : 每次扩容原容量的1.5倍 int newCapacity = oldCapacity + (oldCapacity >> 1);

新增功能: void forEach(Consumer<? super E> action)

遍历 :（普通for、增强for、iterator迭代器、listIterator迭代器）

Vector :底层结构 : 数组；特点 : 与ArrayList相同

区别:1)  Vector是同步的|线程安全，ArrayList不同步|线程不安全,相对效率较高

2) Vector每次扩容原容量的2倍；ArrayList每次扩容原容量的1.5倍,相对ArrayList更有利于节省内存

LinkedList: 实现所有可选列表操作，并允许所有元素（包括null ）

底层结构: 双向链表

特点: 查询效率低,增删效率高

应用场景:单个数据值的集合中,允许数据有序,且可重复,在大量做增删,销量做查询的时候时候适合使用链表

新增功能: 新增了一些与链表头尾相关的方法

注意: 请注意，此实现不同步。

定义链表结构,存储javabean类型的数据,测试使用,遍历使用

存储javabean类型数据时候,要求javabean类型重写equals方法,否则使用一些判断比较的方法时候回默认调用equals方法

Set : 无序,不可重复|去重

无序: 存放的顺序与内部真实存储的顺序不一致

去重: 集合不包含元素对e1和e2 ，使得e1.equals(e2)和最多一个null元素。

新增功能: static <E> Set<E> of(E... elements) 返回包含任意数量元素的不可修改集。

遍历方式:foreach、iterator迭代器

TreeSet :（默认升序排序）

底层结构 : 红黑树

特点 : 查询效率较高,自动把数据做升序排序

底层是由TreeMap维护的

新增功能: 新增了一些与比较大小相关的方法

遍历方式 :foreach、iterator迭代器 

TreeSet存储javabean类型的数据（去重与排序: 都是根据比较规则实现的,与equals没有关系）

比较规则:

内部比较器|内部比较规则|自然排序 : 比较规则定义在javabean类型的内部（javabean类型实现Comparable接口,重写compareTo(T o)方法,在方法中定义比较规则）

外部比较器|外部比较规则|定制排序 : 比较规则定义在javabean类型的外部（定义一个实现类,实现Comparator接口,重写int compare(T o1, T o2),在方法中定义比较规则）

Arrays.sort(数组) 默认升序排序

static <T> void sort(T[] a, Comparator<? super T> c) 根据指定比较器引发的顺序对指定的对象数组进行排序。

HashSet ****

底层结构: 哈希表(数组+链表+红黑树)

特点: 查询,增删效率高 ,去重,无序

底层是由HashMap维护的

遍历: foreach  iterator迭代器

新增方法 : 无

此类允许null元素。

请注意，此实现不同步。

Map : 无序的,去重的

键值对数据的集合

键值对->映射关系

价值对: K-V

K键 : 无序的,去重的|唯一的 ---> Set

V值 : 无序的,可重复 ---> Collection

K-V可以为任意引用数据类型

特点:

一个key只能对应一个Value

key相同value覆盖

遍历方式:

1.values 获取所有键值对的值（Collection<V> values() 返回此映射中包含的值的Collection视图）

2.keySet 获取所有键值对的key,根据key获取value（Set<K> keySet() 返回此映射中包含的键的Set视图。）

3.entrySet 获取所有的键值对,每一个键值对都是一个Entry类型->表示一个键值对（Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射的Set视图。）

TreeMap :底层: 红黑树

存储键值对类型的数据,自动升序排序,去重的

去重,排序: 根据键值对的key实现,与value本身无关

TreeSet底层是由TreeMap

HashMap :基于哈希表的Map接口的实现。 此实现提供了所有可选的映射操作，并允许null值和null键。

HashSet 底层是由HashMap

底层结构 : 哈希表(数组+链表+红黑树)

哈希表:

数组 : 节点数组Node[] --> 要求数组的长度为2的整数次幂（Node : int hash,Object key,Object value,,Node next）

每个索引位置存储的为一个单向链表的首节点(尾插法)

当链表的长度>8,数组的长度>64,会把链表优化成为红黑树

当链表的长度>8,但是数组的长度不大于64,这时候会实现扩容(数组的扩容)

初始容量: 哈希表中的数组默认的初始长度  16（static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16）

数组的容量最大容量 : static final int MAXIMUM_CAPACITY = 1 << 30;

加载因子: 0.75 一般不建议改变

默认加载因子 : static final float DEFAULT_LOAD_FACTOR = 0.75f;

扩容阀值 threshold  : 扩容的临界值  数据的个数size>数组的长度*加载因子 就会扩容

扩容机制: 原容量的2倍 int newCap = oldCap << 1

新增功能: 无

HashMap的哈希表存储数据的过程:

1.根据key计算哈希值（通过key的hashCode方法的返回值进一步进行hash算法的运算,得到的整数；int hash = (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);）

2.调用putVal方法实现添加数据(hash,key,value)

1)判断是否是第一次调用put方法做添加 if ((tab = table) == null || (n = tab.length) == 0)（如果是第一次添加,直接调用resize()实现扩容

2)计算位桶的索引 int index = (n - 1) & hash）

 3)判断哈希表结构的数组table[index]是否存在数据,（

1、如果不存在数据,证明没有头节点,创建新节点,放入当前数组的对应索引位置作为头节点；2、 table[index] = new Node<>(hash, key, value, next);2、size数据的个数+1,判断是否>扩容的阀值,如果大于需要调用resize方法进行扩容,如果不大于,不需要扩容直接返回null；4、if (++size > threshold) resize();5、return null;6、 如果存在数据,作为链表的头结点,遍历这个链表,拿到每一个节点的key与hash值判断是否与要添加的key和hash相同,如果相同,value覆盖（）1、if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))；2、 value覆盖之后,返回被覆盖的value；3、V oldValue = e.value;4、 e.value = value;5、return oldValue;

）

去重 : 根据key做去重,要求key的数据类型重写hashCode与equals方法

Hashtable 与 HashMap之间的区别:（共同点 : 都是Map接口的实现类,底层结构都是哈希表）

异同点 :1.继承体系不同；2.线程是否安全不同（HashMap 线程不安全|不同步；Hashtable 线程安全的|同步的）3.扩容机制不同（HashMap扩容机制 : 每次扩容原容量的2倍； int newCap = oldCap << 1；Hashtable扩容机制 : 原容量的2倍+1；int newCapacity = (oldCapacity << 1) + 1;）4.键值对数据null值的要求不同（HashMap 可以存储null值的key与value，Hashtable key与value都不为null）5.计算hash值与位桶索引index的算法不同（HashMap :int hash = (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);  ------int index = (n - 1) & hash；；；Hashtable :int hash = key.hashCode();int index = (hash & 0x7FFFFFFF) % tab.length;）

如何处理HashMap线程不安全问题:（1.使用Hashtable；2.使用Collections工具类中static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 返回由指定映射支持的同步（线程安全）映射。3.juc高级并发编程包 ConcurrentHashMap<K,V>-> 线程安全的哈希表）

Collections :操作集合的工具类（静态工厂）

void sort(List) //对List容器内的元素排序,排序的规则是按照升序进行排序。

void shuffle(List) //对List容器内的元素进行随机排列

void reverse(List) //对List容器内的元素进行逆续排列

 void fill(List, Object) //用一个特定的对象重写整个List容器

int binarySearch(List, Object)//对于顺序的List容器，采用折半查找的方法查找特定对象

Properties :

Properties类表示一组持久的属性。 Properties可以保存到流中或从流中加载。

属性列表中的每个键及其对应的值都是一个字符串。

可以通过Properties实现软编码,便于后期维护

从配置文件中读取键值对数据:（1.定义配置文件xxx.properties；2.定义Properties对象；3.调用load(),与从流中加载数据；4.根据key获取value->getProperty）