【Java】集合_学习笔记

一、集合

　　1、集合类也称容器类，主要负责保存、盛装其他数据。

　　2、集合可以保存数量不确定的数据，保存具有映射关系的数据（也称关联数组）。

　　3、Java5后提供一些多线程安全的集合类，放在java.util.concurrrent。（utility的缩写，意为多用途的，实用的）

　　4、集合只能保存对象（实际是对象的引用，习惯称对象）。

　　5、Java的集合主要由Collection和Map两个接口派生而出，Map接口的实现类用于保存关联数组，Set集合元素不可重复，通过元素本身访问，Map集合可以通过key值访问，List集合可以通过下标访问。

　　

二、Collection接口

　　1、Collection接口是Set、Queue、List接口的父接口，所以它的方法也可以操控着三个集合。

　　　　a、boolean add（Object o）：向指定集合里添加一个元素，指定集合对象因为这个方法改变，返回true。

　　　　b、boolean addAll（Collection c）：把集合c里的所有元素添加到指定集合里，指定集合对象因为这个方法改变，返回true。

　　　　c、void clean（）：清除指定集合的所有元素，将集合长度变为0。

　　　　d、boolean contains（Object o）：返回集合里是否包含指定元素。

　　　　e、boolean containsAll（Collection c）：返回集合是否包含集合c里的所有元素。

　　　　f、boolean isEmpty（）；返回集合是否为空，长度为0返回true，否则false。

　　　　g、boolean remove（Object o）：删除集合中的指定元素o，当集合中包含一个或多个元素o时，删除第一个符合条件的元素，返回true。

　　　　h。boolean removeAll（Collection c）：从集合里删除集合c包含的所有元素，删除一个或一个以上的元素，返回true。

　　　　i、boolean retainAll（Collection c）：从集合里删除集合c以外的元素，指定集合对象因为这个方法改变，返回true。

　　　　j、in size（）：返回集合里的元素个数、

　　　　k、Object[] toArray（）：把集合转换为一个数组，集合元素变为对应数组元素。

　　2、使用Iterator遍历集合元素

　　　　Iterator接口也称为迭代器，主要用于遍历Collection集合里的元素。

　　　　a、boolean hasNext（）：如果被迭代的集合的元素还没有迭代完，返回true。

　　　　b、Object next（）：返回集合里的下一元素。

　　　　c、void remove（）：删除集合里上次next放回的元素。

　　　　d、迭代是不要改变元素，否则容易引起java.util.ConcurrentModificationException异常。

　　　　下面代码说明如何使用Iterator

　　　　

 package com.example;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Iterator;

 public class MyClass {

     public static void main(String[] args) {
         //HashSet（）类应该是实现了Collection接口的一个类，否则不可能实例化
         Collection names = new HashSet();
         //添加的应该是引用，这里直接放字符串，是在常量池里？
         names.add("xiaoming");
         names.add("xiaogang");
         names.add("xiaoli");
         //通过Collection接口的实现类HashSet的对象的Iterator方法创建Iterator对象
         Iterator it = names.iterator();
         Iterator it1 = names.iterator();
         Iterator it2 = names.iterator();
         //判断集合里的元素是否迭代完成
         while (it.hasNext()){
             //扔进集合里的元素出来都是Object类，类型被遗忘，所以才需要泛型
             String name = (String)it.next();
             System.out.println(name);
             if(name.equals("xiaoli")){
                 //删除当前的next（）返回的对象
                 //it.remove();
             }
             //集合里的元素不会改变，因为name是一个迭代变量，只是赋值过来了，正真的对象没有过来，难道是创建了一个副本？否则引用指向同一对象怎么可能不改变。
            // name = "xiaohong";
         }
         while(it1.hasNext()){
             //如果上一句remove没有注释掉，在这里直接抛出异常，很奇怪
             String named = (String)it1.next();
             System.out.println(named);
         }
         while (it2.hasNext()){
             //不能在迭代是改变集合元素，否则会抛出异常.并没有抛出异常，程序一直执行，死循环。
             //names.add("xiaofang");
             names.remove("xiaoli");
         }
     }
 }

　　3、使用Foreach循环遍历集合元素　　

