十八个常用Java集合类

//例6.1泛型类与非泛型类的区别：以LinkedList为例

import java.util.*;
class GenericTest1 {
	public static void main(String[] args) {
		LinkedList list = new LinkedList();//创建LinkedList集合
		list.add(new Integer(1)); //添加Integer对象到集合中
		list.add(new Integer(2)); //添加Integer对象到集合中
		list.add(new Integer(4)); //添加Integer对象到集合中
		list.add("Alice");//可以正常地将String对象添加到集合中
		int sum = 0;
		for(int i=0; i<list.size();i++){//累加所有Integer对象的数值之和
			Integer a = (Integer) list.get(i); //获取集合的第i个对象，并强制转型
			sum = sum + a.intValue(); //累加
		}
		System.out.println("sum = "+sum);
	}
}
class GenericTest2 {
	public static void main(String[] args) {
	//下一行代码创建管理Integer对象的LinkedList集合
	LinkedList<Integer> list = new LinkedList<Integer>();//确定类型参数E为Integer
		list.add(new Integer(1)); //添加Integer对象到集合中
		list.add(new Integer(2));
		list.add(new Integer(4));
		list.add("Alice"); //这行代码编译出错, 参数只能为String类型，
		int sum = 0;
		for(int i=0; i<list.size();i++){//累加所有Integer对象的数值之和
			Integer a = list.get(i); //不需要强制转换
			sum = sum + a.intValue();
		}
		System.out.println("sum = "+sum);
	}
}

//例6.2 通配符类型的使用示例

import java.util.*;
public class Test {
	public static void main(String[] args) {
		LinkedList<A> a = new LinkedList<A>();
		LinkedList<B> b = new LinkedList<B>();
		LinkedList<Object> c = new LinkedList<Object>();
		printLinkedList(a);
		printLinkedList(b);
		//printLinkedList(c);//出错，无法正确转换并传递参数
		printList(a);
		printList(b);
		printList(c);
		printCollection(a);
		printCollection(b);
		printCollection(c);
	}
	public static void printLinkedList(LinkedList<? extends A> list){/*代码省略*/	}
	public static void printList(List<? super B> list){	/*代码省略*/	}
	public static void printCollection(Collection<?> collection){/*代码省略*/	}
}
class A{}
class B extends A{}

//例6.3Collection与Iterator接口

import java.util.*;
public class CollectionIteratorExample {
	public static void main(String[] args) {
		//创建一个管理String对象的HashSet集合，并将其转型为Collection接口类型
		Collection<String> c1 = new HashSet<String>(); 
		c1.add("张三");//添加元素（字符串元素）
		c1.add("李四");
		System.out.print("c1集合信息：");
		printCollection(c1);
		
		Collection<String> c2 = new HashSet<String>();//转型为Collection接口类型
		c2.add("王五");
		c2.add("赵六");
		System.out.print("c2集合信息：");
		printCollection(c2);
		
		c1.addAll(c2);//将c2的元素都添加到c1中，即集合合并
		System.out.print("c1.addAll(c2)后，c1集合信息：");
		printCollection(c1); 
		if(c1.contains("王五") == true)
			System.out.println("c1包含王五");
		if(c1.containsAll(c2) == true)
			System.out.println("c1包含c2");
		
		c1.removeAll(c2);//将c1集合中出现在c2集合的元素删除
		System.out.print("c1.removeAll(c2)后，c1集合信息：");
		printCollection(c1); 
		
		c1.retainAll(c2);//将c1中没有出现在c2的元素删除
		System.out.print("c1.retainAll(c2)后，c1集合信息：");
		printCollection(c1);
		
		String[]  names = c2.toArray(new String[0]);//转换为对象数组并返回
		System.out.print("c2.toArray(new String[0])获得String数组，相关数组信息：");
		for(int i=0;i<names.length;i++)
			System.out.print(names[i]+" ");
	}
	public static void printCollection(Collection<String> c){
		System.out.print("元素个数:"+c.size()+" 分别是：");
		Iterator<String> iterator = c.iterator();//获得Iterator对象引用
		while(iterator.hasNext())//对集合c的元素进行遍历
			System.out.print(iterator.next()+" ");
		System.out.print("\n");	
	}
}

//例6.4通过Iterator删除元素的使用示例

