java的集合总结篇

java的集合

简化图

1. 首先集合类都位于java.util包下，Java集合类只要是由两个接口派生而出的：collection和Map。collection和Map这两个接口是集合框架的根接口，两个接口又包含了一些子接口和实现类
2. 集合接口：6个接口（短虚线表示），表示不同集合类型，是集合框架的基础。
3. 抽象类：5个抽象类（长虚线表示），对集合接口的部分实现。可扩展为自定义集合类。
4. 实现类：8个实现类（实线表示），对接口的具体实现。
5. collection接口是一组允许重复的对象。
6. Set接口继承Collection,集合元素不允许重复。
7. List接口继承Collection，允许重复，维护元素插入顺序。
8. Map接口是键-值对象，与Collection接口没有什么关系。
9. Set、List和Map可以看做集合的三大类:
   1. List集合是有序的集合，它里面的元素是可以重复，访问集合里面的元素可以让通过元素的索引进行访问
   2. Set集合是一个无序的集合，它里面的元素是不可以重复的，访问集合里面的元素也是根据元素本身来访问（也是不允许重复的原因）
   3. Map集合中保存key-value形式的元素，访问时只能根据key来访问value

总体分析

看上面的框架图，主干是Collection和Map。

1. Collection是个接口，是一个高度抽象的集合，它包含了集合的基本方法和属性。Collection包含List和Set两大分支。注意Map不是Collection的子接口，这个要牢记。
   1. List是一个有序的队列，每一个元素都有他的索引。第一个元素索引是0，List的实现类是LinkedList、ArrayList、Vector、Stack。
   2. Set是一个不允许有重复元素的集合。Set的实现类有HashSet和TreeSet。HashSet是依赖于HashMap的，就是HashSet是通过HashMap实现的。TreeSet是依赖于TreeMap，就是说TreeSet是通过TreeMap实现的。
2. Map是一个映射（除了类集，映射是一个存储关键字和值的管理或者说是关键字/值对的集合）接口，即key-value键值对。Map中的每一个元素包含一个“key”和“value”。AbstractMap是一个抽象类，它实现了Map接口的大部分API。而HashMap、TreeMap、WeakHashMAp都是继承于AbstractMap。Hashtable虽然继承于Dictionary，但是它实现了Map接口。
3. Iterator接口。他是集合的工具，既我们通常通过Iterator来遍历集合。我们说Collection依赖于Iterator，是因为Collection的实现类都要实现Iterator()函数，返回一个Iterator对象，ListIterator专门是为了遍历List而生的。
4. 再看Enumeration，它是JDK 1.0引入的抽象类。作用和Iterator一样，也是遍历集合；但是Enumeration的功能要比Iterator少。在上面的框图中，Enumeration只能在Hashtable, Vector, Stack中使用。
5. 最后，看Arrays和Collections。它们是操作数组、集合的两个工具类。

List接口

1. List接口继承于Collection接口，它可以定义一个允许重复的有序集合。因为List中的元素是有序的，所以我们可以通过使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
2. List接口为Collection直接接口。List所代表的是有序的Collection，即它用某种特定的插入顺序来维护元素顺序。用户可以对列表中每个元素的插入位置进行精确地控制，同时可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。实现List接口的集合主要有：ArrayList、LinkedList、Vector、Stack。

ArrayList

1. 是一个动态数组
2. 扩容每次增打1.5倍（newLength=oldLength+(oldLength>>1)）扩容到旧的大小的1.5倍。
3. 如果我们明确所插入元素的多少，最好指定一个初始容量值，避免过多的进行扩容操作而浪费时间、效率。
4. 允许任何规则的元素插入包括null
5. size、isEmpty、get、set、iterator 和 listIterator 操作都以固定时间运行。add 操作以分摊的固定时间运行，也就是说，添加 n 个元素需要 O(n) 时间（由于要考虑到扩容，所以这不只是添加元素会带来分摊固定时间开销那样简单）
6. ArrayList擅长于随机访问。同时ArrayList是非同步的。
7. 插入效率底

LinkedList

1. 是一个双向链表

2. 除了ArrayList的基本操作还加了get，remove，insert方法在LinkedList的首部和尾部。

3. 由于实现方法的不同，LinkedList不能随机访问，它的所有操作都是按照双向链表的操作执行的。在列表中索引将从头或者结尾还是遍历列表（从靠近指定索引的一端）。这样做的好处就是可以通过较底的代价zaiList中进行插入和删除操作。

4. 与ArrayList一样，LinkedList也是非同步的。如果多个线程同时访问LinkedList时，测必须实现访问同步，一种解决方法就是在创建List时就构造一个同步的List：

 List list=Collections.synchronizedList(new LinkedList(...));

Vector

1. 于ArrayList相似，但是Vector是同步的，所以说Vector是一个线程安全的动态数组。他的操作与ArrayList几乎是一样的。

Stack

1. Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop 方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

List的不同点

Set接口

HashSet

