集合框架和泛型

了解Java集合框架体系结构
会使用ArrayList存取数据
会使用LinkedList存取数据
了解ArrayList与LinkedList区别

使用集合框架的好处
容量自增长；
提供了高性能的数据结构和算法，使编码更轻松，提高了程序速度和质量；
允许不同 API 之间的互操作，API之间可以来回传递集合；
可以方便地扩展或改写集合，提高代码复用性和可操作性。
通过使用JDK自带的集合类，可以降低代码维护和学习新API成本。

常用的集合类有哪些？
Map接口和Collection接口是所有集合框架的父接口：

Collection接口的子接口包括：Set接口和List接口
Map接口的实现类主要有：HashMap、TreeMap、Hashtable、ConcurrentHashMap以及Properties等
Set接口的实现类主要有：HashSet、TreeSet、LinkedHashSet等
List接口的实现类主要有：ArrayList、LinkedList、Stack以及Vector等

**List，Set，Map三者的区别？List、Set、Map 是否继承自 Collection 接口？List、Map、Set 三个接口存取元素时，各有什么特点？
**

Java 容器分为 Collection 和 Map 两大类，Collection集合的子接口有Set、List、Queue三种子接口。我们比较常用的是Set、List，Map接口不是collection的子接口。

Collection集合主要有List和Set两大接口

List：一个有序（元素存入集合的顺序和取出的顺序一致）容器，元素可以重复，可以插入多个null元素，元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。

ArrayList实现了长度可变的数组，在内存中分配连续的空间，遍历元素和随机访问元素的效率比较高
LinkedList采用链表存储方式，插入、删除元素时效率比较高

Set：一个无序（存入和取出顺序有可能不一致）容器，不可以存储重复元素，只允许存入一个null元素，必须保证元素唯一性。Set 接口常用实现类是 HashSet、LinkedHashSet 以及 TreeSet。

Map是一个键值对集合，存储键、值和之间的映射。 Key无序，唯一；value 不要求有序，允许重复。Map没有继承于Collection接口，从Map集合中检索元素时，只要给出键对象，就会返回对应的值对象。

Map 的常用实现类：HashMap、TreeMap、HashTable、LinkedHashMap、ConcurrentHashMap

//使用ArrayList获取并打印新闻标题
package entity;

public class NewTitle {
	private int id;            //ID
	private String titleName;  //名称
	private String creater;    //创建者
	public NewTitle() {
	}
	public NewTitle(int id, String titleName, String creater) {
		this.id = id;
		this.titleName = titleName;
		this.creater = creater;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTitleName() {
		return titleName;
	}
	public void setTitleName(String titleName) {
		this.titleName = titleName;
	}
	public String getCreater() {
		return creater;
	}
	public void setCreater(String creater) {
		this.creater = creater;
	}
	
}

package test;

import java.util.ArrayList;
import java.util.List;

import entity.NewTitle;

public class NewTitleDemo {

	public static void main(String[] args) {
		// 具体实现步骤
		// 1、创建多个各类新闻标题对象
		NewTitle car = new NewTitle(1, "汽车", "管理员");
		NewTitle test = new NewTitle(2, "高考", "管理员");
		// 2、创建存储各类新闻标题的集合对象
		List newsTitleList = new ArrayList();
		// 3、按照顺序依次添加各类新闻标题
		newsTitleList.add(car);
		newsTitleList.add(test);
		// 4、获取新闻标题的总数
		System.out.println("新闻标题数目为：" + newsTitleList.size() + "条");
		// 5、根据位置获取相应新闻标题、逐条打印每条新闻标题的名称，也就是我们常说的遍历集合对象
		for (int i = 0; i < newsTitleList.size(); i++) {
			NewTitle title = (NewTitle) newsTitleList.get(i);
			System.out.println(i + 1 + ":" + title.getTitleName());
		}

	}

}

//使用LinkedList
package entity;

public class NewTitle {
	private int id;            //ID
	private String titleName;  //名称
	private String creater;    //创建者
	public NewTitle() {
	}
	public NewTitle(int id, String titleName, String creater) {
		this.id = id;
		this.titleName = titleName;
		this.creater = creater;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTitleName() {
		return titleName;
	}
	public void setTitleName(String titleName) {
		this.titleName = titleName;
	}
	public String getCreater() {
		return creater;
	}
	public void setCreater(String creater) {
		this.creater = creater;
	}
	
}

package test;
import java.util.LinkedList;
import entity.NewTitle;

public class NewTitleDemo {

