java 集合框架使程序处理集合数组的方法标准化。集合框架包含了一组标准的接口。对这些接口，提供了几个标准的实现工具（LinkedList、HashSet 和 TreeSet）;

集合接口：

集合接口类图如下：

Collection 接口

Collection 接口是构造集合框架的基础。它声明所有类集合都将拥有的核心方法。因为所有类集合实现 Collection，所以熟悉它的方法对于清楚地理解框架是必要的。

注意：其中几个方法可能会引发一个 UnsupportedOperationException 异常，这些发生在当类集合不能被修改时。当一个对象与另一个对象不兼容，例如，当企图增加一个不兼容的对象到一个集合中时，将产生一个ClassCastException异常。

Collection 定义的方法：

List接口

List接口继承了 Collection 并声明了类集的新特性。使用一个基于 零 的下标，元素可以通过他们在列表中的位置被插入和访问。一个列表可以包含重复元素。

处理 由 Collection 定义的方法之外，List 还定义了一些它自己的方法。注意：当类集合不能被修改时，其中的几种方法引发 UnsupportOperationException 异常当一个对象与另一个对象不兼容，例如，当企图增加一个不兼容的对象到一个类集中时，将产生一个ClassCastException异常。

List 定义的方法：

Set 和 sortSet 接口
set 接口定义了一个集合，它继承了 collection 并说明了不允许重复元素的类集的特性。因此，如果试图将仇富元素加到集合时， add() 方法将返回 false,它本身并没有定义任何附件的方法。

SortSet 接口继承了 Set 并说明了按升序排列的集合的特性。当没有元素包含在调用集合中时，其中的几种方法引发 NoSuchElementException 异常。当对象与集合中的元素不兼容时，引发 ClassCastException 异常。如果试图使用 null 对象，而集合不允许 null 时，将引发 NullPointerException 异常。

SortedSet定义的方法：

Queue 和 Deque 接口

Queue< E >接口（E表示集合元素的类型）扩展了 Collection 接口、定义了一个队列数据结构的操作方式。队列定义了一个 “头” 位置， 它是下一个将要被移除的元素。除了从 Collection 继承的操作外，还提供了 插入，提取和检查操作。每个方法都存在两种形式。一种 抛出异常（操作失败时），另一种返回一个特殊值（null 或 false ，具体取决于操作）。插入操作的一种形式是用于专门为有容量限制的 Queue 实现设计的；在大多数实现中，插入操作不会失败。

Queue定义的方法：

remove() 和 poll() 方法可移除 和返回队列的头。到底从队列中移除哪个元素是队列排序策略的功能，而该策略在各种实现中是不同的。 remove() 和 poll() 方法仅在队列为空时其行为有所不同，remove() 方法抛出一个异常，而 poll () 方法则返回 null。

element () 和 peek() 返回但不移除队列的头。

Queue 接口并未定义阻塞队列的方法，而这种情况在并发编程中是很常见的。
BlockingQueue 接口定义了那些等待元素出现或等待队列中有可用空间的方法，这些方法扩展了此接口。

Queue 实现通常不允许插入null元素。尽管某些实现（如 LinkedList）并不禁止插入null.即使 在允许 null 的实现中，也不应该将 null 插入到 Queue 中。因为 null 也用做 poll 方法的一个特殊返回值，表明队列不包含元素。

Deque 定义了一个双端队列数据结构，支持在两端插入和移除元素。大多数Deque 实现对于他们能够包含的元素数有没固定的限制，但此接口即支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。

