Java集合类和HashMap遍历

JAVA 集合类介绍和使用

类关系示意图
Iterable(接口)
    │
    └ -- Collection （接口）
        ├ - List（接口）
        │ ├ - LinkedList  不同步  （构造同步：List list  =  Collections.synchronizedList( new  LinkedList(...));）
        │ ├ - ArrayList   不同步 
        │ └ - Vector      同步
        │　└ -- Stack     同步
        └ - Set
            ├ -- EnumSet
            ├ -- HashSet  -- LinkedHashSet
            └ -- TreeSet

Map
├ -- Hashtable
├ -- HashMap  -- LinkedHashMap
└ -- WeakHashMap

Map接口：
     |
     +   --  WeakHashMap: 以弱键 实现的基于哈希表的 Map。在 WeakHashMap 中，当某个键不再正常使用时，将自动移除其条目。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃，这就使该键成为可终止的，被终止，然后被回收。丢弃某个键时，其条目从映射中有效地移除，因此，该类的行为与其他的 Map 实现有所不同。此实现不是同步的。
     |
     +   --  TreeMap:该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。此实现不是同步的。
     |
     +   --  HashMap:基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用  null  值和  null  键。（除了非同步和允许使用  null  之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。此实现不是同步的。
     |
     +--  SortedMap: 进一步提供关于键的总体排序 的 Map。该映射是根据其键的自然顺序进行排序的，或者根据通常在创建有序映射时提供的 Comparator 进行排序。对有序映射的 collection 视图（由 entrySet、keySet 和 values 方法返回）进行迭代时，此顺序就会反映出来。要采用此排序方式，还需要提供一些其他操作（此接口是 SortedSet 的对应射）。

Collection接口：
     |
     +   --  Set接口:一个不包含重复元素的 collection。更正式地说，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个  null  元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象。
     |        |
     |        +   --  HashSet:此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用  null  元素。此类为基本操作提供了稳定性能，此实现不是同步的。
     |        |
     |        +   --  LinkedHashSet:具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，即按照将元素插入到 set中的顺序（插入顺序）进行迭代。注意，插入顺序不 受在 set 中重新插入的 元素的影响。此实现不是同步的。
     |        |
     |        +   --  TreeSet:基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。此实现为基本操作（add、remove 和 contains）提供受保证的 log(n) 时间开销。此实现不是同步的。
     |
     +   --  List接口:有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
            |
            +   --  ArrayList:List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括  null  在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于Vector 类，除了此类是不同步的。）每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。并未指定增长策略的细节，因为这不只是添加元素会带来分摊固定时间开销那样简单。此实现不是同步的。
            |
            +   --  LinkedList:List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括  null ）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。提供先进先出队列操作(FIFO)。此实现不是同步的。
            |
            +   --  Vector:Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。此实现是同步的.


Collection接口
　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
　　　　Iterator it  =  collection.iterator();  //  获得一个迭代子
　　　　 while (it.hasNext()) {
　　　　　　Object obj  =  it.next();  //  得到下一个元素
　　　　}
　　由Collection接口派生的两个接口是List和Set。
List接口
　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。
　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类
　　LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list  =  Collections.synchronizedList( new  LinkedList(...));

ArrayList类
　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

Vector类
　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的 Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

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

  */

package  myapp.data;
import  myapp.model.Article;

import  java.text.DateFormat;
import  java.text.ParseException;
import  java.util. * ;
import  java.util.Map.Entry;

public   class  CollectionMethodTest {
    
     private   static  List < Article >  list = new  ArrayList < Article > ( 6 );
    
     public   static   void  initialize()  throws  ParseException{
         
         DateFormat df  =  DateFormat.getDateInstance(DateFormat.LONG, Locale.FRANCE);
         list.add( new  Article( 1 , " NBA1 " , " Carl1 " , " NBA Start1 " ,df.parse( " 2010-01-1 " ), 1 ));
         list.add( new  Article( 2 , " NBA2 " , " Carl2 " , " NBA Start2 " ,df.parse( " 2010-01-2 " ), 2 ));
         list.add( new  Article( 3 , " NBA3 " , " Carl3 " , " NBA Start3 " ,df.parse( " 2010-01-3 " ), 3 ));
         list.add( new  Article( 4 , " NBA4 " , " Carl4 " , " NBA Start4 " ,df.parse( " 2010-01-4 " ), 4 ));
         list.add( new  Article( 5 , " NBA5 " , " Carl5 " , " NBA Start5 " ,df.parse( " 2010-01-5 " ), 5 ));
         list.add( new  Article( 6 , " NBA6 " , " Carl6 " , " NBA Start6 " ,df.parse( " 2010-01-6 " ), 6 ));
     }
    
    
      // 列表通常允许重复的元素 ，允许NULL元素，有序
      // 原型:public interface List extends Collection
      // 常用实现类：    AbstractList, ArrayList, LinkedList, Stack, Vector
      public   void  listTest(){
         
     }
     
     // HashMap:允许使用 null 值和 null 键,不同步，实现了Map接口和AbstractMap抽象类
     // 原型：public class HashMap extends AbstractMap implements Map, Cloneable, Serializable
      public   void  hashMapTest(){
         System.out.println( " --------HashMap遍历------ " );
         
         Map < Integer, String >  map = new  HashMap < Integer,String > ();
          for (Article a : list){
             map.put(a.getId(), a.getTitle() + a.getContent());
         }
         // 得到map的所有的键
         Set < Integer >  keys = map.keySet();
         // 得到map的所有的值
         Collection < String >  values = map.values();
         // 返回包含在此映射中的映射关系的 Set 视图。
        Set < Map.Entry < Integer, String >>  setEntry = map.entrySet();
         // 使用Iterator遍历器遍历
        System.out.println( " --------使用Iterator遍历器遍历------ " );
        Iterator < Entry < Integer,String >>  it  =  setEntry.iterator();
         while (it.hasNext()){
            Entry < Integer,String >  e  =  it.next();
            System.out.println( " Id: " + e.getKey() + "  Description: " + e.getValue());
        }
         // 使用for遍历
        System.out.println( " --------使用for遍历------ " );
         for (Entry < Integer,String >  e:setEntry){
            System.out.println( " Id: " + e.getKey() + "  Description: " + e.getValue());
        }
     }
     
      // Set:一个不包含重复元素的 collection。更正式地说，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素
      // 原型：public interface Set extends Collection
      // 实现类：    AbstractSet, EnumSet, HashSet, LinkedHashSet, TreeSet、 JobStateReasons,CopyOnWriteArraySet
      public   void  setTest(){
         Set < String >  set = new  HashSet < String > ();
         set.add( " No1 " );
         set.add( " No2 " );
         set.add( " No3 " );
     }
}

转载于:https://www.cnblogs.com/hubcarl/archive/2011/04/07/2007815.html