　　代码如下：

 import java.util.HashSet;
 import java.util.Objects;

 public class MyClass {
     public static void main(String[] args) {
         //HashSet（）类应该是实现了Collection接口的一个类，否则不可能实例化
         Collection names = new HashSet();
         //添加的应该是引用，这里直接放字符串，是在常量池里？
         names.add("xiaoming");
         names.add("xiaogang");
         names.add("xiaoli");
         for(Object theName_obj:names){
             String theName = (String) theName_obj;
             System.out.println(theName);
             //下面这句话会抛出ConcurrentModificationException，因为theName是一个迭代变量，不是元素本身
             if(theName.equals("xiaoli")){
                 names.remove(theName);
             }
         }
     }
 }

　　运行结果：

 xiaoming
 xiaoli
 Exception in thread "main" java.util.ConcurrentModificationException
     at java.util.HashMap$HashIterator.nextNode(HashMap.java:1437)
     at java.util.HashMap$KeyIterator.next(HashMap.java:1461)
     at com.example.MyClass.main(MyClass.java:15)
     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
     at java.lang.reflect.Method.invoke(Method.java:498)
     at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)

 Process finished with exit code 1

　　4、Set集合

　　Set接口和Collection接口基本一致，并没有提供额外的方法，除了限制不能有重复元素，没有什么区别。如果试图调用add（）方法添加两个相同的元素，会返回false。以上特性适用于实现了Set接口的HashSet、TreeSet、EnumSet类。

　　（1）HashSet类

　　　　HashSet类是Set接口的典型实现，一般使用Set接口都是使用HashSet类。

　　　　HashSet类按照Hash（散列）算法来存储集合中的元素，因此有很好的存储和查找性能。

　　　　HashSet有一下特点：

　　　　　　a、不能保证元素排列顺序，顺序可能与添加顺序不同。

　　　　　　b、HashSet不是同步的，多个线程访问同一HashSet，必须通过代码来保证同步。

　　　　　　c、集合的元素值可以是null。

　　　　　　d、HashSet集合比较两个元素是否相等是两个对象通过equals（）方法比较相等，而且两个对象hashCode（）方法返回值相等，才会认定两个元素相等，如果equals（）方法返回值相等，而hashCode（）方法返回值不相等，HashSet集合不认为两个元素相同，是可以添加的。

　　　　　　e、重写boolean equals（Object obj）方法时，应该也要重写int hashCode（）方法，当两个对象的equals方法返回值相等时，hashCode（）方法的返回值也应该相等。

　　　　　　f、HashSet集合每个能储存元素的槽位（slot）通常称为桶（bucket），如果多个元素的hashCode值相同而equals方法返回false，那么就得在一个桶里放多个元素，这样会导致性能下降。

　　　　重写hashCode()的一般步骤是：

　　　　　　a、按照下表，将对象里每一个有意义的实例变量计算出一个对应的int型hashCode值。

　　　　　　

　　　　　　b、将各个hashCode值组合计算出一个hashCode返回值，如：return f1.hashCode（）+（int）f2；

　　　　　　c、为避免直接相加产生的偶然相等，可以让hashCode值乘以一个任意质数再相加，如：return f1.hashCode（）*3+（int）f2*5；

　　　　HashSet集合里的元素不要随意修改，否则可能导致HashSet无法准确访问该元素，看一下例子。

 package com.example;

 import java.util.HashSet;

 public class MyClass {
         public static void main(String[] args){
             HashSet hs = new HashSet();
             A a = new A(1);
             hs.add(a);
             hs.add(new A(2));
             hs.add(new A(3));
             hs.add(new A(4));
             //直接打印hs集合？调用的是集合对象的toString方法？
             System.out.println(hs);
             //这里只是改变了counter的值，并没有改变hashCode值
             a.counter=2;
             System.out.println(hs);
             //因为重写了equals方法和hashCode方法，所以新建的对象在HashSet看来是同一元素
             hs.remove(new A(2));
             //其实被删掉的是第二个元素，因为删掉一个元素，需要hashCode值和equals方法返回true，第一个的hashcode值是1
             System.out.println(hs);
             //返回FALSE，因为该元素的equals方法返回FALSE，即使hashCode值相等。
             System.out.println("Is hs contain value of counter 1:"+hs.contains(new A(1)));
             //放回FALSE，因为该元素的hashCode值不相等，即使equals方法返回true。
             System.out.println("Is hs contain value of counter 2:"+hs.contains(new A(2)));
             //因此第一个元素在值被修改后，无法得到正常访问，所以HashSet里的元素谨慎修改
         }
 }
 class A{
     int counter;
     public A(int counter){
         this.counter = counter;
     }
     //重写了toString方法，会改变System.out.println的输出方式？
     public String toString(){
         return  "A[counter:"+counter+"]";
     }
     public boolean equals(Object obj){
         //如果它们指向的是同一个对象，那么它们相等
         if(this==obj){
             return true;
         }
         //如果相比较的引用不为null而且它们有父子继承关系，那么进行比较
         if(obj!=null&&obj.getClass()==A.class){
             A a = (A)obj;
             return this.counter==a.counter;
         }
         return false;
     }
     public int hashCode(){
         return this.counter;
     }
 }

