Java编程思想读书笔记-5

第11章 持有对象

11.2 基本概念

Collection

List必须按照插入的顺序保存元素，而Set不能有重复元素，Queue按照排队规则来确定对象产生的顺序(通常与插入顺序保持一致)

Map

一组成对的"键值对"对象，允许使用键值来查找值。

11.3 添加一组元素

import java.util.Arrays;import java.util.List;class Snow{}class Powder extends Snow{}class Light extends Powder{}class Heavy extends Powder{}class Crusty extends Snow{}class Slush extends Snow{}public class AsListInference{public static void main(String[] args){List<Snow> snow1 = Arrays.asList(new Crusty(), new Slush(), new Powder());// Light 和 Heavy都是Powder，snow2的asList中只有Powder类型的，所以只会创建List<Powder>而不是List<Snow>//List<Snow> snow2 = Arrays.asList(//new Light(), new Heavy());// 显示声明了类型List<Snow> snow3 = Arrays.<Snow>asList(new Light(), new Heavy());}}

11.4 容器的打印

import java.util.ArrayList;import java.util.Collection;import java.util.HashMap;import java.util.HashSet;import java.util.LinkedHashMap;import java.util.LinkedHashSet;import java.util.LinkedList;import java.util.Map;import java.util.TreeMap;import java.util.TreeSet;public class PrintContainers{static Collection<String> fill(Collection<String> collection){collection.add("rat");collection.add("cat");collection.add("dog");collection.add("dog");return collection;}static Map<String, String> fill(Map<String, String> map){map.put("rat", "Fuzzy");map.put("cat", "Rags");map.put("dog", "Bosco");map.put("dog", "Spot");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>()));}}

结果：

[rat, cat, dog, dog][rat, cat, dog, dog][cat, dog, rat][cat, dog, rat][rat, cat, dog]{cat=Rags, dog=Spot, rat=Fuzzy}{cat=Rags, dog=Spot, rat=Fuzzy}{rat=Fuzzy, cat=Rags, dog=Spot}

ArrayList和LinkedList都是List类型，按照插入的顺序保存元素。不同之处为两者在执行某些类型的操作时的性能，LinkedList包含的操作较多。

HashSet，TreeSet和LinkedHashSet都是Set类型，具有非重复性，但存储元素的方式不尽相同。HashSet具有最快获取元素的方式，TreeSet按照升序保存对象，LinkedHashSet按照添加的顺序保存对象。

HashMap，TreeMap和LinkedHashMap都是Map类型，通过键值可以来查找对象。HashMap具有最快获取元素的方式，TreeMap按照升序保存对象，LinkedHashMap按照添加的顺序保存对象。

11.5 List

ArrayList：适合随机访问，在但List中间插入和移除元素较慢

LinkedList：List中间插入和删除代价较低，提供了优化的顺序访问，但随机访问性能较差。

为什么不能用 new List()?

编程是要面向对象编程，针对抽象（接口），而非具体
List 是接口，ArrayList是实现
实现List接口的有ArrayList、LinkedList、Vector等，所以用哪个就直接new 一个接口实现
这是一种很好的设计模式.一个接口有多种实现，这种写法是java面向对象的一种思想，依赖倒置原则,即依赖于抽象不依赖于实现(具体)。
给调用者提供的应该是接口或者抽象类，而实现者可以实现或者继承接口或者抽象类来满足调用者，这样调用者不必知道实现者怎样操作，实现者也可以根据具体情，况去实现，这样去除了耦合。这就是java设计模式的基础思想之一。

11.6 迭代器

Iterator：hasNext(),next(),remove()(用于移除由next产生的最后一个元素)，单向访问

ListIterator：只能用于List类的访问，并且可以双向移动 hasNext(),next(),remove(),set()

11.7 LinkedList

实现了基本的List接口。getFirst(),element(),peek()都为获取第一个元素，List为空则getFirst()和element()抛出NoSuchElementException，而peek()则返回null。

removeFirst(),remove(),poll()都为删除元素，List为空removeFirst()和remove()抛出NoSuchElementException，而poll()则返回null。

addFirst(),add(),addLast()都为添加元素，removeLast()移除并返回列表的最后一个元素。

11.8 Stack

后进先出LIFO

用LinkedList来实现Stack

import java.util.LinkedList;public class Stack<T>{private LinkedList<T> storage = new LinkedList<T>();public void push(T v) { storage.addFirst(v);}public T peek() { return storage.getFirst();}public T pop() { return storage.removeFirst();}public boolean empty() { return storage.isEmpty();}public String toString() { return storage.toString();}}

11.10 Map

Mao与数组和其他的Collection一样，可以很容易扩展到多维。如Map<Person, List<Pet>>，表示有多个宠物的人的

11.11 Queue

先进先出FIFO 

优先级队列

import java.util.Arrays;import java.util.Collections;import java.util.HashSet;import java.util.List;import java.util.PriorityQueue;import java.util.Queue;import java.util.Random;import java.util.Set;public class PriorityQueueDemo{ public static void printQ(Queue queue){while(queue.peek() != null){System.out.print(queue.remove() + " ");}System.out.println();}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(25,22,20,18,14,9,3,1,1,2,3,9,14,18,21,23,25);priorityQueue = new PriorityQueue<Integer>(ints);printQ(priorityQueue);priorityQueue = new PriorityQueue<Integer>(ints.size(), Collections.reverseOrder());priorityQueue.addAll(ints);printQ(priorityQueue);String fact = "EDUCATION SHOULD ESCHEW OBFUSCATION";List<String> strings = Arrays.asList(fact.split(""));PriorityQueue<String> stringPQ = new PriorityQueue<String>(strings);printQ(stringPQ);stringPQ = new PriorityQueue<String>(strings.size(), Collections.reverseOrder());stringPQ.addAll(strings);printQ(stringPQ);Set<Character> charset = new HashSet<Character>();for(char c: fact.toCharArray()){charset.add(c);}PriorityQueue<Character> cQueue = new PriorityQueue<Character>(charset);printQ(cQueue);}}

