JAVA 常用容器学习记录

java常用容器

1. 容器的基本概念

Java容器类类库的用途是“保存对象”，并将其划分为两个不同的概念：

1. Collection ，一个独立元素的序列，这些元素都服从一条或多条规则。List必须按照插入的顺序保存元素，而Set不能由重复元素。Queue按照排队规则(FIFO 先进先出的原则)来确定对象产生的顺序(通常与它们被插入的顺序相同)。
2. Map。一组成对的“键值对”对象，允许你使用键来查询值。ArrayList允许你使用数字来查询值，因此在某种意思上讲，它将数字与对象关联在一起了。映射表允许我们使用另一个对象来查询某个对象，他也被称为“关联数组”，因为它将某些对象与另外一些对象关联在了一起；或者被称为“字典”，因为你也可以使用键对象类查询值对象，就像在字典中使用单词来定义一样。Map是强大的编程工具

2. 利用Arrays和Collections添加一组元素

在java.util包中的Arrays和Collections类中都有很多实用方法，可以在一个Collection中添加一组元素。Arrays.asList()方法接受一个数组或是一个用逗号分隔的元素列表(使用可变参数)，并将其转换为一个List对象。Collections.addAll()方法接受一个Collection对象，以及一个数组或是一个用逗号分隔的列表，将元素添加到Collection中。下面展示了这两个方法，以及更加传统addAll()方法，所有Collection类型都包含该方法:

public static void main(String[] args) {
    Collection<Integer> collection = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4, 5));
    Integer[] moreInts = {6, 7, 8, 9, 10};
    collection.addAll(Arrays.asList(moreInts));

    Collections.addAll(collection, 11, 12, 13, 14,15);
    Collections.addAll(collection, moreInts);
    
    List<Integer> list = Arrays.asList(16, 17, 18, 19, 20);
    list.set(1, 99);
    //list.add(21); //会报运行时错误 unsupported operation
  }

Collection的构造函数可以接受另一个Collection，用它来将自身初始化，因此你可以使用Arrays.asList()类为这个构造函数产生输入。但是，Collection.addAll()方法运行起来要快的多，而且构建一个不包含元素的Collection，然后调用Collections.addAll()这种方式很方便，因此它是首选方法。
Collection.addAll()成员方法只能接受另一个Collecion对象作为参数，因此它不如Arrays.asList()或Collections.addAll()灵活，这两个方法使用的都是可变参数列表。
你也可以直接使用Arrays.asList()的输出，将其当作List，但是在这种情况下，其底层表示的是数组，因此不能直接调整尺寸。如果你试图用add()或delete()方法在这种列表种添加或删除元素，就有可能会引发去改变数组尺寸的尝试，因此你将在运行是获得“Unsupported Operation（不支持的操作）" 错误。

3. 容器的打印

你必须使用Arrays.toString()来产生数组的可打印表示，但是打印容器无需任何帮助。下面是一个列子，这个列子种也介绍了一些基本类型的容器：

public static void main(String[] args) {
    System.out.println(fill(new ArrayList<String>()));
    System.out.println(fill(new LinkedList<String>()));
    System.out.println(fill(new HashSet<String>()));
    System.out.println(fill(new TreeSet<String>()));
    System.out.println(fill(new LinkedHashSet<String>()));
    System.out.println(fill(new HashMap<String,String>()));
    System.out.println(fill(new TreeMap<String,String>()));
    System.out.println(fill(new LinkedHashMap<String,String>()));
  }

  static Collection fill(Collection<String> collection){
    collection.add("rat");
    collection.add("cat");
    collection.add("dog");
    collection.add("dog");
    return collection;
  }

  static Map fill(Map<String, String> map) {
    map.put("rat", "Fuzzy");
    map.put("cat", "Rags");
    map.put("dog", "Bosco");
    map.put("dog", "Spot");
    return map;
  }
