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("\n移除后数量:" + 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("\n\n反向：");
    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());
        }
    }

转载于:https://www.cnblogs.com/17003WS/p/6120179.html