	public static void main(String[] args) {
		// 具体实现步骤
		// 1、创建多个各类新闻标题对象
		NewTitle car = new NewTitle(1, "汽车", "管理员");
		NewTitle medical = new NewTitle(2, "医学", "管理员");		
		// 2、创建存储各类新闻标题的集合对象
		LinkedList newsTitleList = new LinkedList();		
		// 3、添加头条新闻标题和末尾标题
		newsTitleList.addFirst(car);
		newsTitleList.addLast(medical);
		// 4、获取头条、以及最末条新闻标题
		NewTitle first = (NewTitle) newsTitleList.getFirst();
		System.out.println("头条的新闻标题为:" + first.getTitleName());
		NewTitle last = (NewTitle) newsTitleList.getLast();
		System.out.println("排在最后的新闻标题为:" + last.getTitleName());
		// 5、删除头条和最末条新闻标题
		NewTitle firstNews=(NewTitle)newsTitleList.removeFirst();
		System.out.println("删除的头条新闻标题为:"+firstNews.getTitleName());
		NewTitle lastNews=(NewTitle)newsTitleList.removeLast();
		System.out.println("删除的末条新闻标题为:"+lastNews.getTitleName());
		System.out.println("删除后剩余的新闻条数："+newsTitleList.size());
	}
}

Set接口存储一组唯一，无序的对象
HashSet是Set接口常用的实现类
Set中存放对象的引用

import java.util.HashSet;
import java.util.Set;


public class SetTest {
	public static void main(String[] args) {
		Set set=new HashSet();
		String s1=new String("java");
		String s2=s1;
//		String s3=new String("java");
		String s3=new String("JAVA");
		set.add(s1);
		set.add(s2);
		set.add(s3);
		System.out.println(set.size());
	}
}

//使用Iterator和增强型for循环遍历Set
package entity;

public class NewTitle {
	private int id;            //ID
	private String titleName;  //名称
	private String creater;    //创建者
	public NewTitle() {
	}
	public NewTitle(int id, String titleName, String creater) {
		this.id = id;
		this.titleName = titleName;
		this.creater = creater;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getTitleName() {
		return titleName;
	}
	public void setTitleName(String titleName) {
		this.titleName = titleName;
	}
	public String getCreater() {
		return creater;
	}
	public void setCreater(String creater) {
		this.creater = creater;
	}
	
}


package test;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import entity.NewTitle;

public class NewTitleDemo {

