*集合概念:
用于存储多个对象的单一对象(容器)。存储的数据叫元素。
元素都是引用类型。
( 用于模拟现实生活中的存储容器，因此集合类型，不单单是一种。
有很多类型，设计成各种存储的数据结构。这些类型统称为集合框架 )
--元素:必须是引用数据类型的数据，不能是基本数据类型的数据。
JDK1.5新特性:
在1.5以前，容器可以存储Object的任何子类型，但是在对元素进行
操作时，比如调用元素的方法等。我们必需知道元素的类型，因此
在编程中增加了大量代码，来进行强制转换，增加了开发难度。
因此1.5开始支持了一个新特性，叫[泛型机制]。用来规定容器中
存储的元素的类型。此机制可以在编译期间就进行判断元素的类型。
=========================================================================
*集合与数组的区别：
数组:可以存储基本数据类型，也可以存储引用数据类型
集合:只能存储引用数据类型
=========================================================================
*Collection接口：
是集合框架的顶级父接口,用来定义常用的抽象方法。
子类需要实现相应的方法逻辑。
--常用方法:
boolean add(E e):
将对象e添加到集合中
int size():
返回集合元素的个数
boolean addAll(Collection c):
将集合c里的元素添加到此集合中
void clear():
清空集合元素
boolean contains(Object obj):
用于判断集合中是否存在于obj相同的元素
boolean containsAll(Collection c)
用于判断此集合中是否包含集合c中的所有元素
boolean isEmpty():
用于判断集合元素是否为空
boolean remove(Object o)
用于移除集合中的某一元素
boolean removeAll(Collection c)
用于移除此集合中与c中共有元素
boolean retainAll(Collection c);
用于保留此集合中与c中共有元素
###子接口：List, Set, Queue
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
一、List：列表
此接口对应的实现类的特点都是：有序的，可以重复的
重复与否与元素的equals方法有关
常用方法：
void add(int index,E element):
将某一元素，插入到此集合的下标index处。
E get(int index):
返回指定下标上的元素
int indexOf(Object obj):
返回指定元素第一次出现的位置。如果没有，返回-1.
E set(int index,E newElement):
使用新元素newElement替换下标index上的元素，返回原元素。
boolean remove(int index):
移除此集合中下标为index上的元素
List<E> subList(int fromIndex,int endIndex):
截取此集合中的一部分，即截取子集，从fromIndex到endIndex
"包前不包后"
PS:此方法在堆中不会产生新的集合对象。
变量引用的父集的一部分。
修改子集，会影响父集
int lastIndexOf(Object obj):
返回此集合指定元素obj最后一次出现的下标。找不到返回-1.
--java 8 为List集合增加了sort()和replaceAll()两个常用的默认方法。
sort()：
方法需要一个Comparator对象（函数式接口）来控制元素升序；
规则：字符串长度越长，字符串越大，再以升序排列。
replaceAll()：
方法需要一个UnaryOperator对象（函数式接口）来替换所有集合元素。
规则：直接用集合元素（字符串）的长度作为新的集合元素。
所以，可以使用Lambda表达式来创建该函数式接口的对象。
--------------------------------------------------------------------------
*使用Lambda表达式遍历集合：
利用forEach(Consumer action)
*使用java 8 增强的Iterator遍历集合元素：
4种方法
*使用Lambda表达式遍历Iterator（迭代器接口）：
利用forEachRemaining(Consumer action)
*使用foreach()循环遍历集合元素：
for(Object obj : books)
--------------------------------------------------------------------------------------------------
*List的三个实现类：
(1)ArrayList
底层是基于动态数组的数据结构.是有存放顺序的.
(2)LinkedList
底层是基于双链表的数据结构.每一个存储单元,都涉及到其他两个引用.
【除此之外，LinkedList还实现了Deque接口，可以被当成双端队列来使用。
因此，既可以被当成栈来使用，也可以被当成队列使用。】
优缺点: 在执行get()/set()时,ArrayList的效率高,LinkedList需要移动指针，效率低
在增加/删除操作时,LinkedList效率高,ArrayList效率低(需要扩容,移动元素)
ps:当然，在元素的数量大的情况下，区别才明显。
(3)Vector:是一个比较古老的集合类型，
线程安全，但是效率特别低；
虽然安全，也不建议使用。
foreach循环:
for(元素类型 变量:要遍历的集合或数组){
逻辑
}
实现原理:使用了迭代器思想
【如果有多个线程需要同时访问List集合中的 元素，
开发者可考虑使用Collection将集合包装成线程安全的集合】
-------------------------------------------
*List排序
--Comparable接口:
如何定义集合中元素之间的大小之分?我们需要在定义元素类型
时实现Comparable接口，实现接口内的compareTo(E e)。
实现此接口的类型的对象之间可以进行比较。
方法：
int compareTo(E e):
比较规则:
(1)this与e比较，this-e，
如果大于0, 返回大于0的一个数
如果等于0, 返回0
如果小于0, 返回小于0的一个数
"按照升序排序"
(2)e-this,"降序排序"
--工具类:Collections
提供了一个sort(Collection c)方法，
对集合里的元素进行排序
--Comparator比较器接口:
如果元素类型已经实现了comparable接口，定义了默认的比较规则。
之后，再想换其他比较规则时，不修改源码。可以利用比较器接口
来重新定义比较规则
方法：
int compare(E o1,E o2);
比较规则:
升序: o1-o2
降序: o2-o1
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
*接口Queue:
Queue也是Collection的子接口,是一种数据结构,队列.
队列:通常都是一端进(offer),另一端出(poll).
进出原则：FIFO
因为队列要经常进行增删操作,所以使用Linkedlist
实现了Queue接口.
--常用方法：
boolean offer(E e)：元素从队尾进入队列
E poll()：从队首移除元素,返回被移除的元素,当队列没有元素时,返回null.
E peek(): 查看队首元素,不移除,队列中没有元素时,返回null.
注意: 为了避免移除队列的队首时出现null,我们最好先查看队首是不是null.
【PriorityQueue： Queue的一个实现类，
保存队列元素的顺序并不是按加入队列的顺序，
而是按队列元素的大小进行重新排序。
因此调用poll()或peek()方法时，
并不是取出最先进入队列的元素，
而是取出最小的元素，
违反了队列的基本规则：FIFO
两种排序方式：1)自然排序
2)定制排序
】
--Deque:是一个Queue的子接口,实现的是双端队列的数据结构
双端队列: 两端都可以进,也都可以出
boolean offerFirst(E e)
boolean offerLast(E e)
E pollFirst()
E pollLast()
E peekFirst()
E peekLast()
【ArrayDeque：
基于数组实现的双端队列（Deque的一个实现类）。
不仅可以作为队列来使用，也可以当成栈来使用。
创建Deque时，可以指定一个numElements参数，
该参数用于指定Object[]数组的长度，
如果不指定numElements参数，Deque底层数组的长度为16.
当集合元素超出了该数组的容量时，
系统会在底层重新分配一个Object[]数组来存储集合元素。
】
栈: 双端队列的特殊情况,一端禁止进出.FILO
方法: void push(E e)----进栈
E pop()-----------出栈
------------------------------------------------------------------------------------------------
*栈的数据结构：
先进后出:FILO
我们可以将双端队列的一端进行禁止操作
另一端进或出,即Stack
void push(E e): 将元素 e推进栈中
E pop(): 将栈中的最顶端的元素，移除。
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
*Set接口：
(1): 无序,存储的元素与添加顺序无关
(2): 不可重复(使用元素的equals方法来判定是否重复)
(3): 能存储null元素，只能存储一次。
--Hash算法机制:
Set集合在添加或查看元素时，当集合中的元素过多时，就是进行
多次的比较，效率变低。
在设计元素类型时，提供hash算法，用于返回对象的一个int值。
在内存中开辟很多小的区域，用于存储一定范围的返回值的对象。
当我们想添加元素或查看元素，先计算此元素的返回值，然后去
相应区域中查找遍历.
--如果在这个区域没有找到对象，说明
集合中可以添加这个对象。
--如果有，然后查看两个对象的equals的返回值
--如果为true, 不能添加
--如果为false, 可以添加，添加至对应的链表结构中(尽可能的避免发生)
--重写HashCode方法：
重写规则：尽可能的让所有的成员变量都参与运算
尽可能的避免出现hash值碰撞
注意:
重写的必要性:
(1)如果重写了equals(), 有必要重写hashCode方法
(2)如果equals()返回true, hashCode返回值有必要相同
(3)如果equals()返回false,hashCode返回值不一定相同，
如果返回值不同，可以提高检索的效率
反过来说:
(1)hashCode值相同，equals方法可能不同
(2)hashCode值不同，equals方法一定不同
--HashCode方法：
Object是引用类型的父类，提供了hashCode()方法以及equals()方法
因此我们在定义类型时，一般都重写hashCode和equals方法。
重写的重要性:
equals方法：我们用来判断集合中的元素是否重复
hashCode方法：我们在使用Set集合时，必须要重写，因为
我们采用的是hash算法计算Set集合元素的存储位置。
int hashCode():
Object提供的方法是通过地址计算hash值，不可控。
我们需要在自定义类中重写此方法。
重写原则:
1)尽可能的让所有成员变量都参与运算
2)尽可能的减少hash值的碰撞
public int hashCode(){
int result = 7;--定义一个局部变量，进行初始化
int prime = 53 --定义一个局部变量，赋值为素数
result = prime*result+field1;
result = prime*result+field2;
return result;
}
------------------------------------------------------------------------------------------
--Set集合的遍历
因为Set集合是无序的，无下标可言，因此不能使用经典for循环。
我们可以使用迭代器原理。
(1)调用集合的iterator()获取迭代器
(2)使用foreach循环
--Set集合的元素：
不能轻易修改参与hash值算法的成员变量。
否则容易引起内存溢出。
原因:成员变量修改后，会出现新的hash值，
但是存储位置还在原hash值的位置上。
因此操作时，找不到具体的存储位置。
--子类：
HashSet：
无序，不重复，
每个能存储元素的“槽位”通常称为“桶”，
底层使用hash算法计算存储位置。
增加/删除时效率高
【当向HashSet中添加可变对象时，必须十分小心。
如果修改HashSet集合中的对象(该对象的关键实例变量)，
有可能导致该对象与集合中的其他对象相等，
从而导致HashSet无法准确访问该对象】
LinkedHashSet:
是HashSet的子类
底层使用hash算法计算存储位置，
同时使用链表来维护顺序，
输出LinkedHashSet集合的元素时，顺序与添加顺序一致。
在查看检索时，效率/遍历比较高
TreeSet：
--是SortedSet子接口的实现类，
--自然排序：升序
--定制排序：
--使用二叉树的数据结构维护元素的顺序。
--如果两个对象通过equals()方法返回true，那么他们通过Comparable()方法也应该返回0
--【如果希望TreeSet能正常工作，只能添加同一种对象】
--【当向TreeSet中添加可变对象时，必须十分小心。
如果修改TreeSet集合中的对象(该对象的关键实例变量)，
有可能导致该对象与集合中的其他对象相等，
从而导致TreeSet无法准确访问该对象】
--向该集合中添加的元素对象，（只有第一个元素不必实现Comparable接口，
后面添加的所有元素都必须实现Comparable接口，
即提供了compareTo(Object obj)方法）
EnumSet：
专门为枚举类设计的集合类，里面提供了多个类方法来创建EnumSet对象
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
*Map接口：集合框架中的另一个父接口
有时也被称作字典/关联数组
Map集合:
用于储存一一对应的元素数据，
第一个对象可以作为索引，第二个对象作为值，
我们称之为key-value，键值对。
--储存数据的特点：
(1)以key-value形式进行存储。
(2)key与value都必须是引用类型
(3)key可以为null。
(4)key与value是单向一对一映射。
(5)key不能重复
--存储机制：
Map是基于数组和链表的数据结构进行存储数据。
作为key的对象采用了hash算法计算存储的数组
(散列数组,散列桶)的位置.如果计算出来的位置，
数组中此位置没有元素，就可以添加到散列桶内，
如果有元素,key的equals方法返回值为false,就会存储在散列桶元素对应的单向链表中。
如果key的equals方法返回值为true,就进行替换(覆盖)。
PS:使用Map集合，做为key的数据类型应该重写equals和HashCode方法
--常用方法：
V put(K k,V v):
作用: 用于存储一对key-value.
返回被替换的value值
如果不是替换就返回null
V get(K k):
作用: 通过key对象，获取对应的value对象，
如果集合中没有此key,返回null
--Map集合的遍历:
Set<K> keySet();
用于获取Map中所有的key对象，返回一个Set集合
Set<Entry<K,V>> entrySet();
【Map提供了一个Entry内部类来封装key-value对，而计算Entry存储时则只考虑key】
将key-value封装成内部类对象，返回Entry对象的Set集合
Collection<V> values();
将map集合中的所有value封装到一个Collection集合中。
--装载因子和HashMap的优化
装载因子:DEFAULT_LOAD_FACTOR = 0.75f(负载极限)
轻负载的hash表具有冲突少、适宜插入与查询的特点，
但是使用Iterator迭代元素时比较慢。
默认容量:DEFAULT_INITIAL_CAPACITY
16,就是数组的容量
元素个数: size
【当我们创建一个HashMap对象时，底层数组的初始容量为16。
当存储的数据的元素个数 size/DEFAULT_INITIAL_CAPACITY
等于 DEFAULT_LOAD_FACTOR时,
数组开始扩容。此时最佳。（hash表会自动成倍地增加容量(桶的数量)，
并将原有的对象重新分配，放入新的桶内，这称为rehashing）,
如果小于0.75扩容，比较占内存。
如果大于0.75扩容，操作的元素比较多。
】
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
--->
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
/**/
Node<K,V>[] tab; 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 {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
/* hash碰撞 */
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;
}
内部类Node,封装了一个key-value数据，同时还存储了下一个节点的引用
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
-------------------------------------------------------------------------------------
*Map接口的子类:
--HashMap与HashTable的区别
(1)HashTable是一个古老的类。不建议使用
(2)HashTable是一个线程安全的类，HashMap线程不安全
(3)HashTable的key不能是null,HashMap的key可以是null(有且只有一个key为null)
--LinkedHashMap:是HashMap子类.
使用链表来维护key-value的顺序,
在迭代时顺序与添加顺序一致。
--TreeMap：
是SortedMap子接口的实现类,
使用了二叉树的数据结构维护填入集合的顺序.
(1)自然排序:
往TreeMap里添加的key对象(必须实现Comparable接口)。
即实现compareTo方法
(2)定制排序:
做为key对象的数据类型，可以不实现Comparabel接口。
在创建TreeMap集合对象时，
需要提供一个比较器Comparator对象(实现compare方法)
与该TreeMap集合相关联
--Properties:
是HashTable的子类型，
用于封装属性文件的key-value信息，
因为在文件里写的都是字符串，
因此Properties的key与value都是字符串类型
【相当于一个Key、value都是String类型的Map】
常用修改key-value方法：
String getProperty(String key);
String getProperty(String key,String defaultValue);
Object setProperty(String key,String value);
常用读写属性文件的方法：
void load(InputStream inStream);
void store(OutputStream out,String comments);
=====================================================================================================================
复习:
一、集合概念：是一个用于存储多个对象的容器(对象).容器内的对象
就是元素,元素都是引用类型。
PS:容器内存储的都是对象的地址
二、与数组的区别？
--相同点:都是容器(数据结构),用来存储多个数据
--不同点:
数组:可以存储基本数据类型
集合:只能存储引用数据类型
三、集合框架中包含多种接口,抽象类,实现类等,用此来满足我们
所需要的用于存储数据的数据结构.
四、Collection与Collections的区别:
Collection:是集合的父接口，定义了集合框架中常用的抽象方法
Collections:是集合的工具类，定义了很多用于操作集合对象的 "工厂/工具方法"
五、子接口:List,Set，Queue
--List:存储此接口实现类的数据,有序,可重复
有序:存储时与添加的顺序相关,有对应的索引/下标标记位置,
从0开始
重复:存储的元素可以是同一个,也可以是对象内容相同的不同对象
根据元素的equals方法进行判断
六、数组与集合之间的转换
1、集合转数组
Object[] toArray()
E[] toArray(E[] e);
2、数组转集合
List Arrays.asList(数组参数);
注意:数组转成的集合,
不能进行增删操作,否则会出现运行时异常.
可以进行替换操作，但是对数组变量有影响.
如果想要成功进行增删操作,可以将元素存入新的集合中.
七、 Iterator：迭代器接口
(1)迭代器的作用是用来遍历集合元素。是一个接口。
Collection接口提供一个方法 Iterator iterator()
(2)Collection的实现类使用内部类定义了迭代器子类。
(3)迭代器提供了统一的方法，用于遍历集合元素。
--常用方法：
boolean hasNext():
判断集合中是否有下一个元素
E next():
取出集合中的下一个元素
void remove():
在使用迭代器对集合进行遍历时，不能使用集合的移除方法
移除集合的元素。必须使用迭代器自己提供的移除才行。
1.增强for循环-foreach循环。
for(元素类型 变量名:要遍历的集合或者数组){
}
与经典for循环的区别：
(1)增强for循环中无法使用下标。
(2)经典for循环中可以使用下标。跟下标有关的逻辑，随便写。
===================================================================================================================
*泛型机制:
(1)概念
jdk1.5版本开始使用的新特性,本质是进行"参数化类型",
在类,接口,方法的定义上都可以使用，用来指定数据类型名的。
(2)集合在定义时，可以用泛型机制来指定元素的类型，这样
编译器在编译期间就可以进行检查元素类型是否匹配，避免了
程序在运行时出现过多的错误
(3)集合框架中的所有类型(接口，抽象类，实现类)都是用了
泛型机制
(4)泛型机制的参数只能传引用类型。