在 Java 中数组的长度是不可修改的。然而在实际应用的很多情况下，无法确定数据数量。这些数据不适合使用数组来保存，这时候就需要使用集合。

Java 的集合就像一个容器，用来存储 Java 类的对象。有些容器内部存放的东西在容器内部是不可操作的，像水瓶里的水，除了将其装入和倒出之外，就不能再进行别的操作了，但是很容易装入和倒出；而有些容器内部存放的东西在容器内部是可以操作的，例如，衣柜里面摆放的衣服，不仅可以将衣服存放到衣柜中，还可以将衣服有序地摆放，以便在使用时快速查找，但是却不容易取出。Java 的集合类比这些容器功能还多，其中有些是方便放入和取出的，有些是方便查找的。在集合中经常会用到泛型来使集合更加安全。

集合

集合类都位于 java.util 包，其中提供了一个表示和操作对象集合的统一构架，包含大量集合接口，以及这些接口的实现类和操作它们的算法。一个集合是一个对象，但它表示一组对象，Java 集合中实际存放的是对象的引用值，不能存放基本数据类型值。

集合中的接口

集合框架是一个类库的集合，包含实现集合的接口。接口是集合的抽象数据类型，提供对集合中所表示的内容进行单独操作的可能。
Collection 接口：该接口是最基本的集合接口，一个 Collection 代表一个元素。
List 接口：该接口实现了 Collection 接口。List 是有序集合，允许有相同的元素。使用 List 能够精确地控制每个元素插入的位置，用户能够使用索引（元素在 List 中的位置，类似于数组下标）来访问 List 中的元素，与数组类似。
Set 接口：该接口也实现了 Collection 接口。它不能包含重复的元素，SortedSet 是按升序排列的 Set 集合。
Map 接口：包含键值对，Map 不能包含重复的键。SortedMap 是一个按升序排列的 Map 集合。

接口实现类

Java 平台提供了许多数据集接口的实现类。例如实现 Set 接口的常用类有 HashSet 和 TreeSet，它们都可以容纳所有类型的对象，但是不能保证序列顺序永久不变

实现 List 接口的常用类有 ArrayList 和 LinkedList，它们也可以容纳所有类型的对象包括 null，并且都保证元素的存储位置。

实现 Map 映射的类是 HashMap，可实现一个键到值的映射。
HashSet：为优化査询速度而设计的 Set。它是基于 HashMap 实现的，HashSet 底层使用 HashMap 来保存所有元素，实现比较简单。
TreeSet：该类不仅实现了 Set 接口，还实现了 java.util.SortedSet 接口，该实现类是一个有序的 Set，这样就能从 Set 里面提取一个有序序列。
ArrayList：一个用数组实现的 List，能进行快速的随机访问，效率高而且实现了可变大小的数组。
LinkedList：对顺序访问进行了优化，但随机访问的速度相对较慢。此外它还有 addFirst()、addLast()、getFirst()、getLast()、removeFirst() 和 removeLast() 等方法，能把它当成栈（Stack）或队列（Queue）来用。

Collection接口

Collection 接口是 List 接口和 Set 接口的父接口，通常情况下不被直接使用。Collection 接口定义了一些通用的方法，通过这些方法可以实现对集合的基本操作。因为 List 接口和 Set 接口继承自 Collection 接口，所以也可以调用这些方法

boolean add(E e)    向集合中添加一个元素，E 是元素的数据类型
boolean addAll(Collection c)    向集合中添加集合 c 中的所有元素
void clear()    删除集合中的所有元素
boolean contains(Object o)  判断集合中是否存在指定元素
boolean containsAll(Collection c)   判断集合中是否包含集合 c 中的所有元素
boolean isEmpty()   判断集合是否为空
Iterator<E>iterator()   返回一个 Iterator 对象，用于遍历集合中的元素
boolean remove(Object o)    从集合中删除一个指定元素
boolean removeAll(Collection c) 从集合中删除所有在集合 c 中出现的元素
boolean retainAll(Collection c) 仅仅保留集合中所有在集合 c 中出现的元素
int size()  返回集合中元素的个数
Object[] toArray()  返回包含此集合中所有元素的数组

public static void main(Strmg[] args)
{
    ArrayList list1=new ArrayList();    //创建集合 iist1
    ArrayList list2=new ArrayList();    //创建集合 Iist2
    list1.add("one");    //向 list1 添加一个元素
    list1.add("two");    //向 list1 添加一个元素
    list2.addAll(list1);    //将 list1 的所有元素添加到 list2
    list2.remove(0);   //删除第一个元素 
}

List集合

List 接口实现了 Collection 接口，它主要有两个实现类：ArrayList 类和 LinkedList 类。在 List 集合中允许出现重复元素。与 Set 集合不同的是，在 List 集合中的元素是有序的，可以根据索引位置来检索 List 集合中的元素，第一个添加到 List 集合中的元素的索引为 0，第二个为 1，依此类推

ArrayList 类

ArrayList 类提供了快速的基于索引的成员访问方式，对尾部成员的增加和删除支持较好。使用 ArrayList 创建的集合，允许对集合中的元素进行快速的随机访问

