Java编程思想之十一 持有对象
如果一个程序只包含固定数量的且其生命期都是已知的对象，那么这是一个非常简单的程序。
11.1 泛型和类型安全的容器
使用ArrayList：创建一个实例，用add()插入对象，然后用get()访问对象，此时需要使用索引，像数组一样，但不是要[]。
import java.util.ArrayList;
public class ApplesAndOrangesWithoutGenerice
{
@SuppressWarnings("unchecked")//不受检查异常的警告
public static void main(String[] args)
{
ArrayList apples = new ArrayList();
for (int i = 0; i < 3; i++)
{
apples.add(new Apple());
}
apples.add(new Orange());
for (Object obj : apples)
{
System.out.println(((Apple) obj).id());
}
}
}
class Apple
{
private static long counter;
private final long id = counter++;
public long id()
{
return id;
}
}
class Orange
{
}
ArrayList保存的是Object。
要想定义保存特定类型的ArrayLIst可以使用泛型<>。
import java.util.ArrayList;
public class ApplesAndOrangesWithoutGenerice
{
@SuppressWarnings("unchecked")//不受检查异常的警告
public static void main(String[] args)
{
ArrayList<Apple> apples = new ArrayList();
for (int i = 0; i < 3; i++)
{
apples.add(new Apple());
}
//apples.add(new Orange());
for (Object obj : apples)
{
System.out.println(((Apple) obj).id());
}
}
}
class Apple
{
private static long counter;
private final long id = counter++;
public long id()
{
return id;
}
}
class Orange
{
}
当指定了某个类型作为泛型参数时，并不仅限于只能将该确切类型的对象放置到容器中，向上转型也可以像作用于其他类型一样作用于泛型。
import java.util.ArrayList;
public class ApplesAndOrangesWithoutGenerice
{
@SuppressWarnings("unchecked")//不受检查异常的警告
public static void main(String[] args)
{
ArrayList<Apple> apples = new ArrayList();
for (int i = 0; i < 3; i++)
{
apples.add(new A());
apples.add(new B());
apples.add(new C());
}
//apples.add(new Orange());
for (Object obj : apples)
{
System.out.println(((Apple) obj).id());
}
}
}
class Apple
{
private static long counter;
private final long id = counter++;
public long id()
{
return id;
}
}
class A extends Apple
{
}
class B extends Apple
{
}
class C extends Apple
{
}
class Orange
{
}
11.2 基本概念
Java容器类类库的用途是保存对象，并将其划分为两个不同的概念：
- Collection。一个独立元素序列，这些元素都服从一条或多条规则。List必须按照插入的顺序保存元素，而set不能保存重复元素。
- Map。一组成对的键值对对象，允许你使用键来查找值。映射表允许我们使用另一个对象来查找某个对象，它也被称为关联数组，因为它将对象于另外一个对象关联到了一起。或者被称为字典。
List<Type> types=new ArrayList<Type>()
ArrayList被向上转型为List。
Conllection接口概括了序列的概念——一种存放一组对象的方式。
import java.util.ArrayList;
import java.util.Collection;
public class SimpleCollection
{
public static void main(String[] args)
{
Collection<Integer> c = new ArrayList<Integer>();
for (int i = 0; i < 10; i++)
{
c.add(i);
}
for (int i : c)
{
System.out.println(i);
}
}
}
11.3 添加一组元素
Arrays.asList()方法接受一个数组或一个用逗号分隔的元素列表，并将其转换为一个List对象。Collections.addAll()方法接受一个Collection对象，以及一个数组或一个用逗号分隔的列表，将元素添加到Collection中。
import java.util.*;
public class AddingGroups
{
public static void main(String[] args)
{
Collection<Integer> collection = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4));
Integer[] moreInts = {6, 7, 8, 9};
collection.addAll(Arrays.asList(moreInts));
Collections.addAll(collection,12,13,14); Collections.addAll(collection,moreInts);
List<Integer> list=Arrays.asList(13,14,15);
}
}
Collection.addAll()成员方法只能接受一个Collection对象作为参数，因此不如Arrays.asList()和Collections.addAll()灵活，着两个方法都可以是可变参数。
可以直接使用Arrays.asList()的输出，将它当成List，但在这种情况下，地城是数组。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class AsListInference
{
public static void main(String[] args)
{
List<Snow> snow1 = Arrays.asList(new P(), new S());
List<Snow> snow2 = Arrays.asList(new P(), new S(), new L());
List<Snow> snow3 = Arrays.asList(new H(), new L());
List<Snow> snow4 = new ArrayList<Snow>();
Collections.addAll(snow4, new P(), new L());
List<Snow> snow5 = Arrays.<Snow>asList(new L());//显示类型参数说明
}
}
class Snow{}
class P extends Snow{}
class L extends P{}
class H extends P{}
class S extends Snow{}
11.4 容器的打印
import java.util.*;
public class PrintingContainers
{
static Collection fill(Collection<String> coll)
{
coll.add("rat");
coll.add("cat");
return coll;
}
static Map fill(Map<String, String> map)
{
map.put("rat", "r");
map.put("cat", "c");
return map;
}
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>()));
}
}
Collection在每个槽中只能保存一个元素，此类容器还包括List。Map每个槽内保存两个元素，键和值相关联的值。
ArrayList和LinkedList都是List类型，从输出可以看出，它们都是按照被插入的顺序保存元素的。
两者的不同之处不仅在于执行某写类型的操作时的性能。而且LinkedList包括的操作也多于ArrayList。
HashSet、TreeSet和LinkedHashSet都是Set类型。
Map使得你可以用键来查找对象，就像一个简单的数据库。键所关联的对象称为值。
HashSet一样，HashMap也提供了最快的查找技术，也没有按照任何明显的顺序来保存元素。TreeMap按照比较结果的升序保存键，而LinkedHashMap则按照插入顺序保存键，同时还保留了HashMap的查询速度。
11.5 List
List可以将元素维护在特定的序列中。List接口在Collection的基础上添加大量的方法，使得可以在List的中间插入和移除元素。
有两种类型的List:
- 基本的ArrayList，它长于随机访问元素，但使在List的中间插入和移除元素时较慢。
- LinkedList，它通过代价较低的在List中间进行的插入和删除操作，提供了优化的顺序访问。LinkedList在随机访问方面比较慢，但是它的特性集较ArrayList更大。
11.6 迭代器
持有事物是容器最基本的工作，要使用容器，必须对容器的确切类型编程。
如果只要使用容器，不知道或者不关心容器的类型，要如何不重写代码就可以应用于不同类型的容器？
使用迭代器：迭代器是一个对象，它的工作是遍历并选择序列中的对象，而客户端程序员不需要指定序列底层的结构。迭代器通常被称为轻量级对象：创建它的代价很小，经常可以看到对迭代器的奇怪限制。
比如Java中的Iterator只能单向移动。
接受对象容器并传递它，从而再每个对象上都执行操作。
创建一个display方法，不必知道容器的确切类型：
display方法不包含任何有关它遍历的序列的类型信息：能够将遍历序列的操作与序列底层的结构分离。所以，迭代器统一了对容器的访问方式。
11.6.1 ListIterator
ListIterator是一个更加强大的Iterator的子类型，它只能用于各种List类访问。但ListIterator可以双向移动。
11.7 LinkedList
LinkedList也像ArrayList一样实现了基本的List接口，但是它执行某些操作比ArrayList更高效，但再随机访问操作要差一些。
11.8 Stack
栈通常是指后进先出的容器。有时也被称为叠加栈，因为最后压入栈的元素，第一个弹出栈。
直接将LinkedList作为栈使用。
import java.util.LinkedList;
public class Stack<T>
{
LinkedList<T> storage=new LinkedList<T>();
public void push(T t){storage.addFirst(t);}//插入一个元素
public T peek(){return storage.getFirst();}//获取第一个元素
public T pop(){return storage.removeFirst();}//移除第一个元素
public boolean empty(){return storage.isEmpty();}//是否还有元素
public String toString(){return storage.toString();}
}
创建一个新的Stack类：
public class StackTest
{
public static void main(String[] args){
Stack<String> stack=new Stack<String>();
for(String s:"My dog has fleas".split(" "))
stack.push(s);
while (!stack.empty())
System.out.println(stack.pop());
}
}
11.9 Set
Set不保存重复的元素。
Set具有与Collection完全一样的接口。实际上Set就是Collection，只是行为不同。Set基于对象的的值来确定归属性。
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
public class SetOfInteger
{
public static void main(String[] args){
Random rand=new Random(47);
Set<Integer> intset=new HashSet<Integer>();
for (int i=0;i<10;i++)
intset.add(rand.nextInt(30));
for(int i:intset)
System.out.println(i);
}
}
HashSet所维护的顺序与TreeSet或LinkedHashSet都不同。TreeSetj将元素存储再红——黑树数据结构中，而HashSet使用的是散列函数。LinkedHashList因为查询速度的原因也使用了散列。
对结构排序，使用TreeSet来代替HashSet
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
public class SetOfInteger
{
public static void main(String[] args){
Random rand=new Random(47);
Set<Integer> intset=new TreeSet<Integer>();
for (int i=0;i<10;i++)
intset.add(rand.nextInt(30));
for(int i:intset)
System.out.println(i);
}
}
使用contains()测试Set归属性
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
public class SetOperations
{
public static void main(String[] args){
Set<String> set1=new HashSet<String>();
Collections.addAll(set1,"a b c d e f g".split(" "));
set1.add("m");
System.out.println("m:"+set1.contains("m"));
System.out.println("h:"+set1.contains("h"));
}
}
打开文件，并将其读入一个Set中。
TextFile继承自List< Sting >，其构造器将打开文件，并更具正则表达式将其断开。
如果要按照字母排序，可以向TreeSet构造器传入String.CASE_INSENTIVE_ORDER比较器。
import net.mindview.util.TextFile;
import java.util.Set;
import java.util.TreeSet;
public class UniqueWordsAlphabetic
{
public static void main(String[] args){
Set<String> words=new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
words.addAll(new TextFile("第十一章持有对象\\src\\SimpleCollection.java","\\W+"));
System.out.println(words);
}
}
11.10 Map
将对象映射到其他对象的能力是一种解决编程问题的杀手锏。
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MapOfList
{
public static Map<Integer, List<? extends Person>> petPeople = new HashMap<Integer, List<? extends Person>>();
static {
petPeople.put(1, Arrays.asList(new Man("aaa"),new WoMan("bbb")));
}
public static void main(String[] args){
System.out.println(petPeople.keySet());
System.out.println(petPeople.values());
System.out.println(petPeople);
}
}
class Person
{
private String name;
Person(String name){
this.name=name;
}
}
class Man extends Person
{
public Man(String name){
super(name);
}
}
class WoMan extends Person
{
WoMan(String name){
super(name);
}
}
Map可以返回它的键的Set，它的值Collection，或者它的键值对的Set。
11.11 Queue
队列是一个典型的先进先出的容器。队列在并发编程中特别重要，因为它们可以安全地将对象从一个任务传输给另一个任务。
LinkedLisk提供了方法以支持队列的行为，并且它实现了Queue接口，因此LinkedLisk可以用作Queue的一种实现。
import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
public class QueueDemo
{
public static void printQ(Queue queue){
while (queue.peek()!=null)
System.out.print(queue.remove()+" ");
System.out.println();
}
public static void main(String[] args){
Queue<Integer> queue=new LinkedList<Integer>();
Random ran=new Random();
for(int i=0;i<10;i++)
queue.offer(ran.nextInt(i+10));
printQ(queue);
Queue<Character> qc=new LinkedList<Character>();
for (char c:"Brontosaurus".toCharArray())
qc.offer(c);
printQ(qc);
}
}
offer()方法将一个元素插入到队尾，或者返回false。peek()和element()都将在不移除的情况下返回对头。poll()和remove()方法将移除并返回对头。
11.11.1 PriorityQueue
优先级队列声明下一个弹出元素最需要的元素。
当你在PriorityQueue上调用offer()方法来插入一个对象时，这个对象会在队列中被排序。默认排序将使用对象在队列中自然顺序，但你可以通过提供自己的Comparator来修改这个顺序。
import java.util.*;
public class PriorityQueueDemo
{
public static void main(String[] args)
{
PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>();
Random rand = new Random(47);
for (int i = 0; i < 10; i++)
priorityQueue.offer(rand.nextInt(i + 10));
QueueDemo.printQ(priorityQueue);
List<Integer> ints = Arrays.asList(25, 22, 20, 18, 14, 9, 3, 1, 1, 2, 3);
priorityQueue = new PriorityQueue<Integer>(ints);
QueueDemo.printQ(priorityQueue);
priorityQueue = new PriorityQueue<Integer>(ints.size(), Collections.reverseOrder());
priorityQueue.addAll(ints);
QueueDemo.printQ(priorityQueue);
String face = "EDUCATION SHOULD ESCHEW";
List<String> strings = Arrays.asList(face.split(" "));
PriorityQueue<String> stringPQ = new PriorityQueue<String>(strings);
QueueDemo.printQ(stringPQ);
stringPQ = new PriorityQueue<String>(strings.size(), Collections.reverseOrder());
stringPQ.addAll(strings);
QueueDemo.printQ(stringPQ);
Set<Character> characters = new HashSet<Character>();
for (char c : face.toCharArray())
characters.add(c);
PriorityQueue<Character> characterspc = new PriorityQueue<Character>(characters);
QueueDemo.printQ(characterspc);
}
}
在PriorityQueue重复是允许的，最小值拥有最高优先级。
11.12 Collection和Iterator
Collection是描述所以有序列容器的共性的根接口，它可能会被认为是一个附属接口，即因为要表示其他若干接口的共性出现的接口。
通过针对接口而非具体实现编写代码，我们的代码可以应用于更多的对象类型。
import java.util.*;
public class InterfaceVsIterator
{
public static void display(Iterator<Integer> it)
{
while (it.hasNext())
{
Integer i = it.next();
System.out.print(i+",");
}
System.out.println();
}
public static void display(Collection<Integer> ints)
{
for(Integer i:ints)
System.out.print(i+"-");
System.out.println();
}
public static void main(String[] args)
{
List<Integer> intList= Arrays.asList(1,2,3,15,3);
Set<Integer> intSet=new HashSet<Integer>(intList);
Map<String,Integer> intmap=new LinkedHashMap<String,Integer>();
String[] s=new String[]{"A","b","c","f","w"};
for(int i=0;i<s.length;i++)
intmap.put(s[i],intList.get(i));
display(intList);
display(intSet);
display(intList.iterator());
System.out.println(intmap);
System.out.println(intmap.keySet());
display(intmap.values());
display(intmap.values().iterator());
}
}
Collection和Iterator都可以将display()方法与底层容器的特定实现解耦。
import java.util.AbstractCollection;
import java.util.Iterator;
public class CollectionSequence extends AbstractCollection<Integer>
{
private Integer[] ints=new Integer[]{1,4,2,5,1};
@Override
public Iterator<Integer> iterator()
{
return new Iterator<Integer>()
{
private int index=0;
@Override
public boolean hasNext()
{
return index<ints.length;
}
@Override
public Integer next()
{
return ints[index++];
}
};
}
@Override
public int size()
{
return ints.length;
}
public static void main(String[] args){
CollectionSequence c=new CollectionSequence();
InterfaceVsIterator.display(c);
InterfaceVsIterator.display(c.iterator());
}
}
生成Iterator是将队列与消费队列的方法连接在一起耦合度最小的方式，并且与1实现Collection相比，它在序列类上所加的约束少得多。
import java.util.Iterator;
public class NonCollectionSequence extends PetSequence
{
public Iterator<Integer> iterator()
{
return new Iterator<Integer>()
{
int index = 0;
@Override
public boolean hasNext()
{
return index < ints.length;
}
@Override
public Integer next()
{
return ints[index++];
}
};
}
public static void main(String[] args){
NonCollectionSequence nc=new NonCollectionSequence();
InterfaceVsIterator.display(nc.iterator());
}
}
class PetSequence
{
protected int[] ints = new int[]{1, 4, 2, 5, 3};
}
11.13 Foreach与迭代器
foreach语法主要用于数组，但它也可以用于任何Collection对象。
Java SE5引入了新的被称为Iterable接口，该接口包含一个能够产生Iterator的iterator()方法，并且Iterable接口被foreach用来在序列中移动。因此，如果你创建了一个Iterable的类，都可以用于foreach。
import java.util.Iterator;
public class IterableClass implements Iterable<String>
{
protected String[] words = ("a,d,fe,r,gd,v,g").split(",");
@Override
public Iterator<String> iterator()
{
return new Iterator<String>()
{
int index = 0;
@Override
public boolean hasNext()
{
return index < words.length;
}
@Override
public String next()
{
return words[index++];
}
};
}
public static void main(String[] args){
for(String s:new IterableClass())
System.out.print(s+",");
}
}
在Java SE中，大量的类都是Iterable类型，主要包括所有Collection类（不包括各种Map）
foreach可以用于数组或其他任何Iterable，但是这并不意味着数组肯定也是一个Iterable，二任何自动包装也不会发生。
import java.util.Arrays;
public class ArrayIsMotIterable
{
static<T> void test(Iterable<T> ib){
for(T t:ib)
System.out.print(t+" ");
}
public static void main(String[] args){
test(Arrays.asList(1,2,3,2));
String[] strings={"a","b","c"};
//test(strings);//转换失败
test(Arrays.asList(strings));
}
}
尝试把数组转换成Iterable会失败，不存在任何数组到Iterable的自动转换，必须手工执行这种转换。
11.13.1 适配器方法惯用法
希望在默认向前的迭代器基础上，添加产生反向迭代器的能力，因此，不能使用覆盖，需要添加一个能够产生Iterable对象的方法，该对象可以用于foreach语句。
mport java.util.Iterator;
public class IterableClass implements Iterable<String>
{
protected String[] words = ("a,d,fe,r,gd,v,g").split(",");
@Override
public Iterator<String> iterator()
{
return new Iterator<String>()
{
int index =words.length-1 ;
@Override
public boolean hasNext()
{
return index > -1;
}
@Override
public String next()
{
return words[index--];
}
};
}
public static void main(String[] args){
for(String s:new IterableClass())
System.out.print(s+",");
}
}
如果直接将ral对象置于foreach语句中，将得到向前迭代器。但如果在对象上调用产生向后迭代器的方法，就会产生不同的行为了。
通过这种方式，可以添加两种适配器方法。
