使用Collection收集对象
Collection架构
在Java SE中，我们有各种各样的API可以使用，数量庞大，种类繁杂，我们要熟用这些API，就需要去了解他们的继承与接口操作，知道在何时该用哪个类，而不用死背API。为此，我们必须熟悉他们的接口继承架构设计。所以在学习前，我们来看一下Collection的继承接口架构：
从这个图片中，我们可以很清晰的看出每个类与接口的继承关系，哪个类调用了哪个接口。对于这张图中的接口，接下来我会给大家一一介绍。
注：图中的实线表示继承，虚线表示操作这个接口，凡是没有标示interface的，都表示的是类。
具有索引的List
List是一种Collection，由这句话可以知道List是继承了Collection接口的，它的作用是收集对象。从上图中我们可以看到，操作List的类有两个，一个是ArrayList，另一个是LinkedList。当我们需要以索引方式保留收集的对象顺序，就需要操作这个接口。
List接口定义了add(),remove(),set()等许多依索引操作的方法。那么我们刚也说过，操作List接口的类有两个，我们什么时候用ArrayList，什么时候用LinkedList呢？
- ArrayList: ArrayList操作时内部就是用Object数组来保存收集的对象，既然是数组，那么他就拥有数组的优势与劣势，对于查找和排序来说，他是非常方便的。一旦涉及到了删除，添加元素，那么他就没有链表来的方便，并且数组的长度问题我们也是需要关注的，一旦ArrayList内部数组的长度不够的时候，就会建立新的数组，并将旧的数组参考指定给新数组，这肯定是浪费时间与内存的。好在的是ArrayList类提供了一个构造函数，可以让我们指定这个数组的容量。
- LinkedList: 对于这个类，和C语言中链表的构造方法是很类似的，我们可以来看一下构造这个类的方法，它拥有链表的优势，适合删除，添加元素，并且不会浪费内存空间。
/**
* Created by paranoid on 16-12-8.
*/
public class SimpleLinkedList {
private class Node{ //将收集到的对象用Node进行封装
Node(Object o){
this.o = o;
}
Object o;
Node next;
}
private Node first; //指向第一个节点
public void add(Object elem){ //添加新的Node封装对象
Node node = new Node(elem);
if(first == null){
first = node;
}
else{
append(node);
}
}
private void append(Node node){
Node last = first;
while(last.next != null){
last = last.next;
}
last.next = node;
}
public int size(){
int count = 0;
Node last = first;
while(last != null){
last = last.next;
count++;
}
return count;
}
public Object get(int index){
checkSize(index);
return findElemOf(index);
}
private void checkSize(int index) throws IndexOutOfBoundsException{
int size = size();
if(index >= size){
throw new IndexOutOfBoundsException(
String.format("Index: %d, Size: %d", index, size));
}
}
private Object findElemOf(int index){ //访问所有的Node并计数以取得对应的索引对象
int count = 0;
Node last = first;
while(count < index){
last = last.next;
count++;
}
return last;
}
}我们可以看到，它的构造过程和链表是十分类似的。
内容不重复的Set
当我们收集对象的时候，需要收集的对象之中不能有重复的对象，当我们有这个需求的时候，就可以使用Set接口。我们在上面那个图中可以看到，操作这个接口的类有两个，分别是HashSet和TreeSet。我们先来介绍HashSet：
import java.util.*;
/**
* Created by paranoid on 16-12-8.
*/
public class WordCount {
public static void main(String[] args){
Scanner console = new Scanner(System.in);
System.out.print("请输入英文:");
Set words = tokenSet(console.nextLine());
System.out.printf("不重复的单词有%d 个: %s\n", words.size(), words);
}
static Set tokenSet(String line){
String[] tokens = line.split(" "); //根据空白切割出字符串
return new HashSet(Arrays.asList(tokens));
}
}运行结果：
因为Arrays.asList()方法返回List，而List是一种Collection，因此它可以传给HashSet，最后得到正确的结果。
但是我们有时候单单使用这个方法的话是会出现失败的，如果我们收集的是对象，然后我们还没有告诉Set什么样的实例才算是重复，那么程序的运行结果就有可能和我们的预期是有偏差的，对于HashSet怎么来判断对象相同，这是由它内部的hashcode和equals方法进行的。刚开始我也没把这部分内容没有弄明白，所以在网上找了一些资料，如果大家也不懂得话，我转载了一篇博客，名字叫做《什么时候需要重写equals方法？为什么重写equals方法，一定要重写HashCode方法？》大家可以看看。在这里我直接上代码：
/**
* Created by paranoid on 16-12-8.
*/
import java.util.*;
class Student2 {
private String name;
private String number;
Student2(String name, String number){
this.name = name;
this.number = number;
}
@Override
public int hashCode(){
//Object有hash方法可以用
//以下可以简化为return Objects.hash(name, number);
int hash = 7;
hash = 47 * hash + Objects.hashCode(this.name);
hash = 47 * hash + Objects.hashCode(this.number);
return hash;
}
@Override
public boolean equals(Object obj){
if(obj == null){
return false;
}
if(getClass() != obj.getClass()){
return false;
}
final Student2 other = (Student2) obj;
if(!Objects.equals(this.name, other.name)){
return false;
}
if(!Objects.equals(this.number, other.number)){
return false;
}
return true;
}
@Override
public String toString(){
return String.format("(%s %s)", name, number);
}
}
public class Students2{
public static void main(String[] args){
Set students = new HashSet();
students.add(new Student2("justin", "B835031"));
students.add(new Student2("Monica", "B835032"));
students.add(new Student2("justin", "B835031"));
System.out.println(students);
}
}支持队列操作的Queue
如果我们希望收集对象的时候是以队列的方式进行收集，那么我们可以操作Queue接口。Queue继承自Collection，所以也有add(),remove(),element()等方法，然而Queue定义了offer，poll，peek等方法，他们之间的差别最主要的在于前三个方法操作失败时会抛出异常，但是后三个方法操作失败时会返回特定的值。
- offer(): 在队列后端加入对象；
- poll(): 在队列前端取出对象；
- peek(): 取得队列前端的对象，但不取得。
前面提到的LinkedList不仅操作了List接口，也操作了Queue的行为。，具体代码我就不在这里陈列了。我们来看一下Queue的子接口Deque。
Deque允许在队列的两端进行操作，我们来看一个使用Deque来操作容量有限的堆栈：
/**
* Created by paranoid on 16-12-8.
*/
import java.util.*;
import static java.lang.System.out;
public class Stack {
private Deque elems = new ArrayDeque();
private int capacity;
public Stack(int capacity){
this.capacity = capacity;
}
public boolean push(Object elem){
if(isFull()){ //判断栈是否已满
return false;
}
return elems.offerLast(elem);
}
private boolean isFull(){
return elems.size() + 1 > capacity;
}
public Object pop(){
return elems.pollLast();
}
public Object peek(){
return elems.peekLast();
}
public static void main(String[] args){
Stack stack = new Stack(5);
stack.push("Justin");
stack.push("Monica");
stack.push("Irene");
out.println(stack.pop());
out.println(stack.pop());
out.println(stack.pop());
}
}运行结果：
由于栈是先进后出，所以最先进去的Justin最后显示出来。
使用泛型
在使用Collection收集对象时，由于事先不知道收集对象的类型，因此内部操作时，都是使用Object来收集被参考的对象，取回对象时也是以Object类型返回，所以如果我们针对某类定义的行为操作时，就必须告诉编译程序，让对象重新扮演该类型。例如：
List names = Arrays.asList("Justin", "Monica", "Irene");
String name = (String) names.get(0);Collection收集对象时，考虑到收集各种对象的需求，因此内部操作采用Object参考收集的对象，这会让执行时期被收集的对象失去形态信息，因此取回对象之后，必须自行记得对象的真正类型。
虽然Collection被用于收集各种对象，但实际上Collection通常会收集同一种类型的对象，例如都是手机字符串的对象。这时候，我们就可以使用泛型语法。
/**
* Created by paranoid on 16-12-8.
*/
import java.util.Arrays;
public class ArrayList <String>{
private Object[] elems;
private int next;
public ArrayList(int capacity){
elems = new Object[capacity];
}
public ArrayList(){
this(16);
}
public void add(String e){
if(next == elems.length){
elems = Arrays.copyOf(elems, elems.length * 2);
}
elems[next++] = e;
}
public String get(int index){
return (String) elems[index];
}
public int size(){
return next;
}
}从上面的代码我们可以看到，在类名称的旁边出现了 string，这表示此类型支持泛型，实际加入ArrayList的对象会是客户端声明的String，当然也可以是其他类型。之后我们如果调用这个类，就可以这样进行：
ArrayList<String> names = new ArrayList<>(); //JDK7之后的写法
names.add("Justin");
String name = names.get(0);接口也可以使用泛型，使用方法同上。
Interable与Iterator
从第一张图我们可以看到，Collection继承自Interable。在JDK5中有一个方法是定义在Collection之中的，这个方法就是Iterator，它会返回Java.util.Iterator接口的操作对象，这个对象包括了Collection收集的所有对象，我们可以先使用Iterator的hasNext方法看看有无下一个对象，若有的话再使用next方法取得下一个方法。由它来显示Collection所收集的对象，具体代码如下：
static void forEach(Collection collection){
Iterator iterator = collection.iterator();
while(iterator.hasNext()){
out.println(iterator.next());
}
}上面的写法也是可以的，但是在JDK5之后，原先定义在Collection中的iterator方法，提升值新的Interable接口，所以上面的代码只需进行简单的修改就可以使用，在这里我就不再赘述。
在Interable接口中，我们还可以使用增强式for循环来使上面代码更加简洁：
static void forEach(Iterable iterable){
for(Object o : iterable){
System.out.println("o");
}
}Comparable与Comparator
当我们收集到对象之后最常做的就是排序工作了吧，在Collections中提供有sort方法，但是一旦收集的对象中包含好几种类型之后，排序就不知道该按对象之中的哪种数据类型进行排序，这时候我们就要操作Comparable接口，这个接口有一个compareTo方法可以让我们指定由这个对象中的哪个数据类型来进行排序。我们来看一个例子：
/**
* Created by paranoid on 16-12-8.
*/
import java.util.*;
class Account2 implements Comparable<Account2>{
private String name;
private String number;
private int balance;
Account2(String name, String number, int balance){
this.name = name;
this.number = number;
this.balance = balance;
}
@Override
public String toString(){
return String.format("Account2(%s, %s, %d)", name, number, balance);
}
@Override
public int compareTo(Account2 other){
return balance - other.balance;
}
}
public class sort3{
public static void main(String[] args){
List accounts = Arrays.asList(
new Account2("Justin", "X1234", 1000),
new Account2("Monica","X5678",500),
new Account2("Irene", "x2468", 200)
);
Collections.sort(accounts);
System.out.println(accounts);
}
}在这个程序中，我们按照资金的大小进行了升序排序。
意外总是不断的发生，我们有可能在编写程序的时候出现这种情况：我们操作不了Comparable接口，也许我们拿不到原始码，也许我们不能修改原始码，举个例子，在String类中，本身就有操作Comparable，所以可以进行排序，然而如果我们突然想要进行降序排序，我们可以操作CompareTo方法吗?不能，因为String已经被声明为final，不能被继承，也就不能进行方法的重新定义。这个时候，我们可以使用Comparator接口，然后我们来重新定义其中的compare方法。具体代码如下：
/**
* Created by paranoid on 16-12-10.
*/
import java.util.*;
class StringComparator implements Comparator<String>{
@Override
public int compare(String s1, String s2){
return -s1.compareTo(s2);
}
}
public class sort {
public static void main(String[] args){
List<String> words = Arrays.asList("A", "B", "C", "D", "E");
Collections.sort(words ,new StringComparator());
System.out.println(words);
}
}例如上面的代码，我们在StringComparator这个勒种操作了Comparator这个接口，并且将compare方法进行了重新定义，由于s1，s2都是String，所以他们可以操作compareTo方法，将其返回值乘上-1，就是我们要的结果。
键值对应的Map
常用的Map操作类
首先既然我们要使用Map相关的API，那么我们就先来了解一下它的设计架构。
上图中，实线表示继承，虚线表示操作接口。
使用HashMap
在使用Map的时候，也可以使用泛型语法。来看个实例吧：
/**
* Created by paranoid on 16-12-10.
*/
import java.util.*;
import static java.lang.System.out;
public class Messages {
public static void main(String[] args){
Map<String, String> messages = new HashMap<>();
messages.put("Justin", "Hello! Justin的信息"); //建立键值对应
messages.put("Monica", "给Monica的悄悄话");
messages.put("Irene", "Irene的可爱猫喵喵叫");
Scanner console = new Scanner(System.in);
out.println("请输入要取得的信息:");
String message = messages.get(console.nextLine()); //指定键的返回值
out.println(message);
out.println(messages);
}
}
从上面的代码中我们可以很清楚的看到，当我们需要建立键值对应的时候，我们使用的是Map的put方法，对于Map而言，键不会重复，判断键是否会重复是根据HashCode和Equals，所以要成为键，这个对象必须操作HashCode和Equals。当我们要取回一个键对应的值，就是用Map的get方法就行了。看一下运行结果吧：
使用TreeMap
如果使用TreeMap，则键的部分会被排序，条件是作为键的对象必须操作Comparable接口，或者是在 创建TreeMap时指定操作Comparator接口的对象。这个的使用方法和上面的HashMap大同小异，我就不贴出代码了。
使用Properties
这个东西继承自HashTable，而HashTable操作了Map接口，所以Properties自然也拥有Map的行为。这个类更多的是用于字符串。setProperty指定字符串的键值，getProperty根据所指定的键取回对应的值。使用方法和上面的都一样，就不在赘述了。
访问Map键值
当我们想要取得Map中所有的键的时候，我们应该怎么办，虽然Map和Collection没有继承上的关系，但却是彼此搭配的API。由于键是不重复的，所以我们可以调用KeySet方法返回Set对象，这是理所当然的。如果想要返回值，那我们需要使用values（）返回Collection对象，来看一个具体操作的代码：
/**
* Created by paranoid on 16-12-10.
*/
import java.util.*;
import static java.lang.System.out;
public class MapKeyValue {
public static void main(String[] args){
Map<String, String> map = new HashMap<>();
map.put("one", "1");
map.put("two", "2");
map.put("three", "3");
out.println("显示键");
map.keySet().forEach(key -> out.println(key)); //Lambda语法
out.println("显示值");
map.values().forEach(key -> out.println(key));
}
}
对于上面代码中的Lambda语法之后会学习到，到时候在进行总结。