ArrayList()：构造一个初始容量为 10 的空列表。
ArrayList(Collection<?extends E>c)：构造一个包含指定 Collection 的元素的列表，这些元素是按照该 Collection 的迭代器返回它们的顺序排列的。

ArrayList 类除了包含 Collection 接口中的所有方法之外，还包括 List 接口

E get(int index)    获取此集合中指定索引位置的元素，E 为集合中元素的数据类型
int index(Object o) 返回此集合中第一次出现指定元素的索引，如果此集合不包含该元
素，则返回 -1
int lastIndexOf(Obj ect o)  返回此集合中最后一次出现指定元素的索引，如果此集合不包含该
元素，则返回 -1
E set(int index, E element) 将此集合中指定索引位置的元素修改为 element 参数指定的对象。
此方法返回此集合中指定索引位置的原元素
List<E> subList(int fromlndex, int tolndex)返回一个新的集合，新集合中包含 fromlndex 和 tolndex 索引之间的所有元素。包含 fromlndex 处的元素，不包含 tolndex 索引处的元素

List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
list.add("4");

list.get(0);//得到1

List sublist=new ArrayList();
sublist=list.subList(0,2); //subList 为1,2

LinkList类

LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素。需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高
LinkedList 类除了包含 Connection 接口和 List 接口

void addFirst(E e)  将指定元素添加到此集合的开头
void addLast(E e)   将指定元素添加到此集合的末尾
E getFirst()    返回此集合的第一个元素
E getLast() 返回此集合的最后一个元素
E removeFirst() 删除此集合中的第一个元素
E removeLast()  删除此集合中的最后一个元素

LinkedList<String> products=new LinkedList<String>();    //创建集合对象
String product1=new String("product1");
String product2=new String("product2");

products.getFirst();//得到product1

Set集合

Set 集合也实现了 Collection 接口，它主要有两个实现类：HashSet 类和 TreeSet类。Set 集合中的对象不按特定的方式排序，只是简单地把对象加入集合，集合中不能包含重复的对象，并且最多只允许包含一个 null 元素

HashSet

HashSet 类是按照哈希算法来存储集合中的元素，使用哈希算法可以提高集合元素的存储速度，当向 Set 集合中添加一个元素时，HashSet 会调用该元素的 hashCode() 方法，获取其哈希码，然后根据这个哈希码计算出该元素在集合中的存储位置,

HashSet()：构造一个新的空的 Set 集合。
HashSet(Collection<? extends E>c)：构造一个包含指定 Collection 集合元素的新 Set 集合。其中，“< >”中的 extends 表示 HashSet 的父类，即指明该 Set 集合中存放的集合元素类型。c 表示其中的元素将被存放在此 Set 集合中。

HashSet hs=new HashSet();                     //调用无参的构造函数创建HashSet对象
HashSet<String> hss=new HashSet<String>();    //创建泛型的 HashSet 集合对象
String name=new String("HelloWorld");
String name1=new String("HelloWorld1");
hss(name); 
hss(name1); 

如果向 Set 集合中添加两个相同的元素，则后添加的会覆盖前面添加的元素，即在 Set 集合中不会出现相同的元素

TreeSet

TreeSet 类同时实现了 Set 接口和 SortedSet 接口。SortedSet 接口是 Set 接口的子接口，可以实现对集合升序排序。TreeSet 只能对实现了 Comparable 接口的类对象进行排序，因为 Comparable 接口中有一个 compareTo(Object o) 方法用于比较两个对象的大小

包装类（BigDecimal、Biglnteger、 Byte、Double、
Float、Integer、Long 及 Short) 按数字大小比较
Character   按字符的 Unicode 值的数字大小比较
String  按字符串中字符的 Unicode 值的数字大小比较

TreeSet 类除了实现 Collection 接口的所有方法之外，还有以下方法

E first()   返回此集合中的第一个元素。其中，E 表示集合中元素的数据 类型
E last()    返回此集合中的最后一个元素
E poolFirst()   获取并移除此集合中的第一个元素
E poolLast()    获取并移除此集合中的最后一个元素
SortedSet<E> subSet(E fromElement,E toElement)  返回一个新的集合，新集合包含原集合中 fromElement 对象与 toElement
对象之间的所有对象。包含 fromElemen t对象，不包含 toElement 对象
SortedSet<E> headSet<E toElement〉   返回一个新的集合，新集合包含原集合中 toElement 对象之前的所有对象。
不包含 toElement 对象
SortedSet<E> tailSet(E fromElement) 返回一个新的集合，新集合包含原集合中 fromElement 对象之后的所有对
象。包含 fromElement 对象

TreeSet<Double> treeSet=new TreeSet<Double>(); 
treeSet.add(0.02);
treeSet.add(0.01);
treeSet.add(0.03);
for(int i=0;i<treeSet.toArray().length;i++)
{
     System.out.print(treeSet.toArray.toArray()[i]); //依次输出 0.01,0.02,0.03
}
SortedSet<Double> headTreeSet =scores.headSet(0.02); //headTreeSet内只有0.01

自然排序时只能向 TreeSet 集合中添加相同数据类型的对象，否则会抛出 ClassCastException 异常