此接口定义在双端队列两端访问元素的方法，提供插入，移除，和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值 (null 或是 false,具体取决于操作）。插入操作的后一种形式是转为使用容量限制的Deque实现设计的；在大多数实现中，插入操作不能失败。

Deque 定义的方法

此接口扩展了 Queue 接口。在将双端队列用作队列时，将得到 FIFO （现金先出）行为。
将原始添加到双端队列的末尾，从双端队列的开头移除元素。
从Queue 接口继承的方法完全等效于 Deque 方法。
双端队列也可用作 LIFO(后进先出）堆栈。应优先使用此接口而不是遗留 Stack l类。在将双端队列用作堆栈时，元素被推入双端队列的开头并从双端队列开头弹出。堆栈方法完全等效于Deque 方法。

虽然 Deque 实现没有严格要求禁止插入 null 元素，但 建议最好不要插入 null 元素。建议任何事实上允许 null 元素的 Deque 实现，用户最好不要利用插入 null 的功能。这是因为各种方法会将null用作特殊的返回值来指示双端队列为空

1.Collection接口的常用方法

1.Collection中能存放什么元素
  没有使用泛型之前，collection中可以存储object的所有子类型
  使用了泛型之后，collection中只能存储某个具体的类型
  集合中不能存储基本数据类型，也不能存java对象，只能存储java对象的内存地址。

2.Collection中常用方法：
注意:collection中包含的方法在它的实现类中也有,也可以使用，是公共的。
boolean add(Object e)

//Collection c=new Collection(); //接口是抽象的，无法实例化
boolean add(Object e) 向集合中添加元素
int size(); 获取集合中元素的个数
void clear(); 清空集合中的所有元素
boolean contains(Object o)：判断当前集合中是否包含元素o,包含返回true,不包含返回false
boolean remove(Object o) 删除集合中的某个元素
boolean isEmpty() 判断该集合中的元素个数是否为0
Obect [] toArray() 将集合转换为数组

public static void main(String[] args) {
    //Collection c=new Collection();      //接口是抽象的，无法实例化
    Collection c=new ArrayList();
    //测试collection接口中的常用方法
    c.add(1200);      //自动装箱，实际上是放进去了一个对象的内存地址。Integer i=new Integer(1200)
    c.add(3.14);      //自动装箱
    c.add(new Object());
    c.add(true);
    //获取集合中元素的个数
    System.out.println("集合中元素的个数"+c.size());
    //清空集合
    c.clear();
    System.out.println("集合中元素的个数"+c.size());
    //再向集合中添加元素
    c.add("hello");
    c.add("world");
    c.add("好客");
    c.add("绿巨人");
    //判断集合中是否包含绿巨人
    boolean flag=c.contains("绿巨人");
    System.out.println(flag);     //true
    boolean flag2=c.contains("绿巨人2");
    System.out.println(flag2);    //false

    System.out.println("集合中元素的个数"+c.size());

    //删除集合中某个元素
    c.remove("绿巨人");
    System.out.println("集合中元素的个数"+c.size());

    //判断集合是否为空
    System.out.println(c.isEmpty());      //false
    c.clear();
    System.out.println(c.isEmpty());      //true
}

输出
集合中元素的个数4
集合中元素的个数0
true
false
集合中元素的个数4
集合中元素的个数3
false
true

2.Collection集合迭代

public static void main(String[] args) {
          //注意：以下的遍历方式/迭代方式，是所有collection通用的一种方式
          //在Map集合中不能用，在所有的collection以及子类中使用
          //创建集合对象
          Collection c=new ArrayList();//后面的集合无所谓，主要是看前面的collection接口，怎么遍历/迭代
          //添加元素
          c.add("abc");
          c.add("def");
          c.add(100);
          c.add(new Object());
          //对集合Collection进行遍历/迭代
          //第一步:获取集合对象的迭代器对象Iterator
          //collection为什么能调用这个方法，因为继承了Iterable接口，可使用其父类的方法
          Iterator it=c.iterator();
          //第二步：通过以上获取的迭代器对象，开始迭代遍历集合
/*
 以下两个方法是迭代器Iterator中的方法
 boolean hasNext()如果仍有元素可以迭代，则返回true
 Object next() 返回迭代的下一个元素
 
 void remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素（可选操作）
 * */
          while(it.hasNext()){
              //不管你当初存进去的是什么，取出来统一都是object
              Object obj=it.next();
              System.out.println(obj);
          }
  }

输出
abc
def
100
java.lang.Object@15db9742

迭代器是一个对象，有两个方法hasnext()和next()。
迭代器是通用的。

public static void main(String[] args) {
    //HashSet集合。无序不可重复
    //无序：存进去和取出的顺序不一定相同
    //不可重复:存进去100，不能再存100
    Collection c=new HashSet();
    c.add(100);
    c.add(200);
    c.add(90);
    c.add(300);
    c.add(600);
    c.add(30);
    c.add(100);
    Iterator it=c.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
}

输出
100
200
600
90
300
30

3.contains方法解析

深入collection集合的contains方法
boolean contains(Object o)
判断集合中是否包含某个对象o,如果包含，返回true,如果不包含返回false
contains底层里面调用了equals方法。

Collection c=new ArrayList();
String s1=new String("abc");      //内存地址假设s1=0x1111
c.add(s1);
String s2=new String("def");      //内存地址假设s2=0x2222
c.add(s2);

String x=new String("abc");          //内存地址假设s3=0x3333
//c集合中是否包含x
//contains里面调用了equals方法
System.out.println(c.contains(x));

输出：true
contains方法是用来判断集合中是否包含某个元素的方法
那么它在底层是它在底层中是怎么判断集合中是否包含某个元素的呢？
调用了equals方法进行比对
equals方法返回true,就表示包含这个元素。
对于一些对象类型，则需要重写其equals方法。

4.集合中元素的删除

public static void main(String[] args) {
    //创建集合
    Collection c=new ArrayList();
    //注意：此时获取的迭代器，指向的是那是集合中没有元素状态下的迭代器 
    //一定要注意：集合结构只要发生改变，迭代器必须重新获取
    Iterator it=c.iterator();
    //添加元素
    c.add(1);
    c.add(2);
    c.add(3);
    while(it.hasNext()){
        Object obj=it.next();
        System.out.println(obj);
    }
}

当集合结构发生了改变，迭代器没有重新获取时，调用next()方法，会发生异常

重点：
当集合结构发生改变时，迭代器必须重新获取，如果还是用以前的迭代器，会出现异常
删除元素之后，集合的结构发生变化，应该重新获取迭代器，但是循环下一次的时候，并没有重新获取迭代器，所以会出现异常

public static void main(String[] args) {
    //创建集合
    Collection c=new ArrayList();

    //添加元素
    c.add("abc");
    c.add("def");
    c.add("ghi");
    Iterator it=c.iterator();
    while(it.hasNext()){
        Object obj=it.next();
        //删除元素之后，集合的结构发生变化，应该重新获取迭代器，但是循环下一次的时候，并没有重新获取迭代器，所以会出现异常
        c.remove(obj);
        System.out.println(obj);
    }
}

在迭代集合元素的过程中，不能调用集合对象的remove方法，否则会出现异常。
可以使用迭代器的remove方法

//创建集合
Collection c=new ArrayList();

//添加元素
c.add("abc");
c.add("def");
c.add("ghi");
Iterator it=c.iterator();
while(it.hasNext()){
    Object obj=it.next();
    it.remove();
    //c.remove(obj);
    System.out.println(obj);
}
System.out.println(c.size());

输出0；

5.List接口的特有方法

测试list接口的常用方法
1.list集合存储元素特点：有序且重复
有序：list集合中的元素有下标，从0开始，以1递增。
可重复：存储一个1，还可以继续存储1
2.list既然是collection接口的子接口，那么肯定list接口中有自己“特色”的方法
以下只列举出list接口特有的常用方法
void add(int index,E element);
E get(int index);
E remove(int index);
E set(int index,E element);
void add(int index,E element);在列表的指定位置插入指定元素(第一个参数是下标)

public static void main(String[] args) {
    //创建list类型的集合
    List myList=new ArrayList();
    //添加元素
    myList.add("A");      //默认是向集合末尾添加元素
    myList.add("B");
    myList.add("C");
    myList.add("D");
    //在列表的指定位置插入指定元素(第一个参数是下标)
    //效率有点低。
    myList.add(1,"king");
    //迭代
    Iterator it=myList.iterator();
    while(it.hasNext()){
        Object et1=it.next();
        System.out.println(et1);
    }
}

E get(int index);根据下标获取元素

//根据下标获取元素
Object firstObj = myList.get(0);
System.out.println(firstObj);
//因为有下标，所以List集合有自己比较特殊的遍历方式
//通过下标遍历,list集合特有的方式，set没有
for(int i=0;i<myList.size();i++){
    Object obj = myList.get(i);
    System.out.println(obj);
}

E remove(int index);
删除指定下标位置的元素

//删除指定下标位置的元素
//删除下标为0的元素
System.out.println(myList.size());
myList.remove(0);
System.out.println(myList.size());

//修改指定位置的元素
myList.set(2, "soft");

以上几个方法不需要死记硬背，理解一下，找帮助文档。

6.Set接口

HashSet的特点：无序且不可重复

//演示HashSset的特点
Set<String> strs=new HashSet<>();
//添加元素
strs.add("hello3");
strs.add("hello4");
strs.add("hello1");
strs.add("hello2");
strs.add("hello3");
strs.add("hello3");
//遍历
for(String s:strs){
    System.out.println(s);
}

输出
hello1
hello4
hello2
hello3
1.存储时顺序和取出的顺序不同
2.不可重复
3.放到hashSet集合的元素实际上是放到HashMap集合的key部分了。
TreeSet集合存储元素的特点
无序不可重复的，但是存储的元素可以自动按照大小顺序排序，称为可排序集合

//创建集合对象
Set<String> strs=new TreeSet<>();
//添加元素
strs.add("A");
strs.add("B");
strs.add("Z");
strs.add("Y");
strs.add("Z");
strs.add("K");
strs.add("M");
//遍历set集合
//从小到大自动排序
for(String s:strs){
    System.out.println(s);
}

输出
A
B
K
M
Y
Z

无序指的是存进去的顺序和取出来的顺序不同，元素没有下标
排序是按照从小到大的顺序排序

      C#开发经常用到.NET框架为我们提供的集合接口和集合类，接下来做一个总结，如有差错，希望各位大神指正。

      首先是集合接口，自己画了一张图（嘿嘿，有点丑），来说明集合接口的继承关系。

       个人觉得，了解集合接口，首先要把握他们的继承关系。如上图，所有的集合接口和集合类都继承/实现IEnumerable接口。IEnumerable只有一个方法GetEnumerator。签名如下：

IEnumerator GetEnumerator()

        这个方法返回值类型为IEnumerator，正是IEnumerator 接口定义了集合遍历的基本方法，使得我们可以通过遍历来访问集合中的元素。

public interface IEnumerator
{
    bool MoveNext();
    object Current {  get; }
    void Reset();
}

MoveNext方法是将游标移动到下一个位置，Current 属性表示当前项，Reset方法是将游标重置到第一个项的位置。

其他的各个接口都提供了各种方法，这些都可以直接在开发工具上查看，暂时略过。接下来说说集合类。

集合类是在实现集合接口的基础上，做进一步的扩展。分为非泛型集合类、泛型集合类、线程安全集合类。

非泛型集合类:

1:ArrayList,ArrayList是可变长度的数组，它的出现就是为了弥补数组的长度是固定的这个缺陷。但他也带来了另一个问题，ArrayList可以存储任意类型的数据，所以它也存在装箱拆箱所带来的性能问题。所以，后来.NET2.0以后，就用List<T>取代ArrayList 

2:HashTable 键值对存取，Key不能重复。通过Key来查找Value时，速度非常快，但是存取时也存在装箱拆箱操作。所以后来就被Dictionary<TKey,TValue>所取代。

3:Stack 先进后出，个人一直觉得 栈是一个非常伟大的发明。

4:Queue 先进先出。

泛型集合类：

1:List<T> 可变长度，并且是有序的。所以如果在其尾部增加或删除数据，那速度比较快。如果在其头部或中间增加或删除数据，那速度比较慢，因为还要重新排序。

2:LinkedList<T> 它是一个双向链表，这也是为了弥补List<T>的缺陷而出现的。不管在什么位置删除数据，速度都很快。

3:HashSet<T> 它是无序的，不允许通过下标访问。当对两个集合进行差集、并集运算的时候，它的性能非常好。

4:SortedSet<T>它是有序的，与HashSet<T>对应。它可以通过Key来索引，也可以通过下标来索引。但是他的性能比HashTable差。

5:Stack<T> 先进后出

6:Queue<T> 先进先出

7:Dictionary<TKey, TValue> 它是对HashTable的优化，不必进行装箱拆箱操作。多线程情况下推荐使用HashTable,因为Dictionary<TKey, TValue>是非线程安全的，在多线程情况下，要进行lock锁定，这时效率就比较差了。

线程安全集合类   一般情况下，非线程安全的集合类，可以通过加上lock来锁定。.NET提供了线程安全集合类

1:ConcurrentDictionary  线程安全的Dictionary

2:ConcurrentQueue    线程安全版本的Queue

3:ConcurrentStack    线程安全版本的Stack

以上是个人对C#集合接口和集合类的总结，部分接口和类可能没有接触到。如有遗漏，欢迎交流补充。

另外送大家一点福利，鞋服买一送一，扫二维码，加微信