Run output：
[rat, cat, dog, dog]
[rat, cat, dog, dog]
[rat, cat, dog]
[cat, dog, rat]
[rat, cat, dog]
{rat=Fuzzy, cat=Rags, dog=Spot}
{cat=Rags, dog=Spot, rat=Fuzzy}
{rat=Fuzzy, cat=Rags, dog=Spot}

这里展示了Java容器类库中的两种主要类型，他们的区别在于容器中每个”槽“保存的元素的个数。Collection在每个槽中只能保存一个元素。此类容器包括：List，它以特定的顺序保存一组元素；Set，元素不能重复；Queue，只允许在容器的一”端“插入对象，并从另一端移除对象。Map在每个槽内保存了两个对象，即键和与之相关联的值。
查看输出会发现，默认的打印行为（其实是使用了容器提供的toString()方法）即可生成可读性很好的结果。Collecion打印出来的内容用方括号括住，每个元素用逗号隔开，Map则用大括号括住，键与值由等号联系。
第一个fill()方法可以作用于所有类型的Collection，这些类型都实现了用来添加新元素的add()方法。
ArrayList和LinkedList都是List类型，从输出可以看出，它们都按照被插入的顺序保存元素。两者的不同之处不仅在于执行某些类型的操作时的性能，而且LinkedList包含的操作也多于ArrayList。
HashSet,TreeSet和LinkedHashSet都是Set类型，输出显示在Set中，每个相同的项只有保存一次，但是输出也显示了不同的Set实现存储元素的方式也不同。HashSet使用的是相当复杂的方式类存储元素的，这种存储方式就是在查找元素最快的方式，因此，这个存储方式并不在乎存储顺序。如果存储顺序很重要，那么可以使用TreeSet，它按照比较结构的升序保存对象；或者使用LinkedHashSet，它按照被添加的顺序保存对象。
Map使得你可以用键来查找对象，就像一个简单的数据库，且对于每个键，Map只接受存储一次。
Map.put(key,value)方法将添加一个值，并将它与某个键关联起来。Map.get(key)方法将产生与这个键相关联的值。Map会自动地调整尺寸，Map还知道如何打印自己，他会显示相关联的键和值，键和值在Map中的保存顺序并不是他们的插入顺序，因为HashMap实现使用的是一种非常快的算法来控制顺序的。
本例使用了三种基本风格的Map:HashMap,TreeMap和LinkedHashMap。与HashSet一样，Hashmap也提供了最快的查找技术，也没有按照任何明显的顺序来保存其元素。TreeMap按照比较结果的升序保存键，而LinkedHashMap则按照插入的顺序保存键，同时还保留了HashMap的查询速度。

4. List常用方法的使用

List承诺可以将元素维护在特定的序列中。List接口在Collection的基础上添加了大量的方法，使得可以在List的中间插入和移除元素。
由两种类型的List：

1. 基本的ArrayList，它长于随机访问元素，但是在List的中间插入和移除元素时较慢。
2. LinkedList，它通过代价较低的在List中间进行插入和移除操作，提供了优化的顺序访问。LinkedList在随机访问方面相对比较慢，但是它的特性集较ArrayList更大。