Map集合

Map 是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键对象和一个值对象。其中，键对象不允许重复，而值对象可以重复，并且值对象还可以是 Map 类型的，Map 接口主要有两个实现类：HashMap 类和 TreeMap 类。其中，HashMap 类按哈希算法来存取键对象，而 TreeMap 类可以对键对象进行排序

Map 接口中提供的常用方法

V get(Object key)   返回 Map 集合中指定键对象所对应的值。V 表示值的数据类型
V put(K key, V value)   向 Map 集合中添加键-值对，返回 key 以前对应的 value，如果没有， 则返回 null
V remove(Object key)    从 Map 集合中删除 key 对应的键-值对，返回 key 对应的 value，如 果没有，则返回null
Set entrySet()  返回 Map 集合中所有键-值对的 Set 集合，此 Set 集合中元素的数据 类型为 Map.Entry
Set keySet()    返回 Map 集合中所有键对象的 Set 集合

Map map=new HashMap();
map.put("1","HelloWorld");
map.put("2","HelloWorld");

Collection类

Collections 类提供了许多操作集合的静态方法，借助这些静态方法可以实现集合元素的排序、填充和复制等操作

正向排序

sort() 方法主要有如下两种重载形式。

void sort(List list)：根据元素的自然顺序对集合中的元素进行升序排序。
void sort(List list,Comparator comparator)：按 comparator 参数指定的排序方式对集合中的元素进行排序。

List test=new ArrayList();
test.add(2);
test.add(1);
test.add(3);
Collections.sort(test); //此时数组为1，2，3

逆向排序

调用 reverse() 静态方法可以对指定集合元素进行逆向排序

void reverse(List list)    //对集合中的元素进行反转排序

List test=new ArrayList();
test.add(2);
test.add(1);
test.add(3);
Collections.reverse(test); //此时数组为3，2，1

复制

Collections 类的 copy() 静态方法用于将指定集合中的所有元素复制到另一个集合中

void copy(List <? super T> dest,List<? extends T> src)

List srcList=new ArrayList();
destList.add("1");
destList.add("2");
List destList=new ArrayList();
Collections.copy(destList,srcList);//此时destList为1，2

填充

Collections 类的 fill() 静态方法可以对指定集合的所有元素进行填充操作

void fill(List<? super T> list,T obj)    //使用指定元素替换指定列表中的所有元素

List test=new ArrayList();
test.add("1");
test.add("2");
Collections.fill(srcList,"0"); //此时List里全是0

泛型

泛型可以在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高了代码的重用率。

泛型集合

泛型本质上是提供类型的“类型参数”，也就是参数化类型。我们可以为类、接口或方法指定一个类型参数，通过这个参数限制操作的数据类型，从而保证类型转换的绝对安全。

public class Person{
     private String name;
     public Person(String _name)
    {
        this.name=_name;
    }
}
Map<Integer, Person> persons=new HashMap<Integer, Person>();    //定义泛型 Map 集合
persons.add(new Person("HelloWorld"));

Map<Integer, Person> persons =new HashMap<Integer, Person>();”创建了一个键类型为 Integer、值类型为 Person 的泛型集合，即指明了该 Map 集合中存放的键必须是 Integer 类型、值必须为 Person 类型，否则编译出错。

Person preson = persons.get(0);//在获取 Map 集合中的元素时，不需要将"persons.get(id);"获取的值强制转换为 Person 类型，程序会隐式转换

泛型类

除了可以定义泛型集合之外，还可以直接限定泛型类的类型参数。

public class class_name<data_type1,data_type2,…>{}
//泛型类一般用于类中的属性类型不确定的情况下。
private data_type1 property_name1;

在实例化泛型类时，需要指明泛型类中的类型参数，并赋予泛型类属性相应类型的值

public class Person<T>{
    private T param;
    public T getParam(){
        return param;
   }
   public void setParam(T _param){
        this. param = _param;
   }
}
public class Employee{
    //类型体
}
public static void main(String[] args){
    //约束为整形
    Person<Integer> intergerPerson = new Person<Integer>();
    intergerPerson. setParam(1);
    //约束为字符串类型
    Person<String> intergerPerson1 = new Person<String>();
    intergerPerson1. setParam("String");
    //除基础类型外，也可以约束为自定义类型
    Person<Employee> intergerPerson2 = new Person<Employee>();
    intergerPerson1. setParam(new Employee());
}

泛型类中的类型参数可以有多个

public class Person<T,N,S>{
    //使用同上
}

泛型方法

泛型同样可以在类中包含参数化的方法，而方法所在的类可以是泛型类，也可以不是泛型类。
泛型方法使得该方法能够独立于类而产生变化。如果使用泛型方法可以取代类泛型化，那么就应该只使用泛型方法。另外，对一个 static 的方法而言，无法访问泛型类的类型参数。因此，如果 static 方法需要使用泛型能力，就必须使其成为泛型方法。

[访问权限修饰符][static][final]<类型参数列表>返回值类型方法名([形式参数列表])
public static<T> void Test(T t){
}
String helloWorld = "HelloWorld";
Test("HelloWorld");