import java.util.*;
public class IteratorRemoveExample {
	public static void main(String[] args) {
		Collection<String> nameSet = new HashSet<String>();//转型为Collection类型
		nameSet.add("张三");
		nameSet.add("张四");
		nameSet.add("李三");
		nameSet.add("李四");
		nameSet.add("王三");
		nameSet.add("王四");
		System.out.print("删除所有姓李的名字之前，元素个数是:" +
				nameSet.size() + " 分别是：");		
		Iterator<String> iterator = nameSet.iterator();
		while(iterator.hasNext())//遍历集合，显示元素信息
			System.out.print(iterator.next()+" ");		
		iterator = nameSet.iterator();
		while(iterator.hasNext()){//遍历元素，并删除所有姓李的名字
			String e = iterator.next();
			if(e.startsWith("李") == true)
				iterator.remove();
		}
		System.out.print("\n删除所有姓李的名字之后，元素个数是:" + 
				nameSet.size() + " 分别是：");		
		iterator = nameSet.iterator();//遍历集合，显示元素信息
		while(iterator.hasNext())
			System.out.print(iterator.next()+" ");		
	}
}

//例6.5 List接口的使用示例

import java.util.*;
public class ListExample {
	public static void main(String[] args) {
		List<String> list1 = new LinkedList<String>();//集合转型为List接口	
		List<String> list2 = new LinkedList<String>();//集合转型为List接口	
		list1.add("张三");
		list1.add(0,"李四");//将"2李四"添加到list1的第0个位置
		list1.add("王五");
		list1.add("赵六");
		System.out.print("list1的元素：");
		printList(list1);
		
		list2.add("李四");
		list2.add("王五");
		list2.add("赵六");
		System.out.print("list2的元素：");
		printList(list2);
		
		list1.addAll(0,list2);//将list2的元素全部添加到list的第0个开始的位置
		System.out.print("list1.addAll(0,list2)执行后，list1的元素：");
		printList(list1);
		
		list1.remove(0);//删除list1的第0个元素
		System.out.print("list1.remove(0)执行后，list1的元素：");
		printList(list1);
		
		list1.set(0,"赵老六");//将第0个元素替换为"赵老六"
		System.out.print("list1.set(0,\"赵老六\")执行后，list1的元素：");
		printList(list1);
		
		System.out.println("list1的第2个元素是：" + list1.get(2));
		System.out.println("list1中\"赵六\"的位置(从前往后数)：" + 
				list1.indexOf("赵六"));//查找元素"赵六"的位置下标
		System.out.println("list1中\"赵六\"的位置(从后往前数)：" + 
				list1.lastIndexOf("赵六"));
		//下行代码将list1的第1，2，3个元素组成子列表并返回（不包括第4个元素）
		List<String> list3 = list1.subList(1,4);
		System.out.print("list1.subList(1,4)返回的子列表元素：");
		printList(list3);		
	}
	public static void printList(List<String> c){
		ListIterator<String> iterator = c.listIterator();//获得ListIterator对象引用
		while(iterator.hasNext())//对集合c的元素进行遍历
			System.out.print(iterator.next()+" ");
		System.out.print("\n");	
	}
}

//例6.6ListIterator接口的使用示例

import java.util.*;
public class ListIteratorExample {
	public static void main(String[] args) {
		List<String> list = new LinkedList<String>();//将集合转型为List接口类型
		list.add("张三");//逐个添加四个元素
		list.add("李四");
		list.add("王五");
		list.add("赵六");
		System.out.print("正向遍历的顺序是：");
		ListIterator<String> iterator = list.listIterator();//获得ListIterator对象
		while(iterator.hasNext())//正向遍历
			System.out.print("(位置"+iterator.nextIndex()+":"+iterator.next()+")");
		//注意：此时的游标位于迭代器的尾部
		System.out.print("\n逆向遍历的顺序是：");
		while(iterator.hasPrevious())//逆向遍历
			System.out.print("(位置"+iterator.previousIndex()+
					":"+iterator.previous()+")");
		System.out.print("\n先正向、后反向：");
		//下面代码说明改变遍历方向后的特点
		System.out.print("(位置"+iterator.nextIndex()+":"+iterator.next()+")");
		System.out.print("(位置"+iterator.previousIndex()+":"+iterator.previous()+")");
		iterator = list.listIterator();//重新获得ListIterator对象。
		while(iterator.hasNext()){//正向遍历，替换"李小四"，增加"李小五"
			String str = iterator.next();
			if(str.equals("李四")){
				iterator.set("李小四");//替换元素：将"李四"替换为"李小四"
				iterator.add("李小五");//添加元素：在"李小四”后面添加"李小五".
			}
		}
		System.out.print("\n将李四替换为李小四，然后添加李小五，元素分别是：\n");
		iterator = list.listIterator();		
		while(iterator.hasNext())
			System.out.print("(位置"+iterator.nextIndex()+":"+iterator.next()+")");
	}
}