public static void main(String[] args) {
    Random random = new Random(47);
    List<String> stringLists = new ArrayList<>(Arrays.asList("机房", "速度", "深刻", "看到", "厄尔", "坤灵", "肯定"));
    System.out.println("打印List：" + stringLists);
    stringLists.add("的数据");
    System.out.println("add(Object)方法: "+ stringLists);
    System.out.println("contains(Object)方法: "+stringLists.contains("的数据"));
    System.out.println("remove(Object)方法: "+stringLists.remove("的数据"));
    System.out.println("get(index)方法: " + stringLists.get(2));
    System.out.println("indexOf(Object)方法: " + stringLists.indexOf(stringLists.get(2)));
    System.out.println("subList(toIndex,formIndex)方法: " + stringLists.subList(1, 4));
    System.out.println("containsAll(List)方法: " + stringLists.containsAll(stringLists.subList(1, 4)));
    Collections.sort(stringLists);
    System.out.println("Collections.sort(List)方法 默认是升序，如果需要降序需要实现Compareable接口: " + stringLists);
    Collections.shuffle(stringLists,random);
    System.out.println("Collections.shuffle(List)方法，随机打乱List 也可以不传入随机对象Random: " + stringLists);
    System.out.println("remove(index)方法: " + stringLists.remove(2));
    System.out.println("retainAll(List)方法，保留参数集合: "+stringLists.retainAll(Arrays.asList("机房", "速度", "深刻")));
    System.out.println("isEmpty: " + stringLists.isEmpty());
    System.out.println("size：" + stringLists.size());
    System.out.println("toArray(): " + stringLists.toArray());
    System.out.println("toArray() 使用了Arrays.toString打印: " + Arrays.toString(stringLists.toArray()));
    System.out.println("toArray(Object[]): "+stringLists.toArray(new String[]{"fds"}));
    System.out.println("toArray(Object[]) 使用了Arrays.toString打印: "+Arrays.toString(stringLists.toArray(new String[]{"fds"})));
    System.out.println("addAll() "+stringLists.addAll(Arrays.asList("fdsfd","dsfdsgds")));
    System.out.println("removeAll(): "+stringLists.removeAll(Arrays.asList("fdsfd","dsfdsgds")));
    stringLists.clear();
    System.out.println("clear: " + stringLists);

  }
  
  Run output：