[A[counter:1], A[counter:2], A[counter:3], A[counter:4]]
[A[counter:2], A[counter:2], A[counter:3], A[counter:4]]
[A[counter:2], A[counter:3], A[counter:4]]
Is hs contain value of counter 1:false
Is hs contain value of counter 2:false

　（2）LinkedHashSet类

　　LinkedHashSet类使用了链表来维护元素的顺序，所以性能比HashSet要低，但在迭代访问时，因为链表存在，所以性能高于HashSet类，LinkedHashSet类依旧是实现了Set接口，所以也不能有重复元素。

　　下面的代码展示了LinkedHashSet类的有序性。

 package com.example;
 import java.util.Iterator;
 import java.util.LinkedHashSet;

 public class MyClass {
     public static void main(String[] args) {
         //HashSet（）类应该是实现了Collection接口的一个类，否则不可能实例化
         LinkedHashSet names = new LinkedHashSet();
         //添加的应该是引用，这里直接放字符串，是在常量池里？
         names.add("xiaogang2");
         names.add("xiaoli3");
         names.add("xiaoming1");
         //通过Collection接口的实现类HashSet的对象的Iterator方法创建Iterator对象
         Iterator it = names.iterator();
         //判断集合里的元素是否迭代完成
         while (it.hasNext()) {
             //扔进集合里的元素出来都是Object类，类型被遗忘，所以才需要泛型
             String name = (String) it.next();
             System.out.println(name);
         }
     }
 }

xiaogang2
xiaoli3
xiaoming1

　　（3）TreeSet类

　　TreeSet类采用红黑树的数据结构来存储集合元素，支持两种排序方式：自然排序和定制排序。并提供以下的额外方法：

　　a、Comparator comparator():如果TreeSet采用定制排序，则该方法返回定制排序所使用的Comparator；如果采用自然排序，返回null。

　　b、Object first（）：返回集合中的第一个元素。

　　c、Object last（）：返回集合中的最后一个元素。

　　d、Object lower（Object e）：返回集合中刚好小于给定元素的那个元素，给定元素不一定要是集合里的元素。

　　e、Object higher（Object c）：返回集合中刚好大于给定元素的那个元素，给定元素不一定要是集合里的元素。

　　f、SortedSet subSet（Object fromElement，Object toElement）：返回此Set集合的子集合，范围从fromElement（包含）到toElement（不包含）。

　　g、SortedSet headSet（Object toElement）：返回此Set集合的子集，从头到toElement（不包含）的元素组成。

　　h、SortedSet tailSet（Object fromElement）：返回此Set集合的子集，从fromElement（包含）到尾巴的元素。

　　下面程序测试了TreeSet的用法

 package com.example;

 import java.util.TreeSet;

 public class MyClass {
     public static void main(String[] args) {
         TreeSet ts = new TreeSet();
         ts.add("a");
         ts.add("b");
         ts.add("c");
         ts.add("d");
         //上一次是重写了toString方法，这一次直接打印会是什么呢？String常量的toString就是自身？
         System.out.println(ts);
         System.out.println(ts.first());
         System.out.println(ts.last());
         System.out.println(ts.headSet("c"));
         System.out.println(ts.tailSet("c"));
         System.out.println(ts.subSet("a","c"));
     }
 }　

[a, b, c, d]
a
d
[a, b]
[c, d]
[a, b]

　　自然排序，就是就是调用集合元素的int compareTo（Object obj）方法来比较元素之间的大小关系，然后按升序排序。