//例6.7LinkedList的使用示例

import java.util.*;
public class LinkedListExample {
	public static void main(String[] args) {
		LinkedList<String> list1 = new LinkedList<String>();
		list1.add("李四");
		list1.addLast("王五");//在集合尾部添加
		list1.addFirst("张三");//在集合头部添加
		System.out.print("list1的元素：");
		printList(list1);
		LinkedList<String> list2 = new LinkedList<String>(list1);//根据list1创建list2
		list2.addFirst("李四");
		list2.add("赵六");
		System.out.print("list2的元素：");
		printList(list2);
		System.out.println("list2的头尾两个元素是："+list2.getFirst()+" "+list2.getLast());
		list2.removeFirst();
		list2.removeLast();
		System.out.print("删除list2的头尾两个元素后，list2的元素是：");
		printList(list2);
	}
	public static void printList(List<String> c){
		ListIterator<String> iterator = c.listIterator();//获得ListIterator对象引用
		while(iterator.hasNext())//对集合c的元素进行遍历
			System.out.print(iterator.next()+" ");
		System.out.print("\n");	
	}
}

//例6.8 ArrayList的使用示例

import java.util.*;
public class ArrayListExample {
	public static void main(String[] args) {
		ArrayList<String> list1 = new ArrayList<String>();//初始容量为默认值
		list1.add("张三");
		list1.add("李四");
		list1.add("王五");
		System.out.print("list1的元素：");
		printList(list1);
		
		ArrayList<String> list2 = new ArrayList<String>(list1);//根据list1创建list2
		System.out.print("list2的元素：");
		printList(list2);
		
		LinkedList<String> list3 = new LinkedList<String>();//创建LinkedList集合
		list3.add("张三");
		list3.add("李四");
		list3.add("王五");
		System.out.print("list3的元素：");
		printList(list3);
		
		int initialCapacity = list1.size() + list2.size();//计算需要的初始容量
		ArrayList<String> list4 = new ArrayList<String>(initialCapacity);//指定初始容量
		list4.addAll(list1);
		list4.addAll(list2);
		list4.ensureCapacity(list4.size()+list3.size());//添加list3之前，提前增加容量
		list4.addAll(list3);//将ArrayList类型集合list3的元素添加到list4
		System.out.print("list4的元素：");
		printList(list4);
	}
	public static void printList(List<String> c){
		ListIterator<String> iterator = c.listIterator();//获得ListIterator对象引用
		while(iterator.hasNext())//对集合c的元素进行遍历
			System.out.print(iterator.next()+" ");
		System.out.print("\n");	
	}
}

//例6.9 HashSet的使用示例：不能添加重复元素

import java.util.*;
public class HashSetExample {
	public static void main(String[] args) {
		Set<String> c = new HashSet<String>(); 
		c.add(new String("王五"));
		c.add(new String("王五"));
		c.add(new String("张三"));
		c.add(new String("张三"));
		c.add(new String("李四"));
		c.add(new String("李四"));
		c.add(new String("赵六"));
		c.add(new String("赵六"));
		c.add(null);
		c.add(null);
		System.out.print("元素个数:"+c.size()+" 分别是：");
		Iterator<String> iterator = c.iterator();//获得Iterator对象引用
		while(iterator.hasNext())//对集合c的元素进行遍历
			System.out.print(iterator.next()+" ");
		System.out.print("\n");	
	}
}

//例6.10 Set集合的使用示例：不定义Student类的equals和hashCode方法