	public static void main(String[] args) {
		// 1、创建多个各类新闻标题对象
		NewTitle car = new NewTitle(1, "汽车", "管理员");
		NewTitle test = new NewTitle(2, "高考", "管理员");
		// 2、创建存储各类新闻标题的集合对象
		Set newsTitleList = new HashSet();
		// 3、按照顺序依次添加各类新闻标题
		newsTitleList.add(car);
		newsTitleList.add(test);
		// 4、获取新闻标题的总数
		System.out.println("新闻标题数目为：" + newsTitleList.size() + "条");
		// 5、使用iterator()获取Iterator对象
		Iterator iterator = newsTitleList.iterator();
		// 6、使用Iterator遍历集合
		while(iterator.hasNext()){
			NewTitle title = (NewTitle) iterator.next();
			System.out.println(title.getTitleName());
		}
		System.out.println("************************");
		// 7、使用增强型for遍历集合
		for(Object obj:newsTitleList){
			NewTitle title = (NewTitle)obj;
			System.out.println(title.getTitleName());
		}
	}

}

总结

List总结：
可以重复，通过索引取出加入数据，顺序与插入顺序一致，可以含有null元素

ArrayList:底层数据结构使数组结构array，查询速度快，增删改慢，因为是一种类似数组的形式进行存储，因此它的随机访问速度极快；
Vector：底层是数组结构array，与ArrayList相同，查询速度快，增删改慢；
LinkedList:底层使用链表结构，增删速度快，查询稍慢；

ArrayList与Vector的区别：

1.如果集合中的元素数量大于当前集合数组的长度时，Vector的增长率是目前数组长度的100%，而ArryaList增长率为目前数组长度的50%。所以，如果集合中使用数据量比较大的数据，用Vector有一定优势
2.线程同步ArrayList是线程不同步，所以Vector线程安全，但是因为每个方法都加上了synchronized，所以在效率上小于ArrayList

Set总结：

数据无序且唯一,实现类都不是线程安全的类，解决方案：Set set = Collections.sysnchronizedSet(Set对象);

HashSet：是Set接口（Set接口是继承了Collection接口的）最常用的实现类，顾名思义，底层是用了哈希表（散列/hash）算法。其底层其实也是一个数组，存在的意义是提供查询速度，插入的速度也是比较快，但是适用于少量数据的插入操作，判断两个对象是否相等的规则：1、equals比较为true；2、hashCode值相同。要求：要求存在在哈希表中的对象元素都得覆盖equals和hashCode方法。

LinkedHashSet：继承了HashSet类，所以它的底层用的也是哈希表的数据结构，但因为保持数据的先后添加顺序，所以又加了链表结构，但因为多加了一种数据结构，所以效率较低，不建议使用，如果要求一个集合急要保证元素不重复，也需要记录元素的先后添加顺序，才选择使用LinkedHashSet

TreeSet：Set接口的实现类，也拥有set接口的一般特性，但是不同的是他也实现了SortSet接口，它底层采用的是红黑树算法（红黑树就是满足一下红黑性质的二叉搜索树：①每个节点是黑色或者红色②根节点是黑色的③每个叶子结点是黑色的④如果一个节点是红色的，那么他的两个子节点是黑色的⑤对每个节点，从该节点到其所有的后代叶子结点的简单路径上，仅包含相同数目的黑色结点，红黑树是许多“平衡”搜索树的一种，可以保证在最坏情况下的基本操作集合的时间复杂度为O(lgn)。普及：二叉搜索树的性质：它或者是一棵空树；或者是具有下列性质的二叉树：若左子树不空，则左子树上所有结点的值均小于它的根结点的值；若右子树不空，则右子树上所有结点的值均大于它的根结点的值；左、右子树也分别为二叉排序树。若子树为空，查找不成功。），要注意的是在TreeSet集合中只能存储相同类型对象的引用。

Tree最重要的就是它的两种排序方式：自然排序和客户端排序

自然排序；实现了Comparable接口，所以TreeSet可以调用对象的ComparableTo()方法来比较集合的大小，然后进行升序排序，这种排序方式叫做自然排序。其中实现了Comparable接口的还有BigDecimal、BigInteger、Byte、Double、Float、Integer、Long、Short（按照数字大小排序）、Character（按照Unicode值的数字大小进行排序）String（按照字符串中字符的Unicode值进行排序）类等。
客户化排序：其实就是实现java.util.Comparator接口提供的具体的排序方式， 是具体要比较对象的类型，他有个compare的方法，如compare(x,y)返回值大于0表示x大于y，以此类推，当我们希望按照自己的想法排序的时候可以重写compare方法。

Map

map的 常用方法

package cn.jbit.map;

import java.util.HashMap;
import java.util.Map;

/**
 * 测试HashMap的多个方法。
 * @author 
 */
public class TestMap {
    public static void main(String[] args) {
        // 1、使用HashMap存储多组国家英文简称和中文全称的键值对
        Map countries = new HashMap();
	    countries.put("CN", "中华人民共和国");
	    countries.put("RU", "俄罗斯联邦");
	    countries.put("FR", "法兰西共和国");
	    countries.put("US", "美利坚合众国");
        // 2、显示"CN"对应国家的中文全称
        String country = (String) countries.get("CN");
        System.out.println("CN对应的国家是:" + country);
        // 3、显示集合中元素个数
        System.out.println("Map中共有"+countries.size()+"组数据");
        /*4、两次判断Map中是否存在"FR"键*/
        System.out.println("Map中包含FR的key吗?" + 
        countries.containsKey("FR"));
        countries.remove("FR");
        System.out.println("Map中包含FR的key吗?" + 
        countries.containsKey("FR"));
        /* 5、分别显示键集、值集和键值对集*/
        System.out.println(countries.keySet());
        System.out.println(countries.values());
        System.out.println(countries);
        /* 3、清空 HashMap并判断*/
        countries.clear();
        if(countries.isEmpty())
        	System.out.println("已清空Map中数据！");
    }
}

package entity;

public class Student {
	private String name; // 学员姓名
	private String sex; // 学员性别

