新手笔记：java集合汇总

参考资料：http://www.cnblogs.com/xwdreamer/archive/2012/05/30/2526822.html

                    http://blog.youkuaiyun.com/touchSea/article/details/750923

先上图，java集合的结构

集合主要实现的接口collection

接口：Collection

所有集合类的根类型，主要的一个接口方法：boolean add(Ojbect c)

add

public boolean add(E e)

确保此 collection 包含指定的元素（可选操作）。如果此 collection 由于调用而发生更改，则返回 true。（如果此 collection 不允许有重复元素，并且已经包含了指定的元素，则返回 false。）

支持此操作的 collection 可以限制哪些元素能添加到此 collection 中来。需要特别指出的是，一些 collection 拒绝添加 null 元素，其他一些 collection 将对可以添加的元素类型强加限制。Collection 类应该在其文档中清楚地指定能添加哪些元素方面的所有限制。

如果 collection 由于某些原因（已经包含该元素的原因除外）拒绝添加特定的元素，那么它必须 抛出一个异常（而不是返回 false）。这确保了在此调用返回后，collection 总是包含指定的元素。

此实现总是抛出一个 UnsupportedOperationException。

指定者：

接口 Collection<E> 中的 add

参数：

e - 确定此 collection 中是否存在的元素。

返回：

如果此 collection 由于调用而发生更改，则返回 true

抛出：

UnsupportedOperationException - 如果此 collection 不支持 add 操作

ClassCastException - 如果指定元素的类不允许它添加到此 collection 中

NullPointerException - 如果指定的元素为 null，并且此 collection 不允许 null 元素

IllegalArgumentException - 如果元素的某属性不允许它添加到此 collection 中

IllegalStateException - 如果由于插入限制，元素不能在此时间添加

其总需要注意的是：虽返回的是boolean，但不是表示添加成功与否，因为Collection规定：一个集合拒绝添加这个元素，无论什么原因，都必须抛出异常，这个返回值表示的意义是add()执行后，集合的内容是否改了（就是元素有无数量、位置等变化）。类似的addAll，remove，removeAll，remainAll也是一样的。

collection的实现方法中有一个十分重要的方法是Iterator

iterator

public abstract Iterator<E> iterator()

返回在此 collection 中的元素上进行迭代的迭代器。

指定者：

接口 Iterable<E> 中的 iterator

指定者：

接口 Collection<E> 中的 iterator

返回：

在此 collection 中的元素上进行迭代的迭代器。

具体的方式为： for(Iterator it = c.iterator(); it.hasNext();) {...}

除此之外，java还提供了一个接口方法

java.util
接口 Iterator<E>

所有已知子接口：

ListIterator<E>, XMLEventReader

所有已知实现类：

BeanContextSupport.BCSIterator, EventReaderDelegate, Scanner

public interface Iterator<E>

对 collection 进行迭代的迭代器。迭代器取代了 Java Collections Framework 中的 Enumeration。迭代器与枚举有两点不同：

• 迭代器允许调用者利用定义良好的语义在迭代期间从迭代器所指向的 collection 移除元素。
• 方法名称得到了改进。

此接口是 Java Collections Framework 的成员。 

package listTest;

import java.util.ArrayList;
import java.util.Iterator;

public class ListTest
{

  /**
   * @param args
   */
  public static void main ( String[ ] args )
  {
    ArrayList<String> arrList = new ArrayList<String>( );
    arrList.add( "1" );
    arrList.add( "2" );
    arrList.add( "3" );
    Iterator<String> it = arrList.iterator( );
    for ( int i = 0 ; i < arrList.size( ) ; i ++ )
    {
      String str = arrList.get( i );
      System.out.println( "根据list集合为：" + str );
    }
    for ( int i = 0 ; it.hasNext( ) ; i ++ )
    {
      String str = it.next( );
      System.out.println( "根据itertar集合为：" + str );
    }
  }

}

显示的结果为：

根据list集合为：1
根据list集合为：2
根据list集合为：3
根据itertar集合为：1
根据itertar集合为：2
根据itertar集合为：3

对于it.hasNext( ) 来说，他是判断是否有下一个元素，与i无关

1.HasSet