　　因为是通过compareTo方法来比较大小的，所以两个元素应该是同一类型，否则会抛出异常，所以TreeSet类里应该只包含一种类型的元素。

　　TreeSet类判断两个元素是否相等的依据是：compareTo方法返回0，相等，否则不相等。

　　Java提供了一个comparable接口，里边有一个compareTo（Object obj）方法，返回一个整型，实现该接口的类必须实现该方法，实现了该接口的类的对象就可以比较大小了。

　　obj1.compareTo（obj.2），返回值0，两个对象相等。返回值正整数，obj1大于obj2。返回值负整数，obj1小于obj2。

　　想把一个对象添加到TreeSet集合里，它的类必须实现Comparable接口。

　　TreeSet里添加一个可变对象后，修改可变对象的值，但是集合不会对元素重新排序，而且很可能出现无法操作集合元素的情况， 所以不建议修改集合元素的值。

　　下列是实现了comparable接口的常用类和比较大小的规则：

　　a、BigDecimal、BigInteger和所有数值型对应的包装类：按对应的数值大小进行比较。

　　b、Character：按字符的UNICODE值进行比较。

　　c、Boolean：true对应的包装类对象大于false对应的包装类对象。

　　e、String：按字符串中字符的UNICODE值进行比较。

　　f、Date、Time：后面的时间、日期比前面的时间日期大。

 package com.example;

 import java.util.TreeSet;

 public class MyClass {
     public static void main(String[] args) {
         TreeSet ts = new TreeSet();

         ts.add(new A(1));
         ts.add(new A(10));
         ts.add(new A(-3));
         System.out.println(ts);
     }
 }
 class A implements Comparable{
     int age;
     public A(int age){
         this.age=age;
     }
     public String toString(){
         return "M[age:"+age+"]";
     }
     public boolean equals(Object obj){
         return true;
     }
     public int compareTo(Object o1){
         A a = (A)o1;
         return 1;
     }
 } 

 [M[age:1], M[age:10], M[age:-3]]

　　定制排序，将集合元素降序排序等。

　　要实现定制排序，需要提供一个Comparator对象和和该TreeSet对象关联。

　　Comparator接口里包含一个int compare（T o1，T o2）方法，o1大于o2，返回正整数，o1等于o2，返回0，o1小于o2，返回负整数。

　　下面代码实现降序：

 package com.example;

 import java.util.Comparator;
 import java.util.TreeSet;

 public class MyClass {
     public static void main(String[] args) {
         TreeSet ts = new TreeSet(new Comparator() {
             @Override
             //如果a1.age>a2.age，返回-1，说明a1指向的对象小于a2指向的对象，所以按照升序，a1在前，a2在后，即实现降序
             public int compare(Object o, Object t1) {
                 A a1=(A)o;
                 A a2=(A)t1;
                 return a1.age>a2.age?-1:a1.age<a2.age?1:0;
             }
         });
         //实现了Comparator接口的匿名内部类和TreeSet对象形成关联数组，在TreeSet对象添加元素时，compare方法将被调用。
         ts.add(new A(1));
         ts.add(new A(10));
         ts.add(new A(-3));
         System.out.println(ts);
     }
 }
 class A{
     int age;
     public A(int age){
         this.age=age;
     }
     public String toString(){
         return "M[age:"+age+"]";
     }
 }

 [M[age:10], M[age:1], M[age:-3]]

　　(4)EnumSet类

　　EnumSet类是一个专门为枚举类设计的集合插入其他类型的元素，会抛出ClassCastException异常。

　　是有序集合，顺序按照枚举值在Enum类的定义顺序。

　　以向量形式存储，紧凑、高效。

　　不允许插入null值，否则抛出NullPointerException异常。

　　EnumSet类没有暴露构造器来创建对象，可以通过以下类方法创建对象。

　　a、EnumSet allOf(Class elementType):创建一个包含指定枚举类里所有枚举值的EnumSet集合。

　　b、EnumSet complementOf（EnumSet s）：创建一个元素类型和指定EnumSet里元素类型相同的EnumSet集合，新的集合里是指定集合的补集。

　　c、EnumSet copyOf（Collection c）：使用一个普通集合来创建EnumSet集合。