	public Student() {
	}

	public Student(String name, String sex) {
		this.name = name;
		this.sex = sex;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

}

package test;

import java.util.HashMap;
import java.util.Map;

import entity.Student;

public class HashMapDemo {

	public static void main(String[] args) {
		// 1、创建学员对象
		Student student1 = new Student("李明", "男");
		Student student2 = new Student("刘丽", "女");
		// 2、创建保存“键-值对”的集合对象
		Map students = new HashMap();
		// 3、把英文名称与学员对象按照“键-值对”的方式存储在HashMap中
		students.put("Jack", student1);
		students.put("Rose", student2);
		// 4、打印键集
		/*System.out.println("键集："+students.keySet());
		// 5、打印值集
		System.out.println("值集："+students.values());
		// 6、打印键-值对集合
		System.out.println("键-值对集合:"+students);*/

		String key = "Jack";
		// 7、判断是否存在”Jack”这个键
		if(students.containsKey(key)){
		    // 8、如果存在，根据键获取相应的值
			Student  student = (Student)students.get(key);
			System.out.println(key+"对应的学员姓名是："+student.getName()+"；性别是："+student.getSex());
		}


	}

}

泛型
将对象的类型作为参数，指定到其他类或者方法上，从而保证类型转换的安全性和稳定性

/**
 * 狗狗类，宠物的子类。
 * @author 
 */
public class Dog extends Pet {
	private String strain;// 品种
	/**
	 * 有参构造方法。
	 * @param name   昵称
	 * @param strain   品种
	 */
	public Dog(String name, String strain) {
		super(name); 
		this.strain = strain;
	}
	public String getStrain() {
		return strain;
	}
	/**
	 * 重写父类的print方法。
	 */
	public void print(){
		super.print(); //调用父类的print方法
		System.out.println("我是一只 " + this.strain + "。");
	}
	/**
	 * 实现吃饭方法。 
	 */
	public void eat() {
		super.health = super.health + 3;
		System.out.println("狗狗"+super.name + "吃饱啦！健康值增加3。");
	}
}



/**
* 宠物类，狗狗和企鹅的父类。
* @author 
*/
public abstract class Pet {
	protected String name = "无名氏";// 昵称
	protected int health = 100;// 健康值
	protected int love = 0;// 亲密度
	
	public abstract void eat();  //抽象方法eat(),负责宠物吃饭功能。
	
