List Set Map 实现类用法总结

 mport java.io.FileNotFoundException;  
 import java.io.FileOutputStream;  
 import java.io.IOException;  
 import java.io.OutputStream;  
 import java.util.ArrayList;  
 import java.util.Comparator;  
 import java.util.HashMap;  
 import java.util.HashSet;  
 import java.util.Hashtable;  
 import java.util.LinkedHashSet;  
 import java.util.LinkedList;  
 import java.util.ListIterator;  
 import java.util.Map;  
 import java.util.Properties;  
 import java.util.Set;  
 import java.util.TreeMap;  
 import java.util.TreeSet;  
 import java.util.concurrent.ConcurrentLinkedQueue;  
   
 public class TypeTest {  
   
     /**
      * ArrayList 优缺点 可以快速访问每个元素，调用get(i)方法来访问下标为i的数组元素。 添加对象速度慢，操作其中对象的速度慢 。
      */  
     private void arrayListTest() {  
         ArrayList<String> arrayList = new ArrayList<String>();  
         // 添加  
         arrayList.add(String.valueOf(1));  
         arrayList.add(new Integer(2).toString());  
         arrayList.add("3");  
         // 在指定位置插入对象  
         arrayList.add(0, new String("00"));  
   
         for (String str : arrayList) {  
             System.out.println(str); // 0,1,2,3  
         }  
   
         // 查询  
         // 返回位置  
         System.out.println(arrayList.indexOf("1")); // 1  
         // 返回指定位置的对象  
         System.out.println(arrayList.get(1)); // 1  
         // 判断对象是否存在  
         System.out.println(arrayList.contains("3")); // true  
   
         // 修改  
         System.out.println(arrayList.set(1, "11"));  
   
         // 删除  
         arrayList.remove(0); // remove index  
         arrayList.remove(String.valueOf(2)); // remove obj  
   
         // JDK 1.5 后的遍历方式  
         for (String str : arrayList) {  
             System.out.println(str); // 11,3  
         }  
   
         // 原始迭代器  
         ListIterator<String> listIterator = arrayList.listIterator();  
         String string = null;  
         while (listIterator.hasNext()) {  
             string = (String) listIterator.next();  
             System.out.println(string);  
         }  
   
         // 转换为数组  
         // 此方法在多线程同时修改 {@code List} 的情况下可能抛出异常  
         // String[] l = (String[])arrayList.toArray(new  
         // String[arrayList.size()]);  
   
         // 其它的一些方法  
         arrayList.size(); // 获取大小  
         arrayList.clear(); // 清空  
         arrayList.isEmpty(); // 是否为空  
         arrayList.subList(0, 1); // 截取  
           
         arrayList.lastIndexOf("0");   //返回指定的对象在列表中最后一次出现的位置索引。  
         arrayList.trimToSize();//将此 ArrayList 实例的容量调整为列表的当前大小。  
     }  
   
     /**
      * List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList
      * 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列
      * (deque)。 此类实现 Queue 接口，为 add、poll
      * 等提供先进先出队列操作。其他堆栈和双端队列操作可以根据标准列表操作方便地进行再次强制转换
      * 。虽然它们可能比等效列表操作运行稍快，但是将其包括在这里主要是出于方便考虑。
      * 是通过节点直接彼此连接来实现的。每一个节点都包含前一个节点的引用，后一个节点的引用和节点存储的值
      * 。当一个新节点插入时，只需要修改其中保持先后关系的节点的引用即可，当删除记录时也一样。
      *  
      * 操作其中对象的速度快 不能随即访问：虽然存在get()方法，但是这个方法是通过遍历接点来定位的所以速度慢。
      *  
      * LinkedList在实现Queue时很有用。
      */  
     private void linkedListTest() {  
         // 多个线程同时访问链接的哈希集合时保持同步  
         /*List<String> list = Collections
                 .synchronizedList(new LinkedList<String>());*/  
         LinkedList<String> list = new LinkedList<String>();  
           
         list.add("a");  
         list.add("b");  
         list.add("c");  
         list.add("d");  
           
         list.addFirst("first");  
         list.addLast("end");  
         list.getFirst();  
         list.getLast();  
         // 其它方法参考ArrayList  
     }  
   
     /**
      * HashSet 主要方法
      */  
     private void hashSetTest() {  
         HashSet<String> hashSet = new HashSet<String>();  
         // 添加数据 注意每次插入的数据是无序的  
         hashSet.add("a");  
         hashSet.add("b");  
         hashSet.add("c");  
         hashSet.add("d");  
   
         // 删除数据  
         hashSet.remove("a");  
   
         // 清空数据  
         hashSet.clear();  
   
         // 查询数据  
         hashSet.contains("a");  
         hashSet.size();  
         hashSet.isEmpty();  
         for (String str : hashSet) {  
             System.out.println(str);  
         }  
   
         // 转换为数组  
         String[] strs = (String[]) hashSet.toArray(new String[0]);  
   
     }  
   
     /**
      * LinkedHashSet
      *  
      * 具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。 此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。
      * 此链接列表定义了迭代顺序，即按照将元素插入到集合中的顺序（插入顺序）进行迭代。 注意，插入顺序不 受在集合中重新插入的 元素的影响。
      */  
     private void linkedHashSetTest() {  
         // 多个线程同时访问链接的哈希集合时保持同步  
         /*Set<String> s = Collections
                 .synchronizedSet(new LinkedHashSet<String>());*/  
         LinkedHashSet<String> s = new LinkedHashSet<String>();  
         s.add("a");  
         s.add("b");  
         s.add("c");  
         s.add("d");  
         for (String str : s) {  
             System.out.println(str); // a,b,c,d  
         }  
     }  
   
     /**
      * TreeSet 此类实现 Set 接口，该接口由 TreeMap 实例支持。 此类保证排序后的 set
      * 按照升序排列元素，根据使用的构造方法不同，可能会按照元素 的自然顺序 进行排序（参见 Comparable），或按照在创建 set
      * 时所提供的比较器进行 排序。
      *  
      * HashSet是基于Hash算法实现的,其性能通常优于TreeSet,我们通常都应该使用HashSet,在我们需要排序的功能时,
      * 我门才使用TreeSet
      */  
     private void treeSetTest() {  
         TreeSet<Student> s = new TreeSet<Student>(new Student.compareToStudent());  
         s.add(new Student(1, "a"));  
         s.add(new Student(2, "b"));  
         s.add(new Student(4, "d"));  
         s.add(new Student(4, "c"));  
         s.first();  
         s.last();  
         //其它tree节点操作参考jdk文档  
         for (Student stu : s) {  
             System.out.println(stu);  
         }  
         /*
          * Student [id=1, name=a] Student [id=2, name=b] Student [id=4, name=c]
          * Student [id=4, name=d]
          */  
     }  
   
     /**
      * 一个基于链接节点的、无界的、线程安全的队列。此队列按照 FIFO（先进先出）原则对元素进行排序。队列的头部 是队列中时间最长的元素。队列的尾部
      * 是队列中时间最短的元素。新的元素插入到队列的尾部，队列检索操作从队列头部获得元素。当许多线程共享访问一个公共 collection
      * 时，ConcurrentLinkedQueue 是一个恰当的选择。此队列不允许 null 元素。
      */  
     private void concurrentLinkedQueueTest() {  
         ConcurrentLinkedQueue<String> concurrentLinkedQueue = new ConcurrentLinkedQueue<String>();  
         concurrentLinkedQueue.add("a");  
         concurrentLinkedQueue.add("b");  
         concurrentLinkedQueue.add("c");  
         concurrentLinkedQueue.offer("d"); // 将指定元素插入到此队列的尾部。  
         concurrentLinkedQueue.peek(); // 检索并移除此队列的头，如果此队列为空，则返回 null。  
         concurrentLinkedQueue.poll(); // 检索并移除此队列的头，如果此队列为空，则返回 null。  
   
         for (String str : concurrentLinkedQueue) {  
             System.out.println(str);  
         }  
     }  
   
     /**
      * HashMap 基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用
      * null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。、
      * 使用HashMap要求添加的键类明确定义了hashCode()和equals()的实现。
      */  
     private void hashMapTest() {  
         HashMap<Integer, Student> map = new HashMap<Integer, Student>();  
         map.put(1, new Student(1, "a"));  
         map.put(2, new Student(2, "a"));  
         map.put(3, new Student(3, "a"));  
         map.put(4, new Student(4, "a"));  
   
         System.out.println(map.containsKey(1));// true  
         System.out.println(map.containsValue(new Student(4, "a")));// true  
         System.out.println(map.get(2)); // Student [id=2, name=a]  
   
         // 获取所有的 key  
         Set<Integer> keySet = map.keySet();  
         for (Integer i : keySet) {  
             System.out.println(i); // 1,2,3,4  
         }  
         // 遍历 Map  
         Set<Map.Entry<Integer, Student>> entries = map.entrySet();  
         for (Map.Entry<Integer, Student> entry : entries) {  
             System.out.println(entry.getKey() + ":" + entry.getValue());  
         }  
         // 1:Student [id=1, name=a]  
         // 2:Student [id=2, name=a]  
         // 3:Student [id=3, name=a]  
         // 4:Student [id=4, name=a]  
     }  
   
     /**
      * 此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。 Hashtable 是同步的。
      */  
     private void hashTableTest() {  
         Hashtable<String, Integer> numbers = new Hashtable<String, Integer>();  
         numbers.put("one", new Integer(1));  
         numbers.put("two", new Integer(2));  
         numbers.put("three", new Integer(3));  
   
         Integer n = (Integer) numbers.get("two");  
         if (n != null) {  
             System.out.println("two = " + n);  
         }  
         // 其操作方法参考 HashMap  
     }  
   
     /**
      * TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap
      */  
     private void treeMapTest() {  
         TreeMap<String, Integer> numbers = new TreeMap<String, Integer>();  
         numbers.put("one", new Integer(1));  
         numbers.put("two", new Integer(2));  
         numbers.put("three", new Integer(3));  
         // 其操作方法参考jdk文档  
     }  
   
     /**
      * Properties Properties 类表示了一个持久的属性集。Properties
      * 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
      */  
     private void propertiesTest() {  
         Properties properties = new Properties();  
         OutputStream os = null;  
         try {  
             os = new FileOutputStream(getClass().getResource("test.properties")  
                     .getFile());  
         } catch (FileNotFoundException e1) {  
             // TODO Auto-generated catch block  
             e1.printStackTrace();  
         }  
         try {  
             properties.load(getClass().getResourceAsStream("test.properties"));  
             properties.getProperty("key");  
             properties.getProperty("key", "default");  
             properties.setProperty("new key", "new value");  
             properties.store(os, "comment");  
             os.close();  
         } catch (IOException e) {  
             e.printStackTrace();  
         }  
   
     }  
   
     /**
      * @param args
      */  
     public static void main(String[] args) {  
         // 测试 ArrayList  
         // TypeTest.arrayListTest();  
         // TypeTest.hashSetTest();  
         // TypeTest.linkedHashSetTest();  
         new TypeTest().hashMapTest();  
     }  
   
 }  
   
 class Student implements Comparable {  
     private int id;  
     private String name;  
   
     public Student(int id, String name) {  
         super();  
         this.id = id;  
         this.name = name;  
     }  
   
     public int getId() {  
         return id;  
     }  
   
     public void setId(int id) {  
         this.id = id;  
     }  
   
     public String getName() {  
         return name;  
     }  
   
     public void setName(String name) {  
         this.name = name;  
     }  
   
     @Override  
     public String toString() {  
         return "Student [id=" + id + ", name=" + name + "]";  
     }  
   
     @Override  
     public int hashCode() {  
         final int prime = 31;  
         int result = 1;  
         result = prime * result + id;  
         result = prime * result + ((name == null) ? 0 : name.hashCode());  
         return result;  
     }  
   
     @Override  
     public boolean equals(Object obj) {  
         if (this == obj)  
             return true;  
         if (obj == null)  
             return false;  
         if (getClass() != obj.getClass())  
             return false;  
         Student other = (Student) obj;  
         if (id != other.id)  
             return false;  
         if (name == null) {  
             if (other.name != null)  
                 return false;  
         } else if (!name.equals(other.name))  
             return false;  
         return true;  
     }  
   
     static class compareToStudent implements Comparator // 定义一个内部类来实现比较器  
     {  
         public int compare(Object o1, Object o2) {  
             Student s1 = (Student) o1;  
             Student s2 = (Student) o2;  
             int rulst = s1.id > s2.id ? 1 : (s1.id == s2.id ? 0 : -1);  
             if (rulst == 0) {  
                 rulst = s1.name.compareTo(s2.name);  
             }  
             return rulst;  
         }  
     }  
   
     @Override  
     public int compareTo(Object o) {  
         int result;  
         Student s = (Student) o;  
         result = id > s.id ? 1 : (id == s.id ? 0 : -1);  
         if (result == 0) {  
             result = name.compareTo(s.name);  
         }  
         return result;  
   
     }  
   
 }