打印List：[机房, 速度, 深刻, 看到, 厄尔, 坤灵, 肯定]
add(Object)方法: [机房, 速度, 深刻, 看到, 厄尔, 坤灵, 肯定, 的数据]
contains(Object)方法: true
remove(Object)方法: true
get(index)方法: 深刻
indexOf(Object)方法: 2
subList(toIndex,formIndex)方法: [速度, 深刻, 看到]
containsAll(List)方法: true
Collections.sort(List)方法 默认是升序，如果需要降序需要实现Compareable接口: [厄尔, 坤灵, 机房, 深刻, 看到, 肯定, 速度]
Collections.shuffle(List)方法，随机打乱List 也可以不传入随机对象Random: [看到, 机房, 坤灵, 厄尔, 深刻, 肯定, 速度]
remove(index)方法: 坤灵
retainAll(List)方法，保留参数集合: true
isEmpty: false
size：3
toArray(): [Ljava.lang.Object;@1d44bcfa
toArray() 使用了Arrays.toString打印: [机房, 深刻, 速度]
toArray(Object[]): [Ljava.lang.String;@266474c2
toArray(Object[]) 使用了Arrays.toString打印: [机房, 深刻, 速度]
addAll() true
removeAll(): true
clear: []

5. 迭代器Iterator

迭代器(也是一种设计模式)。迭代器是一个对象，它的工作是遍历并选择序列中的对象，而客户端程序员不必知道或关心该序列底层的结构。此外，迭代器通常被称为轻量级对象：创建它的代价小。因此经常可以见到对迭代器有些奇怪的限制；例如，Java的Iterator只能单向移动，这个Iterator只能用来:

1. 使用方法iterator()要求容器返回一个Iterator。Iterator将准备好返回序列的第一个元素。
2. 使用next()获得序列中的下一个元素。
3. 使用hasNex()检查序列中是否还有元素。
4. 使用remove()将迭代器新近返回的元素移除。

public static void main(String[] args) {
    List<String> stringLists = new ArrayList<>(Arrays.asList("机房", "速度", "深刻", "看到", "厄尔", "坤灵", "肯定"));
    Iterator<String> iterator = stringLists.iterator();
    while (iterator.hasNext()) {
      String string = iterator.next();
      System.out.print("next: " + string+",");
    }
    System.out.println();
    for (String str : stringLists) {
      System.out.print("forech: " + str+",");
    }
    System.out.println();
    iterator = stringLists.iterator();
    for (int i = 0; i < 7; i++) {
      iterator.next();
      iterator.remove();
    }
    System.out.println(stringLists);
  }
  
  Run output:
next: 机房,next: 速度,next: 深刻,next: 看到,next: 厄尔,next: 坤灵,next: 肯定,
forech: 机房,forech: 速度,forech: 深刻,forech: 看到,forech: 厄尔,forech: 坤灵,forech: 肯定,
[]

有了Iterator就不必为容器中元素的数量操心了，那是由hasNext()和next()关心的事情。
如果你只是向前遍历List，并不打算修改List本身,那么你可以到foreach语法会显得更加简洁。
Iterator还可以移除由next()产生的最后一个元素，这意味着在调用remove()之前必须先调用next()

5.1. ListIterator

ListIterator是一个更加强大的Iterator的子类型，它只能用于各种List类的访问，尽管Iterator只能向前移动，但是ListIterator可以双向移动。它还可以产生相对于迭代器在列表中指向当前位置的前一个和后一个元素的索引，并且可以使用set()方法替换它访问过的最后一个元素。你可以通过调用listIterator()方法产生一个指向List开始处的ListIterator，并且还可以通过调用listIterator(n)方法创建一个一开始就指向列表索引n的元素处的ListIterator，下面这个例子演示了这些方法使用：

public static void main(String[] args) {
    Random random = new Random(47);
    List<String> stringLists = new ArrayList<>(Arrays.asList("机房", "速度", "深刻", "看到", "厄尔", "坤灵", "肯定"));
    ListIterator<String> stringListIterator = stringLists.listIterator();
    while (stringListIterator.hasNext()) {
      System.out.print(stringListIterator.next()+", "+stringListIterator.nextIndex()+", "+stringListIterator.previousIndex()+"; ");
    }
    System.out.println("--------------------------------");
    while (stringListIterator.hasPrevious()) {
      System.out.print(stringListIterator.previous() + ",");
    }
    System.out.println("--------------------------------");
    System.out.println(stringLists);
    stringListIterator = stringLists.listIterator(3);
    while (stringListIterator.hasNext()) {
      stringListIterator.next();
      stringListIterator.set(random.nextInt()+"");
    }
    System.out.println(stringLists);
  }

Run output:
机房, 1, 0; 速度, 2, 1; 深刻, 3, 2; 看到, 4, 3; 厄尔, 5, 4; 坤灵, 6, 5; 肯定, 7, 6; --------------------------------
肯定,坤灵,厄尔,看到,深刻,速度,机房,--------------------------------
[机房, 速度, 深刻, 看到, 厄尔, 坤灵, 肯定]
[机房, 速度, 深刻, -1172028779, 1717241110, -2014573909, 229403722]

6. LinkedList常用方法使用

LinkedList也像ArrayList一样实现了基本的List接口，但是它执行某些操作时比ArrayList更高效，但在随机访问操作方面却要逊色一些。
LinkedList还添加了可以使其用作栈，队列或双端队列的方法。
这些方法中有些彼此之间只是名称有些差异，或者只存在些许差异，以使得这些名字在特定用法的上下文环境中更加适用。例如，getFirst()和element()完全一样，他们都是返回列表的头元素，而不移除它，如果List为空，则抛出NoSuchElementException。peek()方法与这两个方法只是稍有差异，他在列表为空时返回null。
removeFirst()和remove()也是完全一样，他们移除并返回列表的头，而在列表为空抛出NoSuchElementException。poll()稍有差异，他在列表为空时返回null。
addFirst()与add()和addLast()相同，他们都将某个元素插入到列表的尾(端)部。
removeLast()移除并返回列表的最后一个元素。
下面这个例子展示了这些特性：

public static void main(String[] args) {
    Random random = new Random(47);
    List<String> stringLists = new ArrayList<>(Arrays.asList("机房", "速度", "深刻", "看到", "厄尔", "坤灵", "肯定"));
    LinkedList<String> linkedList = new LinkedList(stringLists);
    System.out.println(linkedList);
    System.out.println("getFirst: " + linkedList.getFirst());
    System.out.println("element: " + linkedList.element());
    System.out.println("peek: " + linkedList.peek());
    System.out.println("remove: " + linkedList.remove());
    System.out.println("removeFirst: " + linkedList.removeFirst());
    System.out.println("poll: " + linkedList.poll());
    System.out.println("linkedList: " + linkedList);
    linkedList.addFirst("栈头新增方法");
    System.out.println("addFirst: " + linkedList);
    linkedList.offer("队列新增方式");
    System.out.println("offer: " + linkedList);
    linkedList.add("普通list新增");
    System.out.println("add: " + linkedList);
    linkedList.addLast("栈尾新增方法");
    System.out.println("addLast: " + linkedList);
    System.out.println("removeLast: " + linkedList.removeLast());
  }

Run output:
[机房, 速度, 深刻, 看到, 厄尔, 坤灵, 肯定]
getFirst: 机房
element: 机房
peek: 机房
remove: 机房
removeFirst: 速度
poll: 深刻
linkedList: [看到, 厄尔, 坤灵, 肯定]
addFirst: [栈头新增方法, 看到, 厄尔, 坤灵, 肯定]
offer: [栈头新增方法, 看到, 厄尔, 坤灵, 肯定, 队列新增方式]
add: [栈头新增方法, 看到, 厄尔, 坤灵, 肯定, 队列新增方式, 普通list新增]
addLast: [栈头新增方法, 看到, 厄尔, 坤灵, 肯定, 队列新增方式, 普通list新增, 栈尾新增方法]
removeLast: 栈尾新增方法

7. 栈Stack常用方法使用

"栈”通常时指“后进先出”（LIFO)的容器。有时栈也被称为叠加栈，因为最后“压入”栈的元素，第一个"弹出“栈。
LinkedList具有能够直接实现栈的所有功能的方法，因此可以直接将LinkedList作为栈使用。
栈有以下几个常用的方法:

1. push()将数据压入栈内
2. peek()和pop()都是返回元素，peek()方法提供栈顶元素，但是并不将其从栈顶移除，而pop()方法将移除并返回栈顶元素。
3. isEmpty()栈是否为空。
   以下例子将演示这些方法的使用：

public static void main(String[] args) {
    Random random = new Random(47);
    List<String> stringLists = new ArrayList<>(Arrays.asList("机房", "速度", "深刻", "看到", "厄尔", "坤灵", "肯定"));
    Stack stack = new TestList.Stack<>();
    for(String s: "my dog has fleas".split(" "))
      stack.push(s);
    while (!stack.empty()) {
      System.out.print(stack.pop() + " ");
    }
  }
  static class Stack<T>{
    private LinkedList<T> linkedList = new LinkedList<T>();

    public void push(T t) {
      linkedList.addFirst(t);
    }
    public T peek() {
      return linkedList.getFirst();
    }
    public T pop() {
      return linkedList.removeFirst();
    }
    public boolean empty() {
      return linkedList.isEmpty();
    }
    public String toString() {
      return linkedList.toString();
    }
  }

Run output:
fleas has dog my 

8. Set常用方法使用

Set不保存重复的元素。如果你试图将相同对象的多个实例添加到Set中，那么它就会阻止这种重复现象。Set具有与Collection完全一样的接口，因此没有任何额外的功能，不像前面有两个不同的List。实际上Set就是Collection，只是行为不同。
出于速度原因的考虑，HashSet使用了散列，HashSet所维护的顺序与TreeSet或LinkedHashSet都不同，因为他们的实现具有不同的元素存储方式。TreeSet将元素存储在红-黑树数据结构中，而HashSet使用的时散列函数。LinkedHashSet因为查询速度的原因也使用了散列，但是看起来它使用了链表来维护元素的插入顺序。
下面的例子显示了这三个容器的用法：

public static void main(String[] args) {
    Random random = new Random(47);
    Set<Integer> intSet = new HashSet<>();
    for (int i = 0; i < 10000; i++) {
      intSet.add(random.nextInt(30));
    }
    Set<Integer> intSet1 = new TreeSet<>();
    for (int i = 0; i < 10000; i++) {
      intSet1.add(random.nextInt(30));
    }
    Set<Integer> intSet2 = new LinkedHashSet<>();
    for (int i = 0; i < 10000; i++) {
      intSet2.add(random.nextInt(30));
    }
    System.out.println("HashSet: "+intSet);
    System.out.println("TreeSet: "+intSet1);
    System.out.println("LinkedHashSet: "+intSet2);
  }

Run output:
HashSet: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
TreeSet: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
LinkedHashSet: [25, 11, 10, 6, 19, 29, 23, 18, 15, 3, 4, 0, 12, 28, 9, 16, 2, 26, 13, 8, 27, 20, 1, 17, 22, 24, 14, 7, 5, 21]

在0到29之间的10000个随机数被添加到Set中，因此你可以想象，每一个数都重复了许多次。但是你可以看到，每一个数只有一个实例出现在结果中。

9. Map常用方法使用

Map与数组和其他的Collection一样都是存储数据的，只不过Map是以key-value形式存储的，key和value都可以是任意类型数据。下面例子展示怎么在Map中存数据取数据：

public static void main(String[] args) {
    Map<String, String> map = new HashMap<>();
    map.put("cat", "catsss");
    map.put("rat", "ratsfdsf");
    System.out.println(map);
    System.out.println("containsKey: " + map.containsKey("rat"));
    System.out.println("containsValue: " + map.containsValue("catsss"));
    System.out.println("--------------entrySet------------------------");
    for (Map.Entry entry : map.entrySet()) {
      System.out.println("key: " + entry.getKey());
      System.out.println("values: " + entry.getValue());
    }
    System.out.println("--------------keySet------------------------");
    for (String string : map.keySet()) {
      System.out.println("key: "+string+", value: "+map.get(string));
    }
  }

Run output:
{rat=ratsfdsf, cat=catsss}
containsKey: true
containsValue: true
--------------entrySet------------------------
key: rat
values: ratsfdsf
key: cat
values: catsss
--------------keySet------------------------
key: rat, value: ratsfdsf
key: cat, value: catsss

10. 队列Queue常用方法使用

队列是一个典型的先进先出（FIFO）的容器，即从容器的一端放入事务，从另一端取出，并且事物放入容器的顺序与取出的顺序是相同的。队列常被当作一种可靠的将对象从程序的某个区域传输到另一个区域的途径。
LinkedList提供了方法以支持队列的行为，并且它实现了Queue接口，因此LinkedList可以用作Queue的一种实现。通过将LinkedList向上转型为Queue,下面的示例使用了在Queue接口的方法：

public static void main(String[] args) {
    Queue<Integer> queue = new LinkedList<>();
    Random random = new Random(47);
    for (int i = 0; i < 10; i++) {
      queue.offer(random.nextInt(i + 10));
    }
    printQ(queue);
    System.out.println("执行poll()方法返回数据后数据被移除，队列queue为空");
  }

  public static void printQ(Queue queue) {
    while (queue.peek() != null) {
      System.out.print(queue.poll()+" ");
    }
    System.out.println();
    System.out.println(queue);
  }

Run output:
8 1 1 1 5 14 3 1 0 1 
[]
执行poll()方法返回数据后数据被移除，队列queue为空

offer()方法是与Queue相关的方法之一，它在允许的情况下，将一个元素插入到队尾，或者返回false。peek()和element()都将在不移除的情况下返回队头，但是peek()方法在队列为空时返回null,而element()会抛出NoSuchElementException异常。poll()和remove()方法将移除并返回队头，但是poll()在队列为空时返回null，而remove()会抛出NoSuchElementException异常。

10.1.1 优先队列PriorityQueue

先进先出描述了最典型的队列规则。队列规则是指在给定一组队列中的元素情况下，确定下一个弹出队列的元素的规则。
优先队列声明下一个弹出元素是最需要的元素（具有最高的优先级）
以下例子显示了用法：

public static void main(String[] args) {
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>();
    Random random = new Random(47);
    for (int i = 0; i < 10; i++) {
      priorityQueue.offer(random.nextInt(i + 10));
    }
    printQ(priorityQueue);
    List<Integer> ints = Arrays.asList(23, 242, 3214, 2, 52, 32, 1545, 123, 2, 1, 32, 14,12 );
    priorityQueue = new PriorityQueue(ints);
    printQ(priorityQueue);
    priorityQueue = new PriorityQueue(ints.size(), Collections.reverseOrder());
    priorityQueue.addAll(ints);
    printQ(priorityQueue);

  }

  public static void printQ(Queue queue) {
    while (queue.peek() != null) {
      System.out.print(queue.poll()+" ");
    }
    System.out.println();
  }
Run output:
0 1 1 1 1 1 3 5 8 14 
1 2 2 12 14 23 32 32 52 123 242 1545 3214 
3214 1545 242 123 52 32 32 23 14 12 2 2 1 

可以看到，重复是允许的，最小的值拥有最高的优先级，还可以使用实现了Comparator对象来改变排序方式，后面一个输出就使用Collection。reverseOrder()的反序来输出的数据。

11. Collection和Iterator迭代器

Collection和Iterator都可以用来遍历容器中的数据，这种的使用方式如下:

public static void main(String[] args) {
      List<String> stringLists = new ArrayList<>(Arrays.asList("机房", "速度", "深刻", "看到", "厄尔", "坤灵", "肯定"));
    Set<String> set = new HashSet<>(stringLists);
    Map<String, String> map = new LinkedHashMap<>();
    String[] names = ("Ralph, Eric, RObin, Lacey, Sam, spot").split(",");
    for (int i = 0; i < names.length; i++) {
      map.put(names[i], stringLists.get(i));
    }
    display(stringLists);
    display(set);
    display(stringLists.iterator());
    display(set.iterator());
    System.out.println(map);
    System.out.println(map.keySet());
    display(map.values());
    display(map.values().iterator());
  }

  public static void display(Iterator<String> iterator){
    while (iterator.hasNext()) {
      System.out.print("Iterator: "+iterator.next());
    }
    System.out.println();
  }
  public static void display(Collection<String> collection){
    for (String string : collection) {
      System.out.print("Collection: "+string);
    }
    System.out.println();
  }

Run output:
Collection: 机房Collection: 速度Collection: 深刻Collection: 看到Collection: 厄尔Collection: 坤灵Collection: 肯定
Collection: 肯定Collection: 速度Collection: 深刻Collection: 机房Collection: 厄尔Collection: 坤灵Collection: 看到
Iterator: 机房Iterator: 速度Iterator: 深刻Iterator: 看到Iterator: 厄尔Iterator: 坤灵Iterator: 肯定
Iterator: 肯定Iterator: 速度Iterator: 深刻Iterator: 机房Iterator: 厄尔Iterator: 坤灵Iterator: 看到
{Ralph=机房,  Eric=速度,  RObin=深刻,  Lacey=看到,  Sam=厄尔,  spot=坤灵}
[Ralph,  Eric,  RObin,  Lacey,  Sam,  spot]
Collection: 机房Collection: 速度Collection: 深刻Collection: 看到Collection: 厄尔Collection: 坤灵
Iterator: 机房Iterator: 速度Iterator: 深刻Iterator: 看到Iterator: 厄尔Iterator: 坤灵

在JAVA中，通常都是使用迭代器而不是Collection来表示容器之间的共性。但是，这种方法被绑定到一起了，因为实现Collection就意味着需要提供iterator()方法,所以如果你的类只是想使用Iterator的话，可以不实现Collection接口或者继承’AbstractCollection`类，按以下方式获取这种行为:

public static void main(String[] args) {
      NonCollectionIterator nonCollectionIterator = new NonCollectionIterator();
    display(nonCollectionIterator.iterator());
  }
  static class NonCollectionIterator extends  MyIterator{
      public Iterator<String> iterator(){
        return new Iterator<String>() {
          private int index = 0;
          @Override
          public boolean hasNext() {
            return index < stringLists.size();
          }

          @Override
          public String next() {
            return stringLists.get(index++);
          }

          public void remove(){
            //不实现这个方法 抛异常出去
            throw new UnsupportedOperationException();
          }
        };
      }
  }
  static class MyIterator{
    List<String> stringLists = new ArrayList<>(Arrays.asList("机房", "速度", "深刻", "看到", "厄尔", "坤灵", "肯定"));
  }

  public static void display(Iterator<String> iterator){
    while (iterator.hasNext()) {
      System.out.print("Iterator: "+iterator.next());
    }
    System.out.println();
  }

Run output:

Iterator: 机房Iterator: 速度Iterator: 深刻Iterator: 看到Iterator: 厄尔Iterator: 坤灵Iterator: 肯定

12. Foreach与Iterator迭代器

foreach语法主要用于数组，但是它也可以应用于任何Collection对象。Collection之所以可以使用foreach语法主要是因为JAVA SE5引入了新的Iterable接口，该接口包含一个能够产生Iterator的iterator()方法，并且Iterable接口被foreach用来在序列中移动，因此如果你创建了任何实现Iterable的类，都可以将它用于foreach语句中。

13. 总结

Java提供了大量容器的方法:

1. 数组将数字与对象联系起来。它保存类型明确的对象，查询对象时，不需要对结果做类型转换。它可以时多维的，可以保存基本类型的数据，但是，数组一旦生成，其容量就不能改变。
2. Collection保存单一的元素，而Map保存相关联的键值对。有了Java的泛型，你就可以指定容器中存放的对象类型，因此你就不会将错误类型的对象放置到容器中，并且在从容器中获取元素时，不必进行类型转换。各种Collection和各种Map都可以在你向其中添加更多的元素时，自动调整其尺寸。容器不能持有基本类型，但是自动包装机制会仔细地执行基本类型到容器中所持有的包装器类型之间的双向转换。
3. 像数组一样，List也建立索引与对象的关联，因此，数组和List都是排好序的容器，List能够自动扩充容量。
4. 如果要进行大量的随机访问，就使用ArrayList,如果要经常从表中间插入或删除元素，则应该使用LinkedList。
5. 各种Queue队列以及栈的行为，都可以由LinkedList作为实现类提供方法支持，因为在LinkedList类中由提供队列和栈的方法。
6. Map是一种将对象与对象相关联的设置。HashMap设计用来快速访问；而TreeMap保持“键”始终处于排序状态，所以没有HashMap快。LinkedHashMap保持元素插入的顺序，但是也通过散列提供了快速访问能力。
7. Set不接受重复元素，HashSet提供最快的查询速度，而TreeSet保持元素处于排序状态。LinkedList以插入顺序保存元素。
8. 在程序中使用容器，应该不要使用过时的容器Vector,HashMap和Stack。
   以下列出了Java容器常用的接口和类的简图:
   
   你可以看到，其实只有四种容器：Map,List,Set和Queue，他们各有两到三个实现版本(Queue的java.util.concurrent实现没有包括在上面这张图中)。常用的容器用黑色粗线框表示。
   电线框表示接口，实线框表示普通的(具体的)类。带有空心箭头的点线表示一个特定的类实现了一个接口，实心箭头表示某个类可以生成箭头所指向类的对象。例如，任意的Collection可以生成Iterator，而List可以生成ListIterator(也能生成普通的Iterator，因为List继承至Collection)。