	/**
	 * 无参构造方法。
	 */
	public Pet() {	
	}
	/**
	 * 有参构造方法。
	 * @param name  昵称
	 */
	public Pet(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public int getHealth() {
		return health;
	}
	public int getLove() {
		return love;
	}
	/**
	 * 输出宠物信息。
	 */
	public void print() {
		System.out.println("宠物的自白：\n我的名字叫" + this.name + 
				"，健康值是"	+ this.health + "，和主人的亲密度是"
				+ this.love + "。");
	}
}



import java.util.ArrayList;
import java.util.List;

import cn.jbit.epet.poly.Dog;

/**
 * 测试对List应用泛型。
 * @author 
 */
public class TestList {
    public static void main(String[] args) {
        /* 1、创建多个狗狗对象*/
        Dog ououDog = new Dog("欧欧", "雪娜瑞");
		Dog yayaDog = new Dog("亚亚", "拉布拉多");
		Dog meimeiDog = new Dog("美美", "雪娜瑞");
		Dog feifeiDog = new Dog("菲菲", "拉布拉多");
        /* 2、创建ArrayList集合对象并把多个狗狗对象放入其中*/
        List<Dog> dogs = new ArrayList<Dog>();//标记元素类型
        dogs.add(ououDog);
	    dogs.add(yayaDog);
	    dogs.add(meimeiDog);
	    dogs.add(2, feifeiDog); // 添加feifeiDog到指定位置
	    //dogs.add("hello"); //出现编译错误,元素类型不是Dog。
        /* 3、 显示第三个元素的信息*/
        Dog dog3 = dogs.get(2); //无需类型强制转换
        System.out.println("第三个狗狗的信息如下:");
        System.out.println(dog3.getName() + "\t" + dog3.getStrain());
        /*4、使用foreach语句遍历dogs对象*/
		System.out.println("\n所有狗狗的信息如下：");
		for(Dog dog:dogs){//无需类型强制转换
			System.out.println(dog.getName() + "\t" + dog.getStrain());
		}   
    }
}



import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import cn.jbit.epet.poly.Dog;

/**
 * 测试对Map应用泛型。
 * @author 
 *
 */
public class TestMap {
	public static void main(String[] args) {
		/* 1、创建多个狗狗对象*/
		Dog ououDog = new Dog("欧欧", "雪娜瑞");
		Dog yayaDog = new Dog("亚亚", "拉布拉多");
		Dog meimeiDog = new Dog("美美", "雪娜瑞");
		Dog feifeiDog = new Dog("菲菲", "拉布拉多");
		/* 2、创建Map集合对象并把多个狗狗对象放入其中*/
		Map<String,Dog> dogMap=new HashMap<String,Dog>();
		dogMap.put(ououDog.getName(),ououDog);
		dogMap.put(yayaDog.getName(),yayaDog);
		dogMap.put(meimeiDog.getName(),meimeiDog);
		dogMap.put(feifeiDog.getName(),feifeiDog);
		/*3、通过迭代器依次输出集合中所有狗狗的信息*/
		System.out.println("使用Iterator遍历，所有狗狗的昵称和品种分别是：");
		Set<String> keys=dogMap.keySet();//取出所有key的集合
		Iterator<String> it=keys.iterator();//获取Iterator对象
		while(it.hasNext()){
			String key=it.next();  //取出key
			Dog dog=dogMap.get(key);  //根据key取出对应的值
			System.out.println(key+"\t"+dog.getStrain());
		}
		/*//使用foreach语句输出集合中所有狗狗的信息
		 for(String key:keys){
			Dog dog=dogMap.get(key);  //根据key取出对应的值
			System.out.println(key+"\t"+dog.getStrain());	
		}*/		
	}
}

//测试通过Iterator和增强型for循环遍历Map集合
package cn.jbit.epet.poly;

/**
 * 狗狗类，宠物的子类。
 * @author 
 */
public class Dog extends Pet {
	private String strain;// 品种
	/**
	 * 有参构造方法。
	 * @param name   昵称
	 * @param strain   品种
	 */
	public Dog(String name, String strain) {
		super(name); 
		this.strain = strain;
	}
	public String getStrain() {
		return strain;
	}
	/**
	 * 重写父类的print方法。
	 */
	public void print(){
		super.print(); //调用父类的print方法
		System.out.println("我是一只 " + this.strain + "。");
	}
	/**
	 * 实现吃饭方法。 
	 */
	public void eat() {
		super.health = super.health + 3;
		System.out.println("狗狗"+super.name + "吃饱啦！健康值增加3。");
	}
}

package cn.jbit.epet.poly;

/**
* 宠物类，狗狗和企鹅的父类。
* @author 
*/
public abstract class Pet {
	protected String name = "无名氏";// 昵称
	protected int health = 100;// 健康值
	protected int love = 0;// 亲密度
	
	public abstract void eat();  //抽象方法eat(),负责宠物吃饭功能。
	