　　d、EnumSet copyOf（EnumSet s）：创建一个与指定EnumSet集合具有相同类型元素、相同集合元素的EnumSet集合。

　　e、EnumSet noneOf（Class elementType）：创建一个元素类型为指定枚举类型的空EnumSet。

　　f、EnumSet of（E first，E ...rest）：创建一个或多个枚举值的EnumSet集合，传入的枚举值必须属于同一个枚举类。

　　g、EnumSet range（E from，E to）：创建一个包含from枚举值到to枚举值（不包含？）的EnumSet集合（同一枚举类？）。

　　以下程序示范了EnumSet类的用法：

 package com.example;
 import java.util.EnumSet;
 public class MyClass {
     public static void main(String[] args) {
         //.class是获取目标类型？
         EnumSet es1 = EnumSet.allOf(Season.class);
         System.out.println(es1);
         EnumSet es2 = EnumSet.noneOf(Season.class);
         System.out.println(es2);
         es2.add(Season.Fall);
         es2.add(Season.Spring);
         System.out.println(es2);
         EnumSet es3 = EnumSet.of(Season.Fall,Season.Spring);
         System.out.println(es3);
         //包含第二个元素
         EnumSet es4 = EnumSet.range(Season.Spring,Season.Summer);
         System.out.println(es4);
         //es5集合的元素是es4集合剩下的元素
         EnumSet es5 = EnumSet.complementOf(es4);
         System.out.println(es5);
     }
 }
 enum Season{
     Spring,Summer,Fall,Winter
 }

 [Spring, Summer, Fall, Winter]
 []
 [Spring, Fall]
 [Spring, Fall]
 [Spring, Summer]
 [Fall, Winter]

　　5、List集合

　　List接口是Collection接口的子接口，可以使用Collection接口的所有方法。

　　List集合是有序集合，所以增加了一下根据索引操作集合的方法：

　　a、void add（int index，Object element）：将元素element插入到集合的index处。

　　b、boolean addAll（int index，Collection c）：将集合c的所有元素都插入到集合的index处。

　　c、Object get（int index）：返回集合index处的元素。

　　d、int indexOf（Object o）：返回o对象第一次出现在集合中的位置索引。

　　e、int lastIndexOf（Object o）：返回对象o最后一次出现在集合中的位置索引。

　　f、Object remove（int index）：删除并返回index索引处的元素。

　　g、Object set（int index，Object element）：将index索引处的元素替换成element元素，并返回被替换的旧对象。

　　h、List subList（int fromIndex，int toIndex）：返回从fromIndex处（包含）到toIndex处（不包含）的集合。

　　以下程序显示了List集合一般用法：

 package com.example;
 import java.util.ArrayList;
 import java.util.List;
 public class MyClass {
     public static void main(String[] args) {
         List ls = new ArrayList();
         ls.add(new String("first_add"));
         ls.add(new Integer(2));
         ls.add(new Boolean(true));
         System.out.println(ls);
         ls.add(1,new String("first_insert"));
         for(int i=0;i<ls.size();i++){
             System.out.println(ls.get(i));
         }
         ls.remove(0);
         System.out.println(ls);
         //通过其他的对象引用反而匹配到了集合里的对象引用，因为List集合判断两个元素是否相等是通过equals方法是否返回true
         System.out.println(ls.indexOf(new String("first_insert")));
         //试试除了String类，其他类型是否也可以通过这种方法匹配。可以
         System.out.println(ls.indexOf(new Boolean(true)));
         ls.set(2,new Long(10));
         System.out.println(ls);
         System.out.println(ls.subList(0,2));
     }
 }

 [first_add, 2, true]
 first_add
 first_insert
 2
 true
 [first_insert, 2, true]
 0
 2
 [first_insert, 2, 10]
 [first_insert, 2]

　　（1）ArrayList和Vector实现类

　　　　ArrayList和Vector都是List接口的实现类，所以List接口的方法，它们都能使用。

　　　　ArrayList和Vector都封装了一个动态的、允许再分配的Object[]数组，ArrayList对象和Vector对象通过initialCapacity参数来设置数组长度，当元素超过数组长度时，长度自动增加。当知道需要一次性增加大量元素时，

　　　　可以使用ensureCapacity（int minCapacity）方法一次增加长度，可以减少重分配次数，提高性能，不指定initialCapacity时，Object[]数组长度默认为10。

