如果一个程序只包含固定数量的对象并且对象的生命周期都是已知的，那么这是一个非常简单的程序

泛型和类型安全的集合

  1. 使用ArrayList get() 取出对象时，得到的只是 Object 的引用。
  2. 使用泛型后，在编译期就可以检查集合中是否有错误类型对象。
  3. 向上转型也适用于泛型（即可插入指定类的子类）

基本概念

1.集合(collection): List按照插入顺序保存，Set不能包含重复，Queue按排队规则。
2.映射(Map): 按照键值对存储。
3.通常创建时，可以将他们向上转型为更通用的接口，但是如果需要使用子类额外的方法，就不能向上转型

添加元素组

语法： Arrays.asList() 接受数组并转换为List对象。
Collections.addAll(Collection< ?extends E> c) 

  1. import java.util.*;
  3. public class AddingGroups {
  4.   public static void main(String[] args) {
  5.     Collection<Integer> collection =
  6.       new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
  7.     Integer[] moreInts = { 6, 7, 8, 9, 10 };
  8.     collection.addAll(Arrays.asList(moreInts));
  9.     // Runs significantly faster, but you can't
  10.     // construct a Collection this way:
  11.     Collections.addAll(collection, 11, 12, 13, 14, 15);
  12.     Collections.addAll(collection, moreInts);
  13.     // Produces a list "backed by" an array:
  14.     List<Integer> list = Arrays.asList(16,17,18,19,20);
  15.     list.set(1, 99); // OK -- modify an element
  16.     // list.add(21); // Runtime error; the underlying
  17.                      // array cannot be resized.
  18.   }
  19. }

疑问：为何此处非继承Snow的两个类加入LIst不会报错？

  1. class Light extends Powder {}
  2. class Heavy extends Powder {}
  4. public class AsListInference {
  5.     public static void main(String[] args) {
  6.       List<Snow> snow2 = Arrays.asList(
  7.       new Light(), new Heavy());
  8.     //- snow2.add(new Slush()); // Exception
  9.         }
  10. }
  • 打印：数组（必须使用Arrays.toString()生成可打印模式，Colletions直接打印。

列表List

  • ArrayList: 数组实现 —> 随机访问元素
  • LinkedList：链表实现—>插入，删除元素
  • 对于LinkedList，在列表中插入和删除为廉价操作，而对ArrayList,则为代价昂贵操作。此处提醒我们：若在ArrayList中有许多插入操作，程序开始变慢，则需要考虑性能问题。（采用profiler进行解决）
  • 实际操作见博客：

迭代器Iterators

Iterators实现的是应用于不同类型集合的抽象，在一个序列中移动并选择该序列中的每个对象。
疑惑解答：
Iterator没有当前元素，它的光标位置始终位于previous()【前一个元素，仅ListIterator有】与next()【后一个元素】之间。如下述例子中的 ^ 位置：
^ Element(0) ^ Element(1) ^ Element(2) ^ … ^ Element(n-1) ^
因此n个列表的迭代器有n+1个可能的指针位置。

  • iterator() 返回一个Iterator。第一次调用next()方法时，返回序列的第一个元素。
  • next() 获得序列中的下一个元素。
  • hasNext() 检查序列中是否还有元素。
  • remove() 将迭代器最近返回的元素删除。

迭代器统一了对于集合的访问方式：

  1.   public static void display(Iterator<Pet> it) {
  2.     while(it.hasNext()) {
  3.       Pet p = it.next();
  4.       System.out.print(p.id() + ":" + p + " ");
  5.     }
  6.     System.out.println();
  7.   }
  8. //对于该函数，我们仅需要传入迭代器即可完成遍历
  9. //而迭代器可由List<pet>,LinkedList<pet>,HashSet<pet>等类型产生。

进一步了解一下 Iterable 接口的用法：

  1. public class CrossCollectionIteration2 {
  2.   public static void display(Iterable<Pet> ip) {
  3.     Iterator<Pet> it = ip.iterator();
  4.     while(it.hasNext()) {
  5.       Pet p = it.next();
  6.       System.out.print(p.id() + ":" + p + " ");
  7.     }
  8.     System.out.println();
  9.   }
  10.  //此处的Iterable表示能生成Iterator的各种东西
  11.  //故可以直接传入List<pet>,LinkedList<pet>等作为参数

ListIterator

特点： 双向移动，可指向位置前一个和后一个元素的索引。
更深入的分析见：Java集合中关于Iterator和ListIterator的详解

链表LinkedList

Java文档链接

堆栈Stack

通过这个例子，入门泛型的类定义。
由于Java中使用 ArrayDeque 实现堆栈功能，因此若直接使用，需要声明为Deque类型。
而对于程序员而言，可以通过自己封装一个Stack类完成相应功能。

  1. package onjava;
  2. import java.util.Deque;
  3. import java.util.ArrayDeque;
  5. public class Stack<T> {
  6.   private Deque<T> storage = new ArrayDeque<>();
  7.   public void push(T v) { storage.push(v); }
  8.   public T peek() { return storage.peek(); }
  9.   public T pop() { return storage.pop(); }
  10.   public boolean isEmpty() { return storage.isEmpty(); }
  11.   @Override
  12.   public String toString() {
  13.     return storage.toString();
  14.   }
  15. }

此处使用composition而非继承，创建类时，我们只需要栈的行为，而不需要ArrayDeque的其他方法。

  • 若要在自己的代码中使用Stack类，需要完整指定包名或者更改这个类的名称；否则会与java.util包中的Stack冲突。 onjava.Stack<String> stk = new onjava.Stack<>();
  • 由于 Java.util 中 Stack 采用 vector 实现，而 vector 底层又采用数组实现，push、pop性能大大降低，因而最好不用或者自己封装一个 Stack 类最佳。

集合Set

Java文档链接
特性：

  • 元素不重复
  • Set就是一个Colletion，没有额外的功能，只是行为不同

应用：

  • 快速查询元素归属性（HashSet) contains()