	/**
	 * 无参构造方法。
	 */
	public Pet() {	
	}
	/**
	 * 有参构造方法。
	 * @param name  昵称
	 */
	public Pet(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public int getHealth() {
		return health;
	}
	public int getLove() {
		return love;
	}
	/**
	 * 输出宠物信息。
	 */
	public void print() {
		System.out.println("宠物的自白：\n我的名字叫" + this.name + 
				"，健康值是"	+ this.health + "，和主人的亲密度是"
				+ this.love + "。");
	}
}

package cn.jbit.iterator;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import cn.jbit.epet.poly.Dog;

/**
 * 测试通过Iterator和增强型for循环遍历Map集合
 * @author 
 */
public class Test5 {
	public static void main(String[] args) {

		/* 1、创建多个狗狗对象*/
		Dog ououDog = new Dog("欧欧", "雪娜瑞");
		Dog yayaDog = new Dog("亚亚", "拉布拉多");
		Dog meimeiDog = new Dog("美美", "雪娜瑞");
		Dog feifeiDog = new Dog("菲菲", "拉布拉多");
		/* 2、创建Map集合对象并把多个狗狗对象放入其中*/
		Map dogMap=new HashMap();
		dogMap.put(ououDog.getName(),ououDog);
		dogMap.put(yayaDog.getName(),yayaDog);
		dogMap.put(meimeiDog.getName(),meimeiDog);
		dogMap.put(feifeiDog.getName(),feifeiDog);
		/*3、通过迭代器依次输出集合中所有狗狗的信息*/
		System.out.println("使用Iterator遍历，所有狗狗的昵称和品种分别是：");
		Set keys=dogMap.keySet();//取出所有key的集合
		Iterator it=keys.iterator();//获取Iterator对象
		while(it.hasNext()){
			String key=(String)it.next();  //取出key
			Dog dog=(Dog)dogMap.get(key);  //根据key取出对应的值
			System.out.println(key+"\t"+dog.getStrain());
		}
		/*//使用foreach语句输出集合中所有狗狗的信息
		 for(Object key:keys){
			Dog dog=(Dog)dogMap.get(key);  //根据key取出对应的值
			System.out.println(key+"\t"+dog.getStrain());	
		}
		*/	
	}
}

package entity;

public class Student {
	private String name; // 学员姓名
	private String sex; // 学员性别

	public Student() {
	}

	public Student(String name, String sex) {
		this.name = name;
		this.sex = sex;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

}

package test;

import java.util.HashMap;
import java.util.Map;

import entity.Student;

public class HashMapDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// 1、创建学员对象
		Student student1 = new Student("李明", "男");
		Student student2 = new Student("刘丽", "女");
		// 2、创建保存“键-值对”的集合对象
		Map<String,Student> students = new HashMap<String,Student>();
		// 3、把英文名称与学员对象按照“键-值对”的方式存储在HashMap中
		students.put("Jack", student1);
		students.put("Rose", student2);
		// 4、打印键集
		System.out.println("键集："+students.keySet());
		// 5、打印值集
		System.out.println("值集："+students.values());
		// 6、打印键-值对集合
		System.out.println("键-值对集合:"+students);