import java.util.*;
class Student {
	private String id,name,gender;
	private int age;			
	public Student(String id,String name,int age,String gender){
		this.id = id; this.name = name; 
		this.age = age; this.gender = gender;
	}
	public String toString(){
		return "id = "+id + " name = "+name+" age = "+age+" gender = "+gender;
	}
}
public class Test2{
	public static void main(String[] args){
		//创建了3个Student对象
		Student student1 = new Student("001","张三",18,"男");//创建新Student对象
		Student student2 = new Student("001","张三",18,"男");//创建新Student对象
		Student student3 = new Student("001","李四",19,"男");//创建新Student对象
		HashSet<Student> set = new HashSet<Student>();
		set.add(student1);
		set.add(student2);
		set.add(student3);
		System.out.println("共有" + set.size()+"个元素");
		Iterator<Student> iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next().toString());
		}
	}
}

//例6.11 Set集合的使用示例：定义Student类的equals和hashCode方法

import java.util.*;
class Student {
	private String id,name,gender;
	private int age;			
	public Student(String id,String name,int age,String gender){
		this.id = id; this.name = name; 
		this.age = age; this.gender = gender;
	}
	public boolean equals(Object obj){
		if( obj instanceof Student){//保证obj是Student或其子类的对象
			Student a = (Student)obj; //可以顺利向下转型为Student类型
			return name.equals(a.name) && this.id.equals(a.id) && 
			this.gender.equals(a.gender) && this.age == a.age;
		}
		return false;
	}
	public int hashCode(){
		//将各个成员变量的哈希码值进行异或得到Student对象的哈希码值
		return id.hashCode()^ name.hashCode() ^ 
		gender.hashCode() ^ (new Integer(age).hashCode());
	}
	public String toString(){
		return "id = "+id + " name = "+name+" age = "+age+" gender = "+gender;
	}
}
public class Test3{
	public static void main(String[] args){
		Student student1 = new Student("001","张三",18,"男");
		Student student2 = new Student("001","张三",18,"男");
		Student student3 = new Student("001","李四",19,"男");
		HashSet<Student> set = new HashSet<Student>();
		set.add(student1);
		set.add(student2);
		set.add(student3);
		System.out.println("共有" + set.size()+"个元素");
		Iterator<Student> iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next().toString());
		}
	}
}

//例6.12 TreeSet的使用示例：排序集合创建与操作

import java.util.*;
public class TreeSetExample {
	public static void main(String[] args) {
		TreeSet<String> c = new TreeSet<String>(); 
		c.add("John");
		c.add("Bob");
		c.add("Alice");
		c.add("Clinton");
		c.add("White");
		c.add("Jack");
		System.out.print("TreeSet集合信息：");
		printSet(c);
		System.out.println("最小的元素："+c.first()+"最大的元素："+c.last());
		System.out.print("c.headSet(\"Clinton\")子集信息：");
		printSet(c.headSet("Clinton"));
		System.out.print("c.tailSet(\"Clinton\")子集信息：");
		printSet(c.tailSet("Clinton"));
		System.out.print("c.subSet(\"Bob,\"\"John\")子集信息：");
		printSet(c.subSet("Bob","John"));
	}
	public static void printSet(Set<String> c){
		System.out.print("元素个数:"+c.size()+",分别是：");
		Iterator<String> iterator = c.iterator();//获得Iterator对象引用
		while(iterator.hasNext())//对集合c的元素进行遍历
			System.out.print(iterator.next()+" ");
		System.out.print("\n");	
	}	
}

//例6.13 TreeSet的使用示例：Comparable接口与自然排序

import java.util.*;
class Student implements Comparable<Student> {
	private String id,name,gender;
	private int age;			
	public Student(String id,String name,int age,String gender){
		this.id = id; this.name = name; 
		this.age = age; this.gender = gender;
	}
	public String toString(){
		return "id = "+id + " name = "+name+" age = "+age+" gender = "+gender;
	}
	public int compareTo(Student o) {//实现Comparable接口的抽象方法compareTo
		return this.id.compareTo(o.id);  //比较当前对象与参数对象o的id大小
	}
}
public class Test4{
	public static void main(String[] args){
		Student student1 = new Student("003","张三",18,"男");
		Student student2 = new Student("004","张四",20,"女");
		Student student3 = new Student("002","张二",19,"男");
		Student student4 = new Student("002","赵二",17,"女");//没有插入到集合中
		Student student5 = new Student("001","张一",18,"男");
		Student student6 = new Student("005","张五",20,"男");
		Set<Student> set = new TreeSet<Student>();
		set.add(student1);
		set.add(student2);
		set.add(student3);
		set.add(student4);
		set.add(student5);
		set.add(student6);
		System.out.println("按照age排序后的" + set.size()+"个元素");
		Iterator<Student> iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next().toString());
		}
	}
}

