持有对象

• 11 . java容器就是用来保存对象 除了数组外 还有集合
  分为：Collection,Map 两大类
  Collection：List顺序保存元素，Set不能有重复元素，Queue按照排队来
  Map： 按照键值对保存元素
• 11.1 List
  11.1.1 ArrayList 擅长于访问元素 但是在List的中间插入元素和移除元素就较慢

package com.zlb.list;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
class Fruit{
    public Fruit(){}
}
class Apple extends Fruit{}
class Banana  extends Fruit{}
class Grape  extends Fruit{}
class Pineapple  extends Fruit{}
class Peach  extends Fruit{}
class Strawberry   extends Fruit{}
class Mango   extends Fruit{}
class Cherry   extends Fruit{}
class Pawpaw extends Fruit{}
class Grapefruit extends Fruit{}
public class arrayList {
     public static List<Fruit> list(){
         ArrayList<Fruit> list = new ArrayList<Fruit>();
         Fruit[] fruits = {new Banana(),new Grape(),new Pineapple(),new Peach(),new Strawberry(),new Mango()};
         Collections.addAll(list, fruits);
         return list;
     }
    public static void main(String[] args) {
        Random rand = new Random(47);
        List<Fruit> list = list(); 
        System.out.println("1："+list);
        Fruit cherry = new Cherry();
        list.add(cherry);
        System.out.println("2："+list);
        System.out.println("3："+list.contains(cherry));
        list.remove(cherry);
        Fruit fruit = list.get(2);
        System.out.println("4："+fruit+"\t"+list.indexOf(fruit));
        Fruit cherry1 = new Cherry();;
        System.out.println("5："+list.indexOf(cherry1));
        System.out.println("6："+list.remove(cherry1));
        System.out.println("7："+list.remove(fruit));
        System.out.println("8："+list);
        list.add(3,new Grapefruit());
        System.out.println("9："+list);
        List<Fruit> sub = list.subList(0, 3);
        System.out.println("10："+sub);
        System.out.println("11："+list.containsAll(sub));
        Collections.shuffle(sub, rand);
        System.out.println("12："+sub);
    }
}

11.1.2 LinkList 实现了List的基本接口 在插入和移除操作时较快 但在查询时较慢

 package com.zlb.list;
import java.util.LinkedList;
public class linkList {
    public static void main(String[] args) {
        LinkedList<Fruit> list = new LinkedList<Fruit>(arrayList.list());
        //list.push(new Grape());
        System.out.println("list.getFirst()："+list.getFirst());//得到表头
        System.out.println("list.pop()："+list.pop());//得到表头 并移除表头
        System.out.println("list.getFirst()："+list.getFirst());//得到表头
        System.out.println("list.element()："+list.element());//得到元素
        System.out.println("list.getLast()："+list.getLast());//得到最后一个
        System.out.println("list.peek()："+list.peek());//返回表头
        System.out.println("list.peekFirst()："+list.peekFirst());//移除最后一个
        System.out.println("list.pop()："+list.pop());//返回表头 在移除表头
        System.out.println("list.getFirst()："+list.getFirst());//得到表头
        System.out.println("list.remove()："+list.remove(1));//根据索引移除元素
    System.out.println("list.removeFirst()："+list.removeFirst());//移除表头
System.out.println("list.removeLast()："+list.removeLast());//移除最后一个
    }
}

• 11.2 迭代器
  迭代器是一个对象 用来遍历并选择序列中的对象，java中的迭代器只能单向的向前移动：
  (1) 使用一个方法iterator()要求容器返回一个Iterator
  (2) 使用next()会的序列中的下一个元素
  (3)使用hasnext()检测序列中是否还有元素
  (4)使用remove()将迭代器中新返回的元素删除

 Iterator<Fruit> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        for(Fruit str : list){
            System.out.println(str.toString());
        }

• 11.3 Set
  Set不保存重复的元素
  HashSet 使用了散列存储方式 因此元素是无序的
  TreeSet 使用了基于红黑树的数据结构的存储方式因此元素是有序的

 package com.zlb.list;
 import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class set {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        Collections.addAll(set, "E F G H I J K K A A B C C D".split(" "));
        Iterator<String> ite = set.iterator();
        while(ite.hasNext()){
            System.out.print(ite.next());
        }
        set.add("L");
        set.add("V");
        set.add("W");
        Set<String> set1 = new HashSet<String>(set);
        //System.out.println(set.contains(set1));
        System.out.println(set1.contains(set));
    }
}

• 11.4 Map(以键值对的方式存储数据)
  Map中的HashMap不保证映射顺序，保证基本操作（get 和 put）提供稳定的性能，那么LinkedHashMap就通过一个双重链表保证了顺序（迭代顺序）

package com.zlb.list;
 import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class map {
    public static Map<String,List<? extends Fruit>> fruit = new HashMap<String,List<? extends Fruit>>();
    static {
        fruit.put("Banana", Arrays.asList(new Banana(),new Grape()));
        fruit.put("Pineapple", Arrays.asList(new Pineapple(),new Peach()));
        fruit.put("Strawberry", Arrays.asList(new Strawberry(),new Mango(),new Cherry()));
    }
    public static void main(String[] args) {
        System.out.println("["+fruit.keySet()+"="+fruit.values()+"]");
        for(String str : fruit.keySet()){
            for(Fruit frui : fruit.get(str)){
                System.out.println(frui);
            }
        }
    }
}

• 11.5 Stack (栈是一种先进后出的容器，LinkList具有实现Stack所有功能的方法)

package com.zlb.list;
 import java.util.Stack;
public class stack {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<String>();
        for(String str : "My,Name,Is,Zhou,li,bin".split(",")){
            stack.push(str);//压入栈 先进后出
        }
        while(!stack.empty()){
            System.out.println(stack.pop());//返回表头 并移除表头
            System.out.println(stack.peek());//返回表头 
        }
    }
}

• 11.6 Queue(队列是一种先进先出的容器，事务放入的容器的顺序与取出的顺序是相同的,LinkList实现了Queue的接口)

 package com.zlb.list;
 import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
public class queue {
    public static void printQ(Queue queue){
        while(queue.peek()!=null){//返回表头
            //System.out.print(queue.peek()+"\t");
            //System.out.println();
            System.out.print(queue.remove()+" ");//移除表头并回
        }
    }
    public static void main(String[] args) {
        Queue<Integer> queue1 = new LinkedList<Integer>();
        Queue<Character> queue2 = new LinkedList<Character>();
        Random rand = new Random(47);
        for(int i=0;i<10;i++){
            queue1.offer(rand.nextInt(i+10));
        }
        for(char c : "zhoulibin".toCharArray()){
            queue2.offer(c);
        }
    //  printQ(queue1);
        printQ(queue2);
    }
}