		String key = "Jack";
		// 7、判断是否存在”Jack”这个键
		if(students.containsKey(key)){
		    // 8、如果存在，根据键获取相应的值
			Student  student = students.get(key);
			System.out.println("学员姓名："+student.getName());
		}


	}

}

**Collections算法类
**
Java集合框架将针对不同数据结构算法的实现都保存在工具类中
Collections类定义了一系列用于操作集合的静态方法

Collections和Collection不同，前者是集合的操作类，后者是集合接口
Collections提供的常用静态方法
sort():排序
binarySearch()：查找
max()\min():查找最大\最小值

//常用方法
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsDemo {
	public static void main(String[] args) {
		//创建集合
		List<String> list = new ArrayList<String>();
		//增加10个不同单词
		list.add("this");
		list.add("is");
		list.add("collection");
		list.add("test");
		list.add("and");
		list.add("we");
		list.add("can");
		list.add("learn");
		list.add("how");
		list.add("to");
		
		//打印输出集合中最大元素和最小元素   
		String strMax = (String) Collections.max(list);
		String strMin = (String) Collections.min(list);
		System.out.println("最大值："+strMax);
		System.out.println("最小值："+strMin);
		//按升序打印输出集合中所有元素   
		Collections.sort(list);
		System.out.println("集合升序");
		for(int i=0;i<list.size();i++)
		{
			System.out.println(list.get(i));
		}
		System.out.println(Collections.binarySearch(list, "this"));
		//按降序打印输出集合中所有元素
		Collections.reverse(list);
		System.out.println("集合降序");
		for(int i=0;i<list.size();i++)
		{
			System.out.println(list.get(i));
		}

	}

}

package entity;
public class Student implements Comparable{
private int number=0; 			//学号
	private String name=""; 		//学生姓名
	private String gender="";	 	//性别
	public int getNumber(){
		return number;
	}
	public void setNumber(int number){
		this.number=number;
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
	public String getGender(){
		return gender;
	}
	public void setGender(String gender){
		this.gender=gender;
	}
	public int compareTo(Object obj){
		Student student=(Student)obj;
		if(this.number==student.number){  
			return 0;			//如果学号相同，那么两者就是相等的
		}else if(this.number>student.getNumber()){ 
			return 1;			//如果这个学生的学号大于传入学生的学号
		}else{ 
			return -1;			//如果这个学生的学号小于传入学生的学号
		}
	}
}

package test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import entity.Student;

public class CollectionsDemo {
	public static void main(String[] args) {
		Student student1=new Student();
	    student1.setNumber(5);
	    Student student2=new Student();
	    student2.setNumber(2);
	    Student student3=new Student();
	    student3.setNumber(1);
	    Student student4=new Student();
	    student4.setNumber(4);
	    ArrayList<Student> list=new ArrayList<Student>();
	    list.add(student1);
	    list.add(student2);
	    list.add(student3);
	    list.add(student4);
	    System.out.println("-------排序前-------");
	    Iterator<Student> iterator=list.iterator();
	    while(iterator.hasNext()){
	        Student stu=iterator.next();
	        System.out.println(stu.getNumber());
	    }
	    //使用Collections的sort方法对list进行排序
	    System.out.println("-------排序后-------");
	    Collections.sort(list); 
	    iterator=list.iterator();
	    while(iterator.hasNext()){
	        Student stu=iterator.next();
	        System.out.println(stu.getNumber());
	    } 
	}

}

Map总结：

java的Map(映射)是一种把键对象和值对象进行映射的集合，其中每一个元素都包含了键对象和值对象，其中值对象也可以是Map类型的数据，因此，Map支持多级映射，Map中的键是唯一的，但值可以不唯一，Map集合有两种实现，一种是利用哈希表来完成的叫做HashMap，它和HashSet都是利用哈希表来完成的，区别其实就是在哈希表的每个桶中，HashSet只有key，而HashMap在每个key上挂了一个value；另一种就是TreeMap，它实现了SortMap接口，也就是使用了红黑树的数据结构，和TreeSet一样也能实现自然排序和客户化排序两种排序方式，而哈希表不提供排序。
HashMap：哈希表的实现原理中，先采用一个数组表示位桶，每个位桶的实现在1.8之前都是使用链表，但当每个位桶的数据较多的时候，链表查询的效率就会不高，因此在1.8之后，当位桶的数据超过阈值（8）的时候，就会采用红黑树来存储该位桶的数据（在阈值之前还是使用链表来进行存储），所以，哈希表的实现包括数组+链表+红黑树，在使用哈希表的集合中我们都认为他们的增删改查操作的时间复杂度都是O(1)的，不过常数项很大，因为哈希函数在进行计算的代价比较高,HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap 的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

TreeMap：TreeMap 是一个有序的key-value集合，它是通过红黑树实现的。TreeMap 继承于AbstractMap，所以它是一个Map，即一个key-value集合。TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合。TreeMap 实现了Cloneable接口，意味着它能被克隆。TreeMap 实现了java.io.Serializable接口，意味着它支持序列化。

TreeMap基于红黑树（Red-Black tree）实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。TreeMap的基本操作 containsKey、get、put 和 remove 的时间复杂度是 log(n) 。另外，TreeMap是非同步的。 它的iterator 方法返回的迭代器是fail-fastl的。

HashTable:Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value，线程安全。