疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java集合总结


 

 
接口 Iterator :
对 collection 进行迭代的迭代器。
 
private static void iteratorTest() {
    Collection<String> coll = new ArrayList<String>();
    coll.add("king ");
    coll.add("of ");
    coll.add("pop");
    Iterator<String> it = coll.iterator();
    System.out.println("移除前数量:" + coll.size());
    while (it.hasNext()) { // 如果仍有元素可以迭代,则返回 true
        String str = it.next(); // 返回迭代的下一个元素
        System.out.print(str);
        it.remove(); // 移除当前被迭代的元素
    }
    System.out.println(" 移除后数量:" + coll.size());   
}
接口 Collection :
Collection 层次结构 中的根接口。Collection 表示一组对象,这些对象也称为 Collection 的元素。一些 Collection 允许有重复的元素,而另一些则不允许。一些 Collection 是有序的,而另一些则是无序的。JDK 不提供此接口的任何直接实现:它提供更具体的子接口(如 Set 和 List)实现。此接口通常用来传递 Collection。
 
接口 List :
有序的Collection,此接口的用户可以对列表中每个元素的插入位置进行精确地控制,可以根据元素的整数索引访问元素。允许重复的元素。允许 null 。列表元素上迭代通常优于用索引遍历列表。
 
类 ArrayList :
List 接口的大小可变数组的实现。此实现不是同步的。实现了所有可选列表操作,并允许包括 null 在内的所有元素。除了实现 List 接口外,此类还提供一些方法来操作内部用来存储列表的数组的大小。(此类大致上等同于 Vector 类,除了此类是不同步的)。
 
private static void arrayListTest() {
    List<String> list = new ArrayList<String>();
    list.add("Michael ");
    list.add("Jackson ");
    Iterator<String> it = list.iterator();
    while (it.hasNext()) {
        String str = it.next();
        System.out.print(str);
    }
}
类 LinkedList :
List 接口的链表实现。允许所有元素(包括 null)。除了实现 List 接口外,LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。注意,此实现不是同步的。如果多个线程同时访问一个链接列表,而其中至少一个线程从结构上修改了该列表,则它必须 保持外部同步(结构修改指添加或删除一个或多个元素的任何操作;仅设置元素的值不是结构修改)。
 
private static void linkedListTest() {
    LinkedList<String> ll = new LinkedList<String>();
    ll.add("a");
    ll.add("b");
    System.out.println(ll);
 
    ll.addFirst("addFirst"); // 开头添加
    ll.addLast("addLast"); // 末尾添加
    System.out.println(ll);
    
    ll.removeFirst(); // 返回并删除第一个数据
    ll.removeLast(); // 返回并删除最后一个数据
    System.out.println(ll);
    
    ll.removeFirstOccurrence("a"); // 删除第一次出现的指定元素
    ll.removeLastOccurrence("b"); // 删除最后一次出现的指定元素
    System.out.println(ll);
}
类 Vector :
Vector 类可以实现可增长的对象数组。与数组一样,它包含可以使用整数索引进行访问的组件。但是,Vector 的大小可以根据需要增大或缩小,以适应创建 Vector 后进行添加或移除项的操作。 此实现是同步的。
 
private static void vectorTest() {
    List<String> list = new Vector<String>();
    list.add("a");
    list.add("b");
    for(String str : list) {
        System.out.println(str);
    }
}
接口 ListIterator :
列表迭代器,允许程序员按任一方向遍历列表,迭代期间修改列表,并获得迭代器在列表中的当前位置。ListIterator 没有当前元素,它的光标位置,始终位于调用 previous() 所返回的元素和调用 next() 所返回的元素之间。长度为 n 的列表的迭代器有 n+1
个可能的指针位置,如下面的插入符举例说明:
 
private static void listIteratorTets() {
    List<String> list = new ArrayList<String>();
    list.add("Michael ");
    list.add("Jackson ");
    System.out.print("正向:");
    ListIterator<String> li = list.listIterator();
    while(li.hasNext()) { // 正向
        System.out.print(li.next());
    }
    System.out.print(" 反向:");
    while(li.hasPrevious()) { // 反向
        System.out.print(li.previous());
    }
}
接口 Set :
一个不包含重复元素的 collection。更确切地讲,set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2,并且最多包含一个 null 元素。正如其名称所暗示的,此接口模仿了数学上的 set 抽象。
 