是Set接口的一个子类，主要的特点是：里面不能存放重复元素，而且采用散列的存储方法，所以没有顺序。这里所说的没有顺序是指：元素插入的顺序与输出的顺序不一致。

package listTest;

import java.util.HashSet;
import java.util.Iterator;

public class ListTest
{
  /**
   * @param args
   */
  public static void main ( String[ ] args )
  {
    HashSet<String> hs = new HashSet<String>( );
    hs.add( "1" );
    hs.add( "1" );
    hs.add( "1" );
    hs.add( "1" );
    Iterator it = hs.iterator( );
    while(it.hasNext( ))
    {
      System.out.println( "各个元素为：" + it.next( ) );
    }
  }
}

结果为：

各个元素为：1

package listTest;

import java.util.HashSet;
import java.util.Iterator;

public class ListTest
{
  /**
   * @param args
   */
  public static void main ( String[ ] args )
  {
    HashSet<String> hs = new HashSet<String>( );
    hs.add( "1" );
    hs.add( "2" );
    hs.add( "1" );
    hs.add( "2" );
    Iterator it = hs.iterator( );
    while(it.hasNext( ))
    {
      System.out.println( "各个元素为：" + it.next( ) );
    }
  }
}

结果为：

各个元素为：2
各个元素为：1

经测试为无序，即 元素插入的顺序与输出的顺序不一致，不含重复元素。

2.ArrayList

它和HashSet相反，允许存放重复元素。如果对ArrayList进行访问，迭代器将从索引0开始，每迭代一次，索引值加1。然而，如果访问HashSet中的元素，每个元素将会按照某种随机的次序出现。虽然可以确定在迭代过程中能够遍历到集合中的所有元素，但却无法预知元素被访问的次序。大部分情况下，可以把ArrayList看作一个数组对待。寻址容易，插入和删除困难。

package listTest;

import java.util.ArrayList;
import java.util.Iterator;

public class ListTest
{
  /**
   * @param args
   */
  public static void main ( String[ ] args )
  {
    ArrayList<String> hs = new ArrayList<String>( );
    hs.add( "1" );
    hs.add( "2" );
    hs.add( "1" );
    hs.add( "2" );
    Iterator it = hs.iterator( );
    while(it.hasNext( ))
    {
      System.out.println( "各个元素为：" + it.next( ) );
    }
  }
}

显示结果为：

各个元素为：1
各个元素为：2
各个元素为：1
各个元素为：2

3.LinkList
LinkedList是一种可以在任何位置进行高效地插入和删除操作的有序序列。：寻址困难，插入和删除容易。

package listTest;

import java.util.Iterator;
import java.util.LinkedList;

public class ListTest
{
  /**
   * @param args
   */
  public static void main ( String[ ] args )
  {
    LinkedList<String> hs = new LinkedList<String>( );
    hs.add( "1" );
    hs.add( "2" );
    hs.add( "1" );
    hs.add( "2" );
    Iterator it = hs.iterator( );
    while(it.hasNext( ))
    {
      System.out.println( "各个元素为：" + it.next( ) );
    }
  }
}

结果为：

各个元素为：1
各个元素为：2
各个元素为：1
各个元素为：2

4.HashMap

HashMap里面实现一个静态内部类Entry，其重要的属性有 key , value, next，从属性key,value我们就能很明显的看出来Entry就是HashMap键值对实现的一个基础bean，我们上面说到HashMap的基础就是一个线性数组，这个数组就是Entry[]，Map里面的内容都保存在Entry[]里面。

基本算法

//存储时:
int hash = key.hashCode();// 这个hashCode方法这里不详述,只要理解每个key的hash是一个固定的int值
int index = hash % Entry[].length;
Entry[index] = value;

//取值时:
int hash = key.hashCode();
int index = hash % Entry[].length;
return Entry[index];

比较

		是否有序	是否允许元素重复
Collection		否	是
List		是	是
Set	AbstractSet	否	否
	HashSet
	TreeSet	是（用二叉排序树）
Map	AbstractMap	否	使用key-value来映射和存储数据，key必须唯一，value可以重复
	HashMap
	TreeMap	是（用二叉排序树）