结果：

0 1 1 1 1 1 3 5 8 14 1 1 2 3 3 9 9 14 14 18 18 20 21 22 23 25 25 25 25 23 22 21 20 18 18 14 14 9 9 3 3 2 1 1        A A B C C C D D E E E F H H I I L N N O O O O S S S T T U U U W W U U U T T S S S O O O O N N L I I H H F E E E D D C C C B A A          A B C D E F H I L N O S T U W 

11.13 Foreach与迭代器

import java.util.Collection;import java.util.Collections;import java.util.LinkedList;public class ForeachCollections{ public static void main(String[] args){Collection<String> cs = new LinkedList<String>();Collections.addAll(cs, "Take the long way home".split(" "));for(String s: cs){System.out.print(" " + s + " ");}}}

foreach可以与所有的Collection对象一起工作。原因是Java SE5中引入了Iterator接口(包含了产生Iterator的iterator()方法)，并且Iterator接口被foreach用来在序列中移动。所以如果你创建了任何实现Iterable变量，都可以将它用于foreach中：

import java.util.Iterator;public class IterableClass implements Iterable<String>{ protected String[] words = "And that is how we know the Earch to be banana-shaped.".split(" ");public static void main(String[] args){for(String s: new IterableClass()){System.out.print(s + " ");}}@Overridepublic Iterator<String> iterator() {// TODO Auto-generated method stubreturn new Iterator<String>(){private int index = 0;@Overridepublic boolean hasNext() {// TODO Auto-generated method stubreturn index < words.length;}@Overridepublic String next() {// TODO Auto-generated method stubreturn words[index++];}@Overridepublic void remove() {// TODO Auto-generated method stubthrow new UnsupportedOperationException();}};}}

foreach语句可以用于数组或其他任何Iterable，但是这并不意味者数组肯定是一个Iterable，而任何自动包装也不会自动发生

import java.util.Arrays;public class ArrayIsNotIterable {  static <T> void test(Iterable<T> ib){for(T t : ib){System.out.print(t + " ");}System.out.println();}public static void main(String[] args){test(Arrays.asList(1,2,3));String[]strings = {"A","B","C"};//array可以用,但是它不是iterable//test(strings);test(Arrays.asList(strings));}}

11.3.1 适配器方法惯用法

import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.Iterator;import java.util.List;import java.util.Random;public class MultiIterableClass extends IterableClass {  public Iterable<String> resversed(){return new Iterable<String>(){@Overridepublic Iterator<String> iterator() {// TODO Auto-generated method stubreturn new Iterator<String>(){int current = words.length-1;@Overridepublic boolean hasNext() {// TODO Auto-generated method stubreturn current > -1;}@Overridepublic String next() {// TODO Auto-generated method stubreturn words[current--];}@Overridepublic void remove() {// TODO Auto-generated method stubthrow new UnsupportedOperationException();}};}};}public Iterable<String> randomized(){return new Iterable<String>(){@Overridepublic Iterator<String> iterator() {// TODO Auto-generated method stubList<String> shuffled = new ArrayList<String>(Arrays.asList(words));Collections.shuffle(shuffled, new Random(47));return shuffled.iterator();}};}public static void main(String[] args){MultiIterableClass mic = new MultiIterableClass();for(String s:mic.resversed()){System.out.print(s + " ");}System.out.println();for(String s:mic.randomized()){System.out.print(s + " ");}System.out.println();for(String s:mic){System.out.print(s + " ");}}}

输出：

banana-shaped. be to Earch the know we how is that And is banana-shaped. Earch that how the be And we know to And that is how we know the Earch to be banana-shaped. 

Collection.shuffle()没有影响到原来的数组，只是打乱了shuffled中的引用，这样是因为randomized()方法用一个ArrayList将Arrays.asList()方法的结果包装了起来。如果Arrays.asList()方法产生的List被直接打乱，那么就会修改底层的数组。

import java.util.ArrayList;import java.util.Arrays;import java.util.Collections;import java.util.List;import java.util.Random;public class ModifyingArrayAsList {  public static void main(String[] args){Random random = new Random(47);Integer[] ia = {1,2,3,4,5,6,7,8,9,10};List<Integer> list1 = new ArrayList<Integer>(Arrays.asList(ia));System.out.println("Before shuffling: " + list1);Collections.shuffle(list1, random);System.out.println("After shuffling: " + list1);System.out.println("array: " + Arrays.toString(ia));List<Integer> list2 = Arrays.asList(ia);System.out.println("Before shuffling: " + list2);Collections.shuffle(list2, random);System.out.println("After shuffling: " + list2);System.out.println("array: " + Arrays.toString(ia));}}

第一种情况，Arrays.asList()的输出被传递给了ArrayList的构造器，这将创建一个引用ia的元素的ArrayList，因此打乱顺序不会影响该数组。如果直接使用Arrays.asList(ia)的结果，就会打乱ia的顺序。如果你执行的操作会修改这个list，并且你不想修改原来的数组，那么你就应该在另一个容器中创建一个副本。