//例6.14 TreeSet的使用示例：Comparator接口与比较器

import java.util.*;
class Student{
	private String id,name,gender;
	private int age;			
	public Student(String id,String name,int age,String gender){
		this.id = id; this.name = name; 
		this.age = age; this.gender = gender;
	}
	public String toString(){
		return "id = "+id + " name = "+name+" age = "+age+" gender = "+gender;
	}
	public String getId(){ return id; }
}
class StudentComparator implements Comparator<Student>{//定义比较器类
	public int compare(Student o1, Student o2) {
		return o1.getId().compareTo(o2.getId());
	}
}
public class Test5{
	public static void main(String[] args){
		Student student1 = new Student("003","张三",18,"男");
		Student student2 = new Student("004","张四",20,"女");
		Student student3 = new Student("002","张二",19,"男");
		Student student4 = new Student("002","赵二",17,"女");//没有插入到集合中
		Student student5 = new Student("001","张一",18,"男");
		Student student6 = new Student("005","张五",20,"男");
		//以下代码传递一个Comparator<Student>接口类型对象给TreeSet构造器
		Set<Student> set = new TreeSet<Student>(new StudentComparator());
		set.add(student1);
		set.add(student2);
		set.add(student3);
		set.add(student4);
		set.add(student5);
		set.add(student6);
		System.out.println("按照age排序后的" + set.size()+"个元素");
		Iterator<Student> iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next().toString());
		}
	}
}

//例6.15 Queue的使用示例

import java.util.*;
public class QueueExample {
	public static void main(String[] args) {
		Queue<String> queue = new LinkedList<String>();//对象转型为Queue接口	
		queue.add("Alice");
		queue.offer("Bob");
		queue.offer("Clinton");
		queue.offer("Jack");
		System.out.print("queue的长度是"+queue.size()+" 它的元素有：");
		printQueue(queue);
		System.out.println("通过queue.peek()获得头元素："+queue.peek());
		System.out.print("queue.peek()调用之后，队列的元素有：");
		printQueue(queue);
		System.out.println("通过queue.poll()获得头元素："+queue.poll());
		System.out.print("queue.poll()调用之后，队列的元素有：");
		printQueue(queue);
	}
	public static void printQueue(Queue<String> c){
		Iterator<String> iterator = c.iterator();//获得Iterator对象引用
		while(iterator.hasNext())//对集合c的元素进行遍历
			System.out.print(iterator.next()+" ");
		System.out.print("\n");	
	}
}

//例6.16 Map的使用示例

import java.util.*;
class Student{
	private String id,name,gender;
	private int age;			
	public Student(String id,String name,int age,String gender){
		this.id = id; this.name = name; 
		this.age = age; this.gender = gender;
	}
	public String toString(){
		return "id = "+id + " name = "+name+" age = "+age+" gender = "+gender;
	}
	public String getId(){ return id; }
}
class MapExample{
	public static void main(String[] args){
		Student student1 = new Student("001","张一",18,"男");
		Student student2 = new Student("002","张二",20,"女");
		Student student3 = new Student("003","张三",19,"男");
		Student student4 = new Student("004","张四",17,"女");
		Map<String,Student> map = new HashMap<String,Student>();//创建Map对象
		//以下四行代码添加四个key-value对，key是学号（id），value是学生对象
		map.put(student1.getId(),student1); 
		map.put(student2.getId(),student2);
		map.put(student3.getId(),student3);
		map.put(student4.getId(),student4);
		if(map.containsKey("003")==true){//查找是否有key为003的key-value对
			System.out.println("map中包含key为003的学生对象");
			System.out.println("map中学号003的对象信息是："+
					map.get("003"));//根据key获得value（根据学号得到学生对象）
		}
		//下一行代码功能：查找是否有value为student4的key-value对
		if(map.containsValue(student4) == true) 
			System.out.println("map中包含value为（"+student4+"）的学生对象");
		
		map.remove("003");//删除学号为003的key-value对
		System.out.println("删除学号为003的学生对象后");
		Set<String> keys = map.keySet(); //获得key的集合
		System.out.print("map的key共有" + keys.size() + "个，它们是：");
		Iterator<String> iterator1 = keys.iterator();
		while(iterator1.hasNext())
			System.out.print(iterator1.next()+"  ");
		Collection<Student> values = map.values();//获得value的集合
		System.out.println("\nmap的value共有" + values.size() + "个，它们是：");
		Iterator<Student> iterator2 = values.iterator();
		while(iterator2.hasNext())
			System.out.println(iterator2.next()+"  ");	
	}
}