1. Set是一种不包含重复的元素的Collection，无序（这里说的无序是指：元素的插入顺序与输出的顺序不一致），即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。需要注意的是:虽然Set中元素没有顺序，但是元素在set中的位置是由该元素的HashCode决定的，其具体位置其实是固定的。

   1. 此外需要说明一点，在set接口中的不重复是有特殊要求的。

      举个例子：对象A和对象B是两个不同的对象，正常情况下它们是能够放入Set里面的，但是如果对象A和对象B都重写了hashcode和equals方法，并且重写后的hascode和equals方法是相同的话。那么A和B是不能同时放入Set集合中的，也就是说Set集合中的去重和对象放入对象的hashcode和equals方法直接相关。

      看下面例子：

      public class Test{ 
      public static void main(String[] args) { 
           Set<String> set=new HashSet<String>(); 
           set.add("Hello"); 
           set.add("world"); 
           set.add("Hello"); 
           System.out.println("集合的尺寸为:"+set.size()); 
           System.out.println("集合中的元素为:"+set.toString()); 
        } 
      }

      运行结果：

      集合的尺寸为:2
      集合中的元素为:[world, Hello]

      分析：由于String类重写了hashcode和equals方法，用来比较字符串对象多存储的字符串是否相等。所以这里的第二个Hello是加不进去的。

      例二：

      public class TestSet {
          
          public static void main(String[] args){
              
              Set<String> books = new HashSet<String>();
              //添加一个字符串对象
              books.add(new String("Struts2权威指南"));
              
              //再次添加一个字符串对象，
              //因为两个字符串对象通过equals方法比较相等，所以添加失败，返回false
              boolean result = books.add(new String("Struts2权威指南"));
              
              System.out.println(result);
              
              //下面输出看到集合只有一个元素
              System.out.println(books);    
      
          }
      }

      运行结果：

      false
      [Struts2权威指南]

      分析：book中两次添加的不是同一个对象（程序中通过new关键字来创建字符串对象），当使用运算符放回为false，使用equals方法返回为true，所以不能添加到Set集合中，就是说重写了equals和hashcode方法，因为equals不重写与无异。

2. **HashSet是HashMap实现的，**不保证顺序，而且允许插入一个null元素。

3. 是想方法大致如下：用过应给HashMap存储元素，元素是放在HashMap的Key中，而且Value统一使用一个Object对象。

4. **HashSet是非同步的，**如果多线程同时访问一个哈希set，而其中至少一个线程修改了该set，那么必须保证它外部同步。

5. HashSet按照Hash算法来储存集合的元素，因此具有很好的存取和查找的性能。

LinkedHashSet

1. LinkedHashSet继承与HashSet，其底层是基于LinkedHashMap来实现的，有序，非同步。
2. 。LinkedHashSet集合同样是根据元素的hashCode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。这样使得元素看起来像是以插入顺序保存的，也就是说，当遍历该集合时候，LinkedHashSet将会以元素的添加顺序访问集合的元素。

TreeSet

1. TreeSet是一个有序集合，其底层是基于TreeMap实现的，非线程安全。TreeSet可以确保集合元素处于排序状态。

2. TreeSet支持两种排序方式：自然排序和定制排序，其中自然排序是默认的排序方式

   1. 自然排序：

      1. 在添加单字符和数字是自动排序

         

      2. 在添加对象的时候就必须重写Compareto，否则如下：

         

      3. 自然排序需要Student类实现Comparable接口，并重写Compareto方法：

         1. 实现Comparable接口
            

         2. 重写Compareto方法
            

         3. 测试输出

            

   2. 定制排序

      1. 创建一个比较类，实现Comparator接口，并重写compare(T o1, T o2)方法：
         

      2. 创建集合对象时，使用指定的比较器进行比较
         

      3. 测试结果

         

Map接口

​ Map与List、Set结构不同，它是由一系列键值对组成的集合，提供了key和value的映射。Map接口没有继承Collection。在Map中它保证了key与value直接是一一对的关系。也就是说一个key对应一个value，所以不能存在相同的key值，value的值是可以相同的。

HashMap

1. ​ 以哈希表数据结构实现的，
2. 查找对象时通过哈希函数计算其位置，他是为了快速查询而设计的，
3. 其内部定义了一个hash表数组(Entry[] table)，元素会通过哈希转换函数将元素的哈希地址转换成数组中存放的索引
4. 如果出现存放冲突就会使用散列的链表的形式将所有相同的哈希地址的元素存放起来，可以通过查看HashMap。Entry的源码，它是一个单链表结构。

LinkedHashMap

1. LinkedHashMapsh是HashMap的一个子类，它保留了插入的顺序，如果需要输出的顺序和输入的顺序相同时，那么就选用LinkedHashMap。

2. LinkedHashMap是哈希表和连接例表实现的，具有可预知迭代顺序。此实现提供所有可选的映射操作，并且允许null值和null键。

3. 此类不保证；映射的顺序，特别是它不保证顺序恒久不变。

4. LinkedHashMap实现与HashMap的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。底层维护着一个双向循环链表（用于记录元素的插入顺序或访问顺序）。
   

5. 根据链表中元素的顺序可以分为：按插入顺序的链表，和按访问顺序(调用get方法)的链表。默认是按插入顺序排序，如果指定按访问顺序排序，那么调用get方法后，会将这次访问的元素移至链表尾部，不断访问可以形成按访问顺序排序的链表。