类 HashSet :
此类实现 Set 接口,由哈希表(实际上是一个 HashMap 实例)支持。它不保证 set 的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用 null 元素。
此类为基本操作提供了稳定性能,这些基本操作包括 add、remove、contains 和 size,假定哈希函数将这些元素正确地分布在桶中。对此 set 进行迭代所需的时间与 HashSet 实例的大小(元素的数量)和底层 HashMap 实例(桶的数量)的“容量”的和成比例。因此,如果迭代性能很重要,则不要将初始容量设置得太高(或将加载因子设置得太低)。
注意,此实现不是同步的。如果多个线程同时访问一个哈希 set,而其中至少一个线程修改了该 set,那么它必须 保持外部同步。这通常是通过对自然封装该 set 的对象执行同步操作来完成的。如果不存在这样的对象,则应该使用 Collections.synchronizedSet 方法来“包装” set。例:Set s = Collections.synchronizedSet(new HashSet(...));。
 
private static void hashSetTest() {
    Set<String> set = new HashSet<String>();
    set.add("a");
    set.add("b");
    System.out.println("添加重复前:" + set.size());
    set.add("a");
    System.out.println("添加重复后:" + set.size());
 
    // 遍历一:
    for (String str : set) {
        System.out.println(str);
    }
    // 遍历二:
    Iterator<String> iterator = set.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
}
类 LinkedHashSet :
具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外在于,后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序,即按照将元素插入到 set 中的顺序(插入顺序)进行迭代。注意,插入顺序不 受在 set 中重新插入的 元素的影响。(如果在 s.contains(e) 返回 true 后立即调用 s.add(e),则元素 e 会被重新插入到 set s 中。) 允许 null 元素,不同步。
 
private static void linkedHashSetTest() {
    Set<String> lhs = new LinkedHashSet<String>();
    lhs.add("a");
    lhs.add("b");
    for(String str : lhs){
        System.out.println(str);
    }
}
类 TreeSet :
实现 Set 接口,无序,不可重复,不允许为 null ,不同步。
 
private static void treeSetTest() {
    Set<String> ts = new TreeSet<String>();
    ts.add("a");
    //ts.add(null);
    Iterator<String> it = ts.iterator();
    while(it.hasNext()) {
        System.out.println(it.next());
    }
}
接口 Map :
将键映射到值的对象。一个映射不能包含重复的键;每个键最多只能映射到一个值。
 
类 HashMap :
基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作,并允许使用 null 值和 null 键。(除了非同步和允许使用 null 之外,HashMap 类与 Hashtable 大致相同。)此类不保证映射的顺序。
 
private static void hashMapTest() {
    HashMap<String, String> hm = new HashMap<String, String>();
    hm.put("key1", "value1");
    hm.put("key2", "value2");
    // 遍历方式一:
    for (Map.Entry<String, String> entry : hm.entrySet()) {
        System.out.println(entry.getKey());
        System.out.println(entry.getValue());
    }
    // 遍历方式二:
    for (String str : hm.values()) {
        System.out.println(str);
    }
    // 遍历方式三:
    Iterator<Map.Entry<String, String>> it = hm.entrySet().iterator();
    while (it.hasNext()) {
        System.out.println(it.next().getKey());
        System.out.println(it.next().getValue());
    }
    // 遍历方式四:
    for (String s : hm.keySet()) {
        System.out.println(hm.get(s));
    }
}
类 TreeMap :
基于红黑树(Red-Black tree)的 NavigableMap 实现。该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法。
 
    private static void treeMapTest() {
        Map<String, String> treeMap = new TreeMap<String,String>();
        treeMap.put("key1", "value1");
        treeMap.put("key2", "value2");
        Iterator<String> it = treeMap.values().iterator();
        while(it.hasNext()) {
            System.out.println("~~~~~~~~~~~~~~"+it.next());
        }
    }
    
    private static void treeMapTest2() {
        Map<String, String> treeMap = new TreeMap<String,String>();
        treeMap.put("key1", "value1");
        treeMap.put("key2", "value2");
        for(Entry<String, String> entry : treeMap.entrySet()) {
            System.out.println("~~~~~~~~~~~~"+entry.getKey());
            System.out.println("~~~~~~~~~~~~"+entry.getValue());
        }
    }