Trick:

  • Treeset使用字典序排序，向构造器传入String.CASE_INSENSITIVE_ORDER 比较器。

Set words = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);

映射Map

Java文档链接

  • Map可以扩展到多个维度，只需要创建一个值为Map的Map（这些Map值可以是其他集合甚至是其他Map）
  • Map的一种遍历方法：
    1.   for(Person person : petPeople.keySet()) {   //keySet()获取petPeople所有键组成的Set
    2.     System.out.println(person + " has:");
    3.     for(Pet pet : petPeople.get(person))        //用key遍历value
    4.       System.out.println("    " + pet);
    5.   }

队列Queue

java文档链接
特性：

  • FIFO（先进先出）
  • LinkedList实现了Queue接口，可向上转型为Queue

常用函数：

  • offer()：在尾部插入一个元素。
  • peek()、element():返回队头元素
  • poll(),remove():删除并返回队头元素

PriorityQueue

优先级队列声明下一个弹出的元素是具有最高优先级的元素，可以提供自己的 Comparator 来修改这个顺序。
stringPQ = new PriorityQueue<>(strings.size(), Collections.reverseOrder());

集合与迭代器

在Java中，遵循集合之间的所有共性都是通过迭代器实现的，而不是用Colletion 表示集合之间的共性。
理解下述两种实现方式：

  1. public class InterfaceVsIterator {
  2.   public static void display(Iterator<Pet> it) { //Iterator
  3.     while(it.hasNext()) {
  4.       Pet p = it.next();
  5.       System.out.print(p.id() + ":" + p + " ");
  6.     }
  7.     System.out.println();
  8.   }
  9.   public static void display(Collection<Pet> pets) { //Iterable
  10.     for(Pet p : pets)
  11.       System.out.print(p.id() + ":" + p + " ");
  12.     System.out.println();
  13.   }
  14. }
  • 如果实现了 Collection ，就必须实现 iterator() ```java import typeinfo.pets.; import java.util.;

class PetSequence { protected Pet[] pets = Pets.array(8); }

public class NonCollectionSequence extends PetSequence { public Iterator iterator() { return new Iterator() { private int index = 0; @Override public boolean hasNext() { return index < pets.length; } @Override public Pet next() { return pets[index++]; } @Override public void remove() { // Not implemented throw new UnsupportedOperationException(); } }; } public static void main(String[] args) { NonCollectionSequence nc = new NonCollectionSequence(); InterfaceVsIterator.display(nc.iterator()); } } //非常好的初学样例

  1. <a name="cWZZb"></a>
  2. ### 
  3. <a name="UgAIF"></a>
  4. ### for-in和迭代器
  6. - for-in 的实现是 Java中一个名为 **Iterable** 的接口，该接口包含一个能够生成 **Iterator** 的 `iterator()`  方法。所以只要创建了任意实现 **Iterable **的类，就可使用 for-in 语句。
  7. ```java
  8. public class IterableClass implements Iterable<String> {
  9.   protected String[] words = ("And that is how " +
  10.     "we know the Earth to be banana-shaped."
  11.     ).split(" ");
  12.   @Override
  13.   public Iterator<String> iterator() {
  14.     return new Iterator<String>() {
  15.       private int index = 0;
  16.       @Override
  17.       public boolean hasNext() {
  18.         return index < words.length;
  19.       }
  20.       @Override
  21.       public String next() { return words[index++]; }
  22.       @Override
  23.       public void remove() { // Not implemented
  24.         throw new UnsupportedOperationException();
  25.       }
  26.     };
  27.   }
  28.   public static void main(String[] args) {
  29.     for(String s : new IterableClass())
  30.       System.out.print(s + " ");
  31.   }
  32. }
  • for-in 不会自动装箱。

适配器方法惯用法

如果已有一个接口，需要另外一个接口，编写适配器解决。

  1. import java.util.*;
  3. public class MultiIterableClass extends IterableClass {
  4.   public Iterable<String> reversed() {
  5.     return new Iterable<String>() {
  6.       public Iterator<String> iterator() {
  7.         return new Iterator<String>() {
  8.           int current = words.length - 1;
  9.           public boolean hasNext() {
  10.             return current > -1;
  11.           }
  12.           public String next() {
  13.             return words[current--];
  14.           }
  15.           public void remove() { // Not implemented
  16.             throw new UnsupportedOperationException();
  17.           }
  18.         };
  19.       }
  20.     };
  21.   }
  22.   public Iterable<String> randomized() {  //random()并没有创建自己的Iteraotr
  23.     return new Iterable<String>() {          //而是返回被打乱的List的Iterator
  24.       public Iterator<String> iterator() {
  25.         List<String> shuffled =
  26.           new ArrayList<String>(Arrays.asList(words));
  27.         Collections.shuffle(shuffled, new Random(47));
  28.         return shuffled.iterator();
  29.       }
  30.     };
  31.   }
  32.   public static void main(String[] args) {
  33.     MultiIterableClass mic = new MultiIterableClass();
  34.     for(String s : mic.reversed())
  35.       System.out.print(s + " ");
  36.     System.out.println();
  37.     for(String s : mic.randomized())
  38.       System.out.print(s + " ");
  39.     System.out.println();
  40.     for(String s : mic)
  41.       System.out.print(s + " ");
  42.   }
  43. }

理解并重写葫芦娃！

collection.png
map.png