6. 不同步

7. 性能没有HashMap好，但是迭代访问Map里面的所有元素时将有更好的性能，因为底层用链表来维护顺序的。

TreeMap

1. 是一个有序得key-value集合，非同步，基于红黑树实现，每一个key-value都是红黑树得一个节点。

2. TreeMap存储会进行排序的，会根据key来对key-value键值进行排序，其中排序方式有两种，具体取决于使用的构造方法

   1. 自然排序
      1. TreeMap所有的的key都必须实现Comparaable接口，并且所有的key属于同一个类对象，否则会报ClassCastRxception异常
   2. 定制排序
      1. 定义TreeMap时，创建一个comparator对象，该对象对所有的treeMap中所有的key值进行排序，采用定制排序的时候不需要TreeMap中所有的key必须实现Comparable接口。

3. TreeMap判断两个元素相等的标准：两个key通过compareTo()方法返回0，则认为这两个key相等。

4. 如果使用自定义的类来作为TreeMap中的key值，且想让TreeMap能够良好的工作，则必须重写自定义类中的equals()方法，TreeMap中判断相等的标准是：两个key通过equals()方法返回为true，并且通过compareTo()方法比较应该返回为0。

   

@Iterator与ListIterator详解

Iterator

Iterator的定义如下：

public interface Iteraor<E> {}

1. Iterator是一个接口，它是集合的迭代器。集合可以通过Iteraor去遍历集合中的元素。Iterator提供的API接口如下：

   1. boolean hasNext():判断集合是否存在下一个元素。如果有，hasNext()方法返回true。
   2. Object next()：返回这个集合的下一个元素
   3. void remove：删除集合里上一次next方法返回元素。

2. 代码示例

   public class IteratorExample {
       public static void main(String[] args) {
           ArrayList<String> a = new ArrayList<String>();
           a.add("aaa");
           a.add("bbb");
           a.add("ccc");
           System.out.println("Before iterate : " + a);
           Iterator<String> it = a.iterator();
           while (it.hasNext()) {
               String t = it.next();
               if ("bbb".equals(t)) {
                   it.remove();
               }
           }
           System.out.println("After iterate : " + a);
       }
   }

   Before iterate : [aaa, bbb, ccc]
   After iterate : [aaa, ccc] 

3. 注意：

   1. Iterator只能单向移动。
   2. Iterator.remove()是唯一安全的方式来在迭代过程中修改集合；如果在迭代过程中以任何其它的方式修改了基本集合将会产生未知的行为。

ListIterator

ListIterator是一个功能更加强大的迭代器, 它继承于Iterator接口,只能用于各种List类型的访问。可以通过调用listIterator()方法产生一个指向List开始处的ListIterator, 还可以调用listIterator(n)方法创建一个一开始就指向列表索引为n的元素处的ListIterator.

ListIterator接口定义如下:

public interface ListIterator<E> extends Iterator<E> {
    boolean hasNext();
 
    E next();
 
    boolean hasPrevious();
 
    E previous();
 
    int nextIndex();
 
    int previousIndex();
 
    void remove();
 
    void set(E e);
 
    void add(E e);
     
} 

由以上定义我们可以推出ListIterator可以:

(1)双向移动（向前/向后遍历）.

(2)产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引.

(3)可以使用set()方法替换它访问过的最后一个元素.

(4)可以使用add()方法在next()方法返回的元素之前或previous()方法返回的元素之后插入一个元素.

使用示例：

public class ListIteratorExample {
 
    public static void main(String[] args) {
        ArrayList<String> a = new ArrayList<String>();
        a.add("aaa");
        a.add("bbb");
        a.add("ccc");
        System.out.println("Before iterate : " + a);
        ListIterator<String> it = a.listIterator();
        while (it.hasNext()) {
            System.out.println(it.next() + ", " + it.previousIndex() + ", " + it.nextIndex());
        }
        while (it.hasPrevious()) {
            System.out.print(it.previous() + " ");
        }
        System.out.println();
        it = a.listIterator(1);
        while (it.hasNext()) {
            String t = it.next();
            System.out.println(t);
            if ("ccc".equals(t)) {
                it.set("nnn");
            } else {
                it.add("kkk");
            }
        }
        System.out.println("After iterate : " + a);
    }
} 

输出结果如下：

Before iterate : [aaa, bbb, ccc]
aaa, 0, 1
bbb, 1, 2
ccc, 2, 3
ccc bbb aaa 
bbb
ccc
After iterate : [aaa, bbb, kkk, nnn]

[https://www.cnblogs.com/TestMa/p/10641367.html]:

    it.set("nnn");
        } else {
            it.add("kkk");
        }
    }
    System.out.println("After iterate : " + a);
}

}

输出结果如下：

```java
Before iterate : [aaa, bbb, ccc]
aaa, 0, 1
bbb, 1, 2
ccc, 2, 3
ccc bbb aaa 
bbb
ccc
After iterate : [aaa, bbb, kkk, nnn]

[https://www.cnblogs.com/TestMa/p/10641367.html]: