JAVA 容器总结 v1.0

因为数组大小不允许修改。所以

Java 提供丰富的容器用来满足程序员多样化的需求，方便数据的引用管理。

• List
• LinkedList
• ArrayList
• Map
• HashMap
• HashTable
• WeakHashMap
• Set

List

     LinkedList

     ArrayList

      Vector

          Stack

Set

Map

     Hashtable

     HashMap

     WeakHashMap

List

元素有序，元素可以重复

ArrayList

底层数据结构使用的是 数组结构，查询快，增删较慢，线程不同步

LinkedList

底层数据结构是 链表结构，查询较慢，增删较快

Vector

底层数据结构是数组，线程同步，查询，增删都很慢，被 ArrayList 代替了。

Map

HashTable

Hashtable的泛型只能够指定引用类型，如果需要使用int这种值类型，需要使用它们的封装类，如Integer对应int

HashMap

底层数据结构是数组，只是数组的每一项都是一条链。

HashMap 采用一种所谓的“Hash 算法”来决定每个元素的存储位置。

HashSet

Set类不允许其中存在重复的元素（集），无法添加一个重复的元素（Set中已经存在）。HashSet利用Hash函数进行了查询效率上的优化，其contain（）方法经常被使用，以用于判断相关元素是否已经被添加过。

HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key

Map的key和Set都有一个共同的特性就是集合的唯一性.TreeMap更是多了一个排序的功能

参考：

http://alex09.iteye.com/blog/539549

http://blog.sina.com.cn/s/blog_028bc2700101334i.html

SxtMap

---

package  com.vip.test.container2;

import  java.util.ArrayList;

import  java.util.Collections;

//import java.util.Comparator;

import  java.util.List;

/**

 * 就是动态数组，数组的复杂版本

 *  @author  qi.ren

 *

 */

public  class  ArrayList01 {

        public  static  void  main(String[]  args ) {

              List<Integer>  list  =  new  ArrayList<Integer>();

              

               for ( int  i  = 0;  i  < 10;  i ++) {

                      list .add( i );

              }

               list .add(102); //没有 frist , last 插入。

              

              System. out .println( list .size()); //数组个数

              

              System. out .println( list );

              

               list .remove(4);

              System. out .println( list );

              

               list .clear();

               list .add(99);

               list .add(88);

               list .add(111);

               list .add(77);

               list .add(180);

              System. out .println( list );

              

//            list.sort((Comparator<? super Integer>) list);

              Collections.sort( list ); //排序

              System. out .println( list );

       }

}

---

package  com.vip.test.container1;

import  java.util.LinkedList;

import  java.util.List;

/**

 * 双向链表

 *  @author  qi.ren

 * http://blog.csdn.net/jdsjlzx/article/details/41654295

 *

 * 栈实现：先进后出

 * addFirst 先进, getFirst 后出，removeFirst 出了要删除。

 * 队列：先进先出

 * addLast, getFirst, removeFirst

 */

public  class  Linkedlist {

        public  static  void  main(String[]  args ) {

              LinkedList<String>  llist  =  new  LinkedList<String>();

               llist .add( "a" );

               llist .add( "b" );

               llist .add( "c" );

               llist .add( "d" );

               llist .add( "e" );

              

               llist .remove(0); //元素下标从 0 开始。

              

               //打印第一个元素，最后一个元素，元素个数

              System. out .println( "链表的第一个元素: "  +  llist .getFirst() );

              System. out .println( "链表的最后一个元素 : "  +  llist .getLast() );

              System. out .println( "链表长度为： "  +  llist .size());

              

               //遍历输出元素值

               for (String  str :  llist ) {

                     System. out .println( str );

              }

              

              List  subl  =  llist .subList(1, 3); //父链表的 1 至 3 生成子链表（3 是第4 个，不含 第 4 个）

              System. out .println( subl );

              

               llist .add(1,  "aa" ); //插入的索引是插入后的索引位置

              System. out .println( llist );

               llist .addFirst( "a0" );

               llist .addLast( "alast" );

              System. out .println( llist );

               llist .removeFirst();

               llist .removeLast();

              System. out .println( llist );

               llist .clear(); //清空链表

              System. out .println( llist );

       }

}

---

package  com.vip.test.container3;

import  java.util.Hashtable;

public  class  Hashtable1 {

        public  static  void  main(String[]  args ) {

              Hashtable<String, String>  ht  =  new  Hashtable<String, String>();

               ht .put( "a1" ,  "b1" );

               ht .put( "a2" ,  "b2" );

               ht .put( "a1" ,  "a11" );

              

              System. out .println( ht );

              System. out .println( ht .size());

               //通过 KEY 删除元素

               ht .remove( "a1" );

              System. out .println( ht );

              

               //通过 KEY 判断元素是否存在

               boolean  r1  =  ht .containsKey( "a1" );

              System. out .println( r1 );

               boolean  r2  =  ht .containsKey( "a2" );

              System. out .println( r2 );

              

               //通过 VALUE 判断元素是否存在

               boolean  r3  =  ht .contains( "b2" );

              System. out .println( r3 );

               boolean  r4  =  ht .contains( "b2" );

              System. out .println( r4 );

              

               ht .put( "a3" ,  "b3" );

               ht .put( "a4" ,  "b4" );

               ht .put( "a5" ,  "b5" );

               //使用 keySet 获取哈希表的 key 集合，遍历 key 用 get(key) 获取对应的 value 遍历所有的值

               for (String  key  :  ht .keySet()) {

                     String  value  =  ht .get( key );

                     System. out .println( value );

              }

       }

}

---

package  com.vip.test.container4;

import  java.util.HashMap;

import  java.util.Iterator;

import  java.util.Map.Entry;

import  java.util.Set;

public   class  Hashmap01 {

        public   static   void  main(String[]  args ) {

              HashMap<String, Double>  map  =  new  HashMap<String, Double>();

               map .put( "语文" , 80.0);

               map .put( "数学" , 89.0);

               map .put( "英语" , 72.0);

               map .put( "自然" , 99.0);

              

              System. out .println( map );

              System. out .println( "语文："  +  map .get( "语文" ));

              System. out .println( map .containsKey( "语文" ));

              System. out .println( map .keySet());

              System. out .println( map .isEmpty());

              

               map .remove( "语文" );

              System. out .println( map .containsKey( "语文" ));

              

               //采用Iterator遍历HashMap

               //迭代器 : http://www.cnblogs.com/amboyna/archive/2007/09/25/904804.html

              Iterator  it  =  map .keySet().iterator();

               while ( it .hasNext()) {

                     String  key  = (String)  it .next();

                     System. out .println( "key: " +  key );

                     System. out .println( "value: " +  map .get( key ));

              }

              

                    

              //遍历HashMap的另一个方法

              Set<Entry<String, Double>>  sets  =  map .entrySet();

               for (Entry<String, Double>  entry  :  sets ) {

                     System. out .print( entry .getKey() +  ", " );

                     System. out .println(  entry .getValue());

              }

       }

}

---

参选：

http://www.cnblogs.com/chenssy/p/3521565.html