集合（Collection）
1. 什么是集合？
集合是一组对象组成的一个整体，又称为容器，集合类属于java.util包。集合不同于数组的地方在于，一是它的容量是可变的，二是集合中只能存储对象，不能存储基本数据类型
Java的集合类库有一大一小两派，一大由Collection接口带领，一小由Map接口带领。
2. Collection接口
Collection接口下有两大分支，分别为List接口和Set接口。注意，Collection是接口，而Collections则是java.util包下的一个具体类。
2.1 List接口
List集合中允许有重复对象。
2.1.1 ArrayList类
ArrayList分配了一个动态再分配的对象数组数组（说白了就是长度可变的数组），可以通过索引进行随机访问，但是插入删除比较麻烦，这与数组的特性是一致的。
List list = new ArrayList();
注：ArrayList是线程不安全的，即它的方法没有同步；而Vector是线程安全的，它的所有方法都是同步的。
2.1.2 LinkedList类
LinkedList采用链表结构保存对象，插入删除方便，但是访问慢，这和链表的特性是一致的。
List list2 = new LinkedList();
import java.util.ArrayList;
import java.util.List;
public class Gather{
public static void main(String[] args) {
List list = new ArrayList<>();
for(char ch = 'a'; ch <= 'z'; ch++){
list.add(ch);
}
int ran = (int)(Math.random()*(list.size()-1));
System.out.println("随机获取list中的元素："+list.get(ran));
list.remove(2);
for(int i = 0; i < list.size(); i++){
System.out.print(list.get(i)+" ");
}
}
}
ArrayList示例
2.2 Set接口
Set是没有重复元素的集合，遍历Set集合的顺序和插入顺序并不总是一致，Set集合中的元素可以看作是无序的。
2.2.1 HashSet类
HashSet基于散列表
举例：
public class People {
private String name;
private long id_card;
public People(String name, long id_card){
this.name = name;
this.id_card = id_card;
}
public long getId_card(){
return id_card;
}
public void setId_card(long id_card){
this.id_card = id_card;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
}
——————————华丽的分割线————————————
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class CollectionDemo {
public static void main(String[] args) {
Set<People> hashSet = new HashSet<People >();
hashSet.add(new People("张三", 2000));
hashSet.add(new People("李四", 2001));
hashSet.add(new People("王五", 2002));
Iterator<People> it = hashSet.iterator();
System.out.println("集合中的元素是：");
while(it.hasNext()){
People person = it.next();
System.out.println(person.getName()+" "+person.getId_card());
}
}
}
HashSet示例
2.2.2 TreeSet类
TreeSet树集是一个有序集合，可以以任意顺序将元素插入到集合中。遍历时，按照排序后的顺序呈现，排序是用红黑树完成的。
TreeSet如何知道元素的大小呢，在默认情况下，TreeSet假定插入的元素实现了Comparable接口。这个接口定义了一个方法：
Public interface Comparable<T>{
Int compareTo(T other);
}
通过Comparable接口定义排列顺序有局限性。对于一个给定的类，只能实现这个接口一次，如果想要使用不同规则，多次对类对象进行排序，就要用到Comparator对象传递给TreeSet构造器来定义排序规则。Comparator接口声明了一个带有两个显式参数的compare方法：
Public interface Comparator<T>{
Int compare(T a, T b);
}
与compareTo方法一样，如果a位于b之前compare方法则返回负值，相等返回0，否则返回正值。
如果按照描述信息进行排序，就直接定义一个实现Comparator接口的类：
Class ItemComparator implements Comparator<Item>{
Public int compare(Item a, Item b){
String descrA = a.getDescription();
String descrB = b.getDescription();
Return descrA.compareTo(descrB);
}
}
然后将这个类的对象传递给树集的构造器：
ItemComparator comp = new ItemComparator();
SortedSet<Item> sortByDescrition = new TreeSet<>(comp);
（总是就是，在构造TreeSet时，传给它一个对象参数，这个对象是实现了Comparator接口的类的一个实例，它定义了一种比较TreeSet集中元素的规则，就酱紫(⊙o⊙)哦）
注：在Java中，散列表用链表数组实现，每个链表被称为桶（bucket）。要想查找表中对象的位置，就要先计算它的散列码（也就是哈希码hashCode），然后与桶的总数取余，所得到的结果就是保存这个元素的桶的索引。例如，散列码76268，并且有128个桶，则对象应该保存在第108号桶中。
桶数是指用于收集具有相同散列值的桶的数目。标准类库使用的桶数是2的幂，默认值为16（为表大小提供的任何值都将被自动转换为2的下一个幂）。
散列表可以用于实现几个重要的数据结构，其中最简单的就是set类型。Set的add方法首先在集中查找要添加的对象，如果不存在，就将这个对象添加进去。
3.Map接口
Map提供了将键值映射到值的对象，键不能重复，一个键映射到一个值。
3.1 HashMap类
HashMap也叫散列映射表，它对键进行散列，散列或比较函数只能作用于键，与键关联的值不能进行散列或比较。
HashMap是基于哈希表的Map接口的实现，增删的效率更高。允许null值和null键。
3.2 TreeMap类
TreeMap也叫树映射表，用键的整体顺序对元素进行排序。
TreeMap类不仅实现了Map类，还实现了java.util.SortedMap接口，因此集合中元素具有一定的顺序。增删效率比HashMap差。由于映射关系是根据键对象按照一定的顺序排列的，所以不允许键值为null
public class Emp {
private String e_id;
private String e_name;
public Emp(String e_id,String e_name){
this.e_id = e_id;
this.e_name = e_name;
}
public String getE_id() {
return e_id;
}
public void setE_id(String e_id) {
this.e_id = e_id;
}
public String getE_name() {
return e_name;
}
public void setE_name(String e_name) {
this.e_name = e_name;
}
}
—————————华丽的分割线———————————
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class MapText {
public static void main(String[] args) {
Map map = new HashMap();
Emp emp = new Emp("001","zhangsan");
Emp emp2 = new Emp("015","lisi");
Emp emp3 = new Emp("009","wangyi");
Emp emp4 = new Emp("011","tangbao");
map.put(emp.getE_id(), emp.getE_name());
map.put(emp2.getE_id(),emp2.getE_name());
map.put(emp3.getE_id(), emp3.getE_name());
map.put(emp4.getE_id(), emp4.getE_name());
Set set = map.keySet();
Iterator it = set.iterator();
//HashMap的无序是指既不是按照添加顺序，也不是按照键值大小顺序
/*HashMap中哈希码的定义
* public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
*Objects类中哈希码的定义(Objects继承自Object)
*public static int hashCode(Object o) {
return o != null ? o.hashCode() : 0;
}
*/
System.out.println("HashMap类实现的Map集合，无序：");
while(it.hasNext()){
String str = (String)it.next();
String name = (String)map.get(str);
System.out.println(str+":"+name);
}
TreeMap treemap = new TreeMap();
treemap.putAll(map);
Iterator it2 = treemap.keySet().iterator();
System.out.println("TreeMap 类实现的Map集合，键对象升序：");
while(it2.hasNext()){
String str = (String)it2.next();
String name = (String)map.get(str);
System.out.println(str+""+name);
}
}
}
TreeMap和HashMap
3.3其它
集合框架并没有将映射表视为一个集合，但是可以获得映射表的视图，这时一组实现了Collection接口的对象，或者它的子接口的视图。
有3个视图，分别是：键集、值集合（不是集）和键/值对集。键与键/值对形成了一个集，这是因为在映射表中一个键只能有一个副本。
Set<K> keySet()
Collection<K> values()
Set<Map.Entry<K,V>> entrySet()
注意：keySet既不是HashSet，也不是TreeSet，而是实现了Set接口的某个其他类的对象。Set接口扩展了Collection接口。
4.Iterator接口
通过迭代器Iterator接口可以遍历集合。
Iterator接口位于java.util包下，它有3个方法：
hasNext(): 如果还有元素可迭代，返回true
next(): 返回迭代的下一个元素
remove(): 删除上次调用next()方法时返回的元素（注意：对next()和remove()方法的调用具有相互依赖性，调用remove()之前没有调用next()是不合法的。如果想要删除后面的元素，必须通过调用next()越过前面的元素才行）
反复调用next()方法可以遍历集合，但是当到达了集合末尾，会抛出NoSuchElementException。
Collection<String> c = ...;
Iterator<String> iter = c.iterator();
while(iter.hasNext()){
String element = iter.next();
Do sth with element
}
//从Java SE 5.0 起，可以用for each循环来遍历
for(String element : c){
Do sth with element
}
Iterator接口
4.1迭代顺序
元素被访问的顺序取决于集合类型，如果对ArrayList进行迭代，从索引为0的位置开始，没迭代一次，索引加1。如果访问的是HashSet，元素将按随机顺序出现，虽然可以保证遍历，但无法预知访问次序。
4.2 ListIterator接口
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.ListIterator;
public class ListIteratorDemo {
public static void main(String[] args) {
ArrayList<Integer> array = new ArrayList<>();
Collections.addAll(array, 1,2,3,4,5,6);
System.out.println("集合中的元素："+array);
ListIterator<Integer> iterator = array.listIterator();
boolean hasNext = iterator.hasNext();
System.out.println("集合是否还有下一个元素："+hasNext);
boolean hasPrevious = iterator.hasPrevious();
System.out.println("集合是否还有前一个元素："+hasPrevious);
System.out.println("nextIndex："+iterator.nextIndex());
System.out.println("next："+iterator.next());
System.out.println("nextIndex："+iterator.nextIndex());
System.out.println("next："+iterator.next());
System.out.println("previousIndex："+iterator.previousIndex());
System.out.println("previous："+iterator.previous());
System.out.println("nextIndex："+iterator.nextIndex());
System.out.println("next："+iterator.next());
//add将元素插入到nextIndex所指的位置
System.out.println("nextIndex："+iterator.nextIndex());
iterator.add(999);
System.out.println("向集合中添加999后："+array);
//set将next()返回的元素替换为100
iterator.next();
iterator.set(100);
System.out.println("集合中的元素："+array);
//remove将100删除
iterator.remove();
System.out.println("集合中的元素："+array);
}
}
ListIterator
5.Deque接口
Java SE 6中引入了Deque接口，并由ArrayDeque和LinkedList类实现。这两个类都提供了双端队列。在必要时可增加队列长度。
public interface Deque<E> extends Queue<E>
6.集合框架
框架（framework）是一个类的集，它奠定了创建高级功能的基础。框架包含很多超类，这些超类拥有非常有用的功能、策略和机制。框架使用者创建的子类可以扩展超类的功能，而不必重新创建这些基本的机制。例如，Swing就是一种用户界面的机制。