//例6.17 SortedMap的使用示例

import java.util.*;
class Student{
	private String id,name,gender;
	private int age;			
	public Student(String id,String name,int age,String gender){
		this.id = id; this.name = name; 
		this.age = age; this.gender = gender;
	}
	public String toString(){
		return "id = "+id + " name = "+name+" age = "+age+" gender = "+gender;
	}
	public String getId(){ return id; }
}
class SortedMapExample{
	public static void main(String[] args){
		Student student1 = new Student("004","张四",17,"女");
		Student student2 = new Student("001","张一",18,"男");
		Student student3 = new Student("003","张三",19,"男");
		Student student4 = new Student("005","张五",19,"男");
		Student student5 = new Student("002","张二",20,"女");
		SortedMap<String,Student> map = new TreeMap<String,Student>();
		map.put(student1.getId(),student1);
		map.put(student2.getId(),student2);
		map.put(student3.getId(),student3);
		map.put(student4.getId(),student4);
		map.put(student5.getId(),student5);
		System.out.println("map的第一个键是：" + map.firstKey());
		System.out.println("map的最后一个键是：" + map.lastKey());
		Set<String> keys = map.keySet();
		System.out.print("map的key共有" + keys.size() + "个，它们是：");
		Iterator<String> iterator1 = keys.iterator();
		while(iterator1.hasNext())
			System.out.print(iterator1.next()+"  ");
		Collection<Student> values = map.values();
		System.out.println("\nmap的value共有" + values.size() + "个，它们是：");
		Iterator<Student> iterator2 = values.iterator();
		while(iterator2.hasNext())
			System.out.println(iterator2.next()+"  ");	
		//获取子映射
		map = map.subMap("002","004");//获取键为002、003的子映射
		values = map.values();
		System.out.println("子映射的value共有" + values.size() + "个，它们是：");
		iterator2 = values.iterator();
		while(iterator2.hasNext())
			System.out.println(iterator2.next()+"  ");	
	}
}

//例6.18 集合的使用示例

import java.util.*;
interface Speakable{
	public abstract void speak();
}
class Dog implements Speakable{
	public void speak(){System.out.println("我是小狗，汪汪叫");}	
}
class ShepherdDog extends Dog{
	public void eat(){System.out.print("大口吃肉，流口水......");}		
	public void speak(){eat();System.out.println("我是牧羊犬，有肉吃才叫");}	
}
class Cat implements Speakable{
	public void speak(){System.out.println("我是小猫，喵喵叫");}	
}
class Sheep implements Speakable{
	public void speak(){System.out.println("我是绵羊，咩咩叫");}	
}
class AnimalTool{
	public static void animalSpeak(Speakable[] animals){
		for(int i=0; i<animals.length;i++)
			animals[i].speak();
	}
	public static void animalSpeak(LinkedList<Speakable> animals){
		Iterator<Speakable> iterator = animals.iterator();
		while(iterator.hasNext()){
			Speakable animal = iterator.next();
			animal.speak();
		}
	}
}
public class Test7 {
	public static void main(String[] args) {
		Speakable[] animals = new Speakable[4];
		animals[0] = new Dog();		//将Dog类型引用转型为Speakable类型
		animals[1] = new Cat();		//将Cat类型引用转型为Speakable类型
		animals[2] = new Sheep();	//将Sheep类型引用转型为Speakable类型
		animals[3] = new ShepherdDog();	//将ShepherdDog型引用转型为Speakable型
		AnimalTool.animalSpeak(animals);	
		
		LinkedList<Speakable> animals2 = new LinkedList<Speakable>();
		animals2.add(new Dog());
		animals2.add(new Cat());
		animals2.add(new Sheep());
		animals2.add(new ShepherdDog());
		AnimalTool.animalSpeak(animals2);	
	}
}