　　　　以下方法可以重新分配Object[]数组：

　　　　a、void ensureCapacity（int minCapacity）：将Object[]数组的长度增加大于等于minCapacity值。

　　　　b、void trimToSize（）：调整Object[]数组长度为当前元素个数，这样可以节省空间。

　　　　Vector集合是一个非常古老的集合，有很多问题，应该尽量避免使用。

　　6、Queue集合

　　　　Queue接口用于模拟队列数据结构（先进先出）。

　　　　队列的头放在存放时间最长的元素，队列的尾放在存放时间最短的元素上。

　　　　新元素插入（offer）到队列的尾部，访问元素（poll）操作会返回队列的头部元素。

　　　　队列不允许随机访问队列中的元素。

　　　　Queue接口定义如下几个方法：

　　　　a、void add（Object c）：将指定元素加入此队列的尾部。

　　　　b、Object element（）：获取队列头部的元素，但是不删除该元素。

　　　　c、boolean offer（Object e）：将指定元素加入此队列的尾部。当Queue队列容量有限时，此方法比add好。

　　　　d、Object peek（）：获取队列头部元素，但是不删除该元素。如果队列为空，返回null。

　　　　e、Object poll（）：获取队列头部元素，并删除该元素，如果队列为空，返回null。

　　　　f、Object remove（）：获取队列头部元素，并删除该元素。

　　　（1）PriorityQueue实现类

　　　　PriorityQueue实现类是一个比较标准的队列实现，但不是绝对标准的队列实现。

　　　　因为它保存队列元素的顺序不是按照加入顺序保存的，而是对队列元素的大小进行了从新排序后保存的。

　　　　因此，PriorityQueue实现类违反了队列的基本原则：先进先出（FIFO）。

　　　（2）Deque接口和ArrayDeque实现类

　　　　Deque接口是Queue接口的子接口，代表一个双端队列，双端队列可以从两端添加、删除元素，所以也可以当成栈（先进后出）来使用。

　　　　以下是Deque定义的一些双端队列的方法：

　　　　a、void addFirst（Object e）：将指定元素插入该双端队列的开头。

　　　　b、void addLast（Object e）：将制定元素插入该双端队列的末尾。

　　　　c、Iterator descendingIterator（）：返回该双端队列的迭代器，该迭代器将以逆向顺序来迭代。

　　　　e、Object getFirst（）：获取但不删除双端队列的第一个元素。

　　　　f、Object getLast（）：获取但不删除双端队列的最后一个元素。

　　　　g、boolean offerFirst（）：将指定元素插入该双端队列的开头。

　　　　h、Boolean offerLast（）：将指定元素插入该双端队列的末尾。

　　　　i、Object peekFirst（）：获取但不删除该双端队列的第一个元素，队列为空，返回null。

　　　　j、Object peekLast（）：获取但不删除该双端队列的最后一个元素，队列为空，返回null。

　　　　k、Object pollFirst（）：获取并删除该双端队列的第一个元素，队列为空，返回null。

　　　　l、Object poolLast（）：获取并删除该双端队列的最后一个元素，队列为空，返回null。

　　　　m、Object pop（）：（栈方法）pop该双端队列所表示的栈的栈顶元素，相当于removeFirst（）。

　　　　n、void push（Object e）：（栈方法）将一个元素push进该双端队列的栈顶，相当于addFirst（）。

　　　　o、Object removeFirst（）：获取并删除该双端队列的第一个元素。

　　　　p、Object removeLast（）：获取并删除该双端队列的最后一个元素。

　　　　q、Object removeFirstOccurrence（Object o）：删除该双端队列第一次出现的元素o。

　　　　r、Object removeLastOccurrence（Object o）：删除该双端队列最后一次出现的元素o。

　　　　ArrayDeque实现类是一个基于数组实现的双端队列，它也有一个动态的可以重新分配的数组Object[]，数组长度由numElements指定，默认长度为16.

　　　　建议尽量避免使用Stack集合，因为Stack集合很古老。

　　　7、LinkedList实现类

　　　　LinkedList类实现了List接口和Deque接口，可以根据索引访问元素，可以被当做双端队列和“栈”来使用。

　　　　LinkedList类内部以链表来存储集合元素，在随机访问时性能较差，在插入、删除时性能较好。