JAVA常用集合框架用法详解——基础篇

下面举几个例子主要是引出集合类的：

1、8,4,5,6,7,55,7,8  像这样的类型相同的可以使用数组来存储，本例可以用int[] arr来存储。

2、”zhnagsan”,true,68 像这样的可以使用StringBuilder或者StringBuffer来存储，但最终需要使用.toString()的方法转换成字符串才可以使用。即变为：”zhnagsantrue68”。

3、”李思”,25  像这样的可以使用对象来存储，如: new Person(“李思”,25);

9.1那什么时候需要使用集合类呢？？？？？？

1.集合类的由来：

对象用来封装特有的数据，对象多了需要存储，或者对象的个数不确定，就使用集合容器进行存储。

2.集合的特点：

--用于存储对象的容器

--集合的长度是可变的

--集合中不可以存储基本的数据类型（如:int、 char、 boolean之类的）

 

接下来用一幅图演示集合的整体框架：

3、集合容器因内部的数据结构不同，有多种具体容器。不断向上抽取，就形成了集合框架。

框架的顶层Collection接口：

Collection的常见方法：

---添加。

    boolean add(Object obj);   boolean addAll(Collectioncoll);

</pre><pre name="code" class="html">代码如下：
package com.ll.list;

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

public class testAdd {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();//定义List对象
		List<String> list=new ArrayList<String>();//定义另一个List对象	
		allList.add("hello");//使用从Collection接口中继承的方法
		allList.add(0, "world");//此方法为List自己扩展的方法
		System.out.println(allList);
		list.add("LL");
		list.add("www.ll.com");
		allList.addAll(list);//增加一组对象，此方法是从父类继承的
		System.out.println(allList);
		allList.addAll(1, list);//此方法是List接口自己扩展的方法
		System.out.println(allList);
	}

}

---删除

boolean remove(Object  obj);  boolean removeAll(Collection coll);

void  clear();//将集合中的元素清空

代码如下：

package com.ll.list;

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

public class testRemove {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();//实例化一个List对象
		allList.add("kello");
		allList.add("joke");
		allList.add("www.ll.com");
		allList.add("world");
		System.out.println(allList);//输出List对象中的元素
		allList.remove(0);//删除指定位置的内容
		System.out.println(allList);
		allList.remove("joke");//删除指定的内容
		System.out.println(allList);
	}

}

---判断

boolean contains(Object obj);//是否包含

boolean  containsAll(Collection coll);

boolean  isEmpty();//判断集合中是否含有元素

 

package com.ll.list;

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

public class testSizeAndGet {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();//定义并实例化List对象
		allList.add("world");
		allList.add("world");
		allList.add("kkorld");
		allList.add("pprld");
		allList.add("lllrld");
		allList.add("wqwld");
		System.out.println("从前向后输出：");
		for(int i=0;i<allList.size();i++){
			System.out.println(allList.get(i)+"..");
		}
		
		System.out.println("从后向前输出：");
		for(int i=allList.size()-1;i>=0;i--){
			System.out.println(allList.get(i)+"..");
		}
	}

}

---获取

int size();//获取集合中元素的个数

Iterator iterator();//取出元素的方式，使用的是迭代器

Object get(int i);

代码如下：

package com.ll.list;

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

public class testSizeAndGet {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();//定义并实例化List对象
		allList.add("world");
		allList.add("world");
		allList.add("kkorld");
		allList.add("pprld");
		allList.add("lllrld");
		allList.add("wqwld");
		System.out.println("从前向后输出：");
		for(int i=0;i<allList.size();i++){
			System.out.println(allList.get(i)+"..");
		}
		
		System.out.println("从后向前输出：");
		for(int i=allList.size()-1;i>=0;i--){
			System.out.println(allList.get(i)+"..");
		}
	}

}

代码如下：测试Iterator的用法

package com.ll.list;

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

/*
 * 迭代输出：Iterator
 * 是最常用的的集合输出操作
 * 但是只能进行单向的从前向后输出
 */
public class testIterator {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> allList=new ArrayList<String>();
		allList.add("hello");
		allList.add("world");
		allList.add("__ll__");
		//直接实例化一个Iterator接口
		System.out.println("删除前的集合"+allList.toString());
		Iterator<String> it=allList.iterator();
		while(it.hasNext()){//判断是否还有元素
			String str=it.next();
			if("__ll__".equals(str)){
				it.remove();//使用remove方法删除指定的元素
			}
			else{
				System.out.print(str+"、");//next()方法用来取出当前元素
			}
		}
		System.out.println("\n删除后的集合"+allList.toString());
	}

}

----其他

boolean retainAll(Collectioncoll);//取交集

Object[]     toArray();将集合转成数组

 

 

4、Collection是接口，只能通过子类来实例化。如：Collection coll=new ArrayList();

 

注意：这里会稍微提一下之前的迭代输出的代码。迭代输出有两种写法，如下：

法一：

       Iterator it=coll.iterator();

       while(it.hasnext){

       system.out.println(it.next());

       }

法二：

       for(Iterator it=coll.iterator;it.hasnext();){

       system.out.println(it.next());

       }

比较两种方法，我们会注意到while()循环结束后，it会一直占着内存不放，而for循环不会出现这种情况。

5、迭代器的原理

迭代器，取出元素的对象，该对象必须依赖具体的容器。因为每一个容器的数据结构是不同的。所以该迭代器是在容器中进行内部的实现。对于使用容器而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可。也就是iterator方法。

Iterator接口就是对所有Collection容器进行元素取出的公共接口。

9.2、Collection的子接口

  ----List:有序（存入和取出的顺序一致），元素都有索引（即角标），元素可以重复。

-----Set:元素不能重复，无序的。

 

一、List特有的常见方法（都有一个共性的特点就是可以操作角标）

List集合是可以完成对元素的增删改查，List集合的实现是通过子类来完成：

如 List  ll=new ArrayList();

         1、添加（通过索引的位置来添加元素）

                   voidadd(index,element);

                   voidadd(index,Collection)

 

                   //List特有的取出方式之一

                   for(inti=0;i<ll.size();i++){

                   System.out.println(ll.get(i));

                            }

         2、删除（删除相应索引位置的元素）

         Object      remove(index);//返回被删除的元素

 

         3、修改（修改指定索引位置的元素，并返回修改前的元素）

         ObjectSet(index,element)//返回被修改的元素

        

         4、获取：

Object get (index);

int  IndexOf(object);//返回此列表中第一次出现指定元素的索引，如果此列表不包含该素，                               //则返回-1.

int lastIndexOf(object);//返回此列表中最后一次出现指定的元素，如果此列表不包含该元素，                                  //则返回-1.

List subList(int from,int to);//包含头，不包含尾，获取子列表。

代码如下：
package com.wq.list;
/**
 * 添加一个课程类，提供课程的选择
 * @author LULEI
 *
 */
public class Courses {
	private String id;//课程序号
	private String name;//课名
	
	public Courses(){
		
	}
	public Courses(String id,String name){
		this.setId(id);
		this.setName(name);
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	
}

测试List的一些方法：

package com.wq.list;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class ListTest {
	//用于存放备选课程的List
	public List courseToSelect;
	public ListTest(){
		this.courseToSelect=new ArrayList();
	}
	
	//用于courseToSelect添加备选课程
	public void testAdd(){
		//创建一个课程的实例，并通过使用add方法，将该实例
		//添加到备选课程List中
		Courses cr1=new Courses("1", "数据库");
		courseToSelect.add(cr1);//将课程添加到备选课程List中
		Courses temp=(Courses)courseToSelect.get(0);//选取List列表中的第一个元素
		System.out.println("添加了课程："+temp.getId()+"."+temp.getName());
		
		Courses cr2=new Courses("2","JAVA");
		courseToSelect.add(0, cr2);
		Courses temp2=(Courses)courseToSelect.get(0);
		System.out.println("添加了课程："+temp2.getId()+"."+temp2.getName());
		
		/*
		 * 下面代码会出现越界的异常
		Courses cr3= new Courses("4", "test");
		courseToSelect.add(4,cr3);
		//Courses cr3=(Courses)courseToSelect.get(4);
		//System.out.println("添加了课程："+cr3.getId()+"."+cr3.getName());
		 * 
		 */
		
		Courses cr7=new Courses("1", "数据库");
		courseToSelect.add(cr7);//将课程添加到备选课程List中
		Courses temp7=(Courses)courseToSelect.get(2);//选取List列表中的第一个元素
		System.out.println("添加了课程："+temp7.getId()+"."+temp7.getName());
		//addAll()方法的使用
		Courses[] cr3={new Courses("3","高数"),new Courses("4","英语")};
		courseToSelect.addAll(Arrays.asList(cr3));//将数组转换成List集合
		Courses temp3=(Courses)courseToSelect.get(3);
		Courses temp4=(Courses)courseToSelect.get(4);
		
		System.out.println("添加了两门课:"+temp3.getId()+"."+temp3.getName()
				+temp4.getId()+"."+temp4.getName());
		
		Courses[] cr4={new Courses("5","高等语文"),new Courses("6","数据处理")};
		courseToSelect.addAll(2,Arrays.asList(cr4)); //将数组转换成List集合

		Courses temp5=(Courses)courseToSelect.get(2);
		Courses temp6=(Courses)courseToSelect.get(3);
		
		System.out.println("添加了两门课:"+temp5.getId()+"."+temp5.getName()
				+temp6.getId()+"."+temp6.getName());
		
	}
	
	/**
	 * 创建一个Get方法，用于获取List中的元素的方法
	 */
	public void testGet(){
		int num=courseToSelect.size();//获取List的长度
		System.out.println("可以选择的课程如下：");
		for(int i=0;i<num;i++){
			Courses cr=(Courses) courseToSelect.get(i);
			System.out.println(cr.getId()+"."+cr.getName());
		}
	}
	
	/**
	 * 使用迭代器的方法来获取List中的元素
	 * @param args
	 */
	public void testIterator(){
		//迭代器是个借口，依赖集合存在
		Iterator i=courseToSelect.iterator();
		System.out.println("可以选择的课程如下(通过迭代器实现的)：");
		while(i.hasNext()){
			Courses cr=(Courses)i.next();
			System.out.println(cr.getId()+"."+cr.getName());
		}
	}
	
	/**
	 * 使用for each的方法来获取List中的元素
	 * @param args
	 */
	public void testForEach(){
		System.out.println("可以选择的课程如下(通过foreach实现的)：");
		for(Object obj:courseToSelect){
			Courses cr=(Courses)obj;
			System.out.println(cr.getId()+"."+cr.getName());
		}
	}
	
	/**
	 * 通过set()方法来修改List元素
	 * @param args
	 */
	public void testModify(){
		courseToSelect.set(4, new Courses("7", "毛概"));
		}
	
	
	/**
	 * 学会使用remove()方法来删除List中的元素
	 * 这种方法的参数是obj，还有一种remove方法的参数是索引、
	 * 如：remove(4);即可获得同样的效果
	 * @param args
	 */
	public void testRemove(){
		Courses cr=(Courses) courseToSelect.get(4);
		System.out.println("将要删除的课程是:"+cr.getId()+"."+cr.getName());
		courseToSelect.remove(cr);
		System.out.println("课程已删除");
		testForEach();
	}
	
	
	/**
	 * 使用removeAll()方法来删除多个List中的对象
	 * @param args
	 */
	public void testRemoveAll(){
		Courses[] crs={(Courses) courseToSelect.get(4),
				(Courses) courseToSelect.get(5)};
		//removeAll的参数是一个集合，所以要将
		//Courses数组转换成集合List
		courseToSelect.removeAll(Arrays.asList(crs));
		testForEach();
	}
	
	/**
	 * 创建一个奇怪的方法，用来给List添加字符串
	 * @param args
	 */
	public void testAddString(){
		System.out.println("到底能不能添加字符串呢！！");
		courseToSelect.add("这是一个很无辜的字符串");
	}
	
	public static void main(String[] args){
		ListTest lt=new ListTest();
		lt.testAdd();
		lt.testGet();
		
		lt.testIterator();
		lt.testAddString();
		lt.testForEach();
//		lt.testModify();
//		lt.testForEach();
//		lt.testRemove();
//		lt.testRemoveAll();
	}
}

接下来我们看看一个使用迭代器出错的代码：

主要代码如下：

       ll.add(“qwe1”);

       ll.add(“qwe2”);

       ll.add(“qwe3”);

Iterator  it=ll.iterator();//获取List集合的迭代器的对象

       while(it.hasnext()){

              Object  obj=it.next();

              if(obj.equals(“qwe2”)){

                     ll.add(“abc9”);//集合添加元素

                     }

              else{

              System.out.println(“next:”+obj);//打印元素

                     }

       }     

 

以上就是一段代码，但是在运行while循环中会出现异常：Java.util.concurrentModificationException。主要的原因是：在迭代器过程中，不要使用集合来操作元素，容易抛出异常。怎么解决呢？？？我们可以使用Iterator的子接口ListIterator来完成在迭代器中对元素进行更多的操作。

 

更换代码如下：

       ll.add(“qwe1”);

       ll.add(“qwe2”);

       ll.add(“qwe3”);

ListIterator  it=ll.listiterator();//获取List集合的迭代器的对象

       while(it.hasnext()){

              Object  obj=it.next();

              if(obj.equals(“qwe2”)){

                     it.add(“abc9”);//迭代器对象进行添加元素

                     }

              else{

              System.out.println(“next:”+obj);//打印元素

                     }

       }      

二、List的子类

-------Vector:内部是数组数据结构，是同步的（即线程安全的）。增删修改查询都很慢。（不常用）

-------ArrayList:内部是数组数据结构的，是不同步的。替代了Vector,查询的速度快。

------LinkedList:内部是链表的数据结构，是不同步的。增删元素的速度非常快。

 

这里我们做一个练习：使用LinkedList来模拟一个堆栈和队列的数据结构。

堆栈：先进后出（First In Last Out）FILO

队列：先进先出（First In First Out）FIFO

 

我们应该描述这样一个容器，给使用者提供一个容器对象完成这两种结构的一种。

LinkedList(可以实现队列和堆栈的功能)

常用的方法如下：

       addFirst();

       addLast();//从jdk1.6后改成 offerFirst(),和offerLast();

getFirst();//获取但不移除，如果链表为空。抛出NoSuchElementException

getLast();

 

从jdk1.6后上面两个改成：

peekFirst();//获取但不移除，如果链表为空，则返回null

peekLast();

 

 

removeFirst();//获取，且移除当前的元素。如果链表为空。抛出NoSuchElementException

removeLast();

 

从jdk1.6后上面两个改成：

poolFirst();//获取且移除当前的元素，如果链表为空，则返回null

poolLast();

 

 

代码的实现如下：

///队列类
package com.wq.linkedlist;

import java.util.LinkedList;
import java.util.List;

public class DuiLie {
	//这个类是实现队列的功能的
	LinkedList ls=new LinkedList();//内部是链表结构的list
	public DuiLie(){
		
	}
	public void addElement(Object obj){
		//ls.addLast(obj);//在后面添加元素
		ls.offerLast(obj);//jdk1.6版本后的在后面添加元素方法
		System.out.println(obj+"已经加入队列");
	}
	public void removeElement(){
		Object obj=ls.pollFirst();//jdk1.6版本的删除最前面的元素，取代了removeFirst()方法
		System.out.println(obj+"已经出队列");
	}
}


///堆栈类
package com.wq.linkedlist;

import java.util.LinkedList;

public class DuiZhan {
	//这个类是实现堆栈的功能的
		LinkedList ls=new LinkedList();//内部是链表结构的list
		public DuiZhan(){
			
		}
		public void addElement(Object obj){
			//ls.addLast(obj);//在后面添加元素
			ls.offerLast(obj);//jdk1.6版本后的在后面添加元素方法
			System.out.println(obj+"已经加入堆栈");
		}
		public void removeElement(){
		Object obj=ls.pollLast();//jdk1.6版本的删除最前面的元素，取代了removeLast()方法
			System.out.println(obj+"已经退出堆栈");
		}
}


/////测试上述两个类
package com.wq.linkedlist;

public class test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		DuiZhan dz=new DuiZhan();//实例化堆栈的对象
		DuiLie dl=new DuiLie();//实例化队列的对象
		
		//实现堆栈的功能
		System.out.println("实现堆栈的功能");
		dz.addElement(111);
		dz.addElement(222);
		dz.addElement(333);
		dz.addElement(444);
		
		dz.removeElement();
		dz.removeElement();
		dz.removeElement();
		dz.removeElement();
		System.out.println();
		
		//实现队列的功能
		System.out.println("实现队列的功能");
		dl.addElement(111);
		dl.addElement(222);
		dl.addElement(333);
		dl.addElement(444);
		
		dl.removeElement();
		dl.removeElement();
		dl.removeElement();
		dl.removeElement();
		
	}

}

运行结果如下：

实现堆栈的功能

111已经加入堆栈

222已经加入堆栈

333已经加入堆栈

444已经加入堆栈

444已经退出堆栈

333已经退出堆栈

222已经退出堆栈

111已经退出堆栈

 

实现队列的功能

111已经加入队列

222已经加入队列

333已经加入队列

444已经加入队列

111已经出队列

222已经出队列

333已经出队列

444已经出队列

三、ArrayList集合存数自定义对象

1、集合里存储的都是对象的引用，迭代器里迭代的也是集合中的引用

代码如下：

package com.wq.arraylist;

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

import com.wq.person.Person;

/**
 * 该类主要完成 去除ArrayList中的重复元素
 * @author LULEI
 *
 */
public class testArrayList {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List li=new ArrayList();
		
		testDemo1(li);
	}

	public static void testDemo1(List li) {
		//测试传统的对象
		/*
		li.add("111");
		li.add("111");
		li.add("222");
		li.add("333");
		li.add("444");
		li.add("333");
		*/
		
		/*
		 * 测试添加自定义的对象Person
		 */
		li.add(new Person("wq1",21));
		li.add(new Person("wq2",22));
		li.add(new Person("wq1",21));
		li.add(new Person("wq3",23));
		li.add(new Person("wq2",22));
		li.add(new Person("wq3",23));
		System.out.println(li);
		
		//调用换取单个元素的方法
		li=getSingelElement(li);
		System.out.println(li);
	}

	public static List getSingelElement(List li) {
		// TODO Auto-generated method stub
		List temp=new ArrayList();
		for(Iterator it=li.iterator();it.hasNext();){
			Object obj=it.next();
			if(!temp.contains(obj)){//如果不包含该元素
				temp.add(obj);
			}
		}
		return temp;
	}

}

四、Set集合

Set是个接口，元素不可以重复，是无序的。Set接口中的方法和Collection的一致。

Set的子类：

1、-----HashSet：此类实现的Set接口，由哈希表(实际上是一个HashMap)实例支持，它不保证Set的迭代顺序，但是允许使用null元素。

 

HashSet：内部结构是哈希表，是不同步的。

哈希表确定元素是否相同：

一、    判断的是两个元素的哈希值是否相同。如果相同，再判断两个对象的内容是否相同。

二、    判断哈希值是否相同，其实判断的是对象的hashCode()的方法。判断内容是否相同，用的是equals（）方法。

三、    如果哈希值不同，那就不需要进行equals判断。

 

HashSet集合数据结构是哈希表，所以存储元素的时候，使用元素的hashCode()方法来确定位置，如果位置相同，再通过元素的equals方法来确定是否相同。

 

练习题：定义功能去除ArrayList的重复元素

注意：像ArrayList集合，在判断元素是否相同的时候，仅仅需要判断equals（）方法。因为数据结构不同，对元素的判断依据也就一样。

 

代码如下：

package com.wq.person;

public class Person extends Object {
		private String name;
		private int age;
		
		public Person() {
			super();
			// TODO Auto-generated constructor stub
		}
		public Person(String name, int age) {
			super();
			this.name = name;
			this.age = age;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
	
		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + age;
			result = prime * result + ((name == null) ? 0 : name.hashCode());
			return result;
		}
		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (!(obj instanceof Person))
				return false;
			Person other = (Person) obj;
			if (age != other.age)
				return false;
			if (name == null) {
				if (other.name != null)
					return false;
			} else if (!name.equals(other.name))
				return false;
			return true;
		}
		@Override
		public String toString() {
			// TODO Auto-generated method stub
			return name+"...."+age;
		}
		
}





//hashset测试程序
package com.wq.hashset;

import java.util.HashSet;
import java.util.Iterator;

import com.wq.person.Person;

public class testHashSet {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HashSet hs=new HashSet();//实例化一个hashset对象
		hs.add(new Person("lisi1",21));
		hs.add(new Person("lisi2",22));
		hs.add(new Person("lisi3",23));
		hs.add(new Person("lisi4",24));
		hs.add(new Person("lisi4",24));//如果想在迭代中不出现相同的元素，需要
									   //通过覆写Person类的hashcode和equals方法
		//使用迭代器进行迭代
		
		for(Iterator it=hs.iterator();it.hasNext();){
			Person pe=(Person)it.next();
			System.out.println(pe.getName()+"---"+pe.getAge());
		}
	}

}

运行结果如下（由于无序这只是一种可能）：
lisi4---24
lisi3---23
lisi2---22
lisi1---21

特别注意：如果希望元素不重复，但是要有序，这时可以考虑使用LinkedHashSet,它是HashSet的子接口。

 

 

2、----TreeSet:可以对Set集合的元素进行排序，不是同步的。

       判断元素唯一性的方式就是根据比较方法compareTo()的返回结果，判断返回的结果是否为0，是0就表示相同的元素且不存储。否则就相反

 

TreeSet对元素进行排序的方式一：让元素具备比较功能，元素需要实现comparable接口，覆盖CompareTo()方法。

 

 

如果不要按照对象具备的自然顺序进行排序，如果对象不具备自然顺序。（即对象没有比较性，或者具备的比较性不是我们所需要的）这个时候怎么办？？？

 

TreeSet对元素进行排序的方式二：（生成一个比较器）让集合自身具备比较的功能，定义一个类，实现Comparator接口，覆盖compare方法，将该类的对象作为参数传递给TreeSet集合的构造函数。

   

代码演示如下：

//Person类
package com.wq.person;
//需要实现Comparable接口
public class Person extends Object implements Comparable{
		private String name;
		private int age;
		
		public Person() {
			super();
			// TODO Auto-generated constructor stub
		}
		public Person(String name, int age) {
			super();
			this.name = name;
			this.age = age;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
	
		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + age;
			result = prime * result + ((name == null) ? 0 : name.hashCode());
			return result;
		}
		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (!(obj instanceof Person))
				return false;
			Person other = (Person) obj;
			if (age != other.age)
				return false;
			if (name == null) {
				if (other.name != null)
					return false;
			} else if (!name.equals(other.name))
				return false;
			return true;
		}
		@Override
		public String toString() {
			// TODO Auto-generated method stub
			return name+"...."+age;
		}
		//需要覆写的compareTo方法
		//这里我的思路是先比较age的大小，如果age相等，则
		//接着比较name的字典顺序大小
		@Override
		public int compareTo(Object o) {
			// TODO Auto-generated method stub
			Person per=(Person) o;//实现强制类型转换
			if(this.age>per.age){
				return 1;
			}else if(this.age<per.age){
				return -1;
			}else{//如果年纪相等就比较名字的字典顺序大小
				int temp=this.name.compareTo(per.name);
				return temp;
			}
			
			
		}
		
}


//自己写的Comparator接口
package com.wq.comparator;

import java.util.Comparator;

import com.wq.person.Person;

public class ComparatorByName implements Comparator {

	/**
	 * 覆写compare方法，生成一个比较器。这里我们用name来作为比较
	 */
	@Override
	public int compare(Object o1, Object o2) {
		// TODO Auto-generated method stub
		Person p1=(Person)o1;
		Person p2=(Person)o2;
		
		int temp=p1.getName().compareTo(p2.getName());//获取两个对象的name比较的结果
		return temp==0?p1.getAge()-p2.getAge():temp;
	}

}


//测试类。用于测试CompareTo()方法和Comparable接口
package com.wq.TreeSet;

import java.util.Iterator;
import java.util.TreeSet;

import com.wq.comparator.ComparatorByName;
import com.wq.person.Person;

public class testTreeSet {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//测试实现Comparable接口的比较功能
		System.out.println("测试实现Comparable接口的比较功能");
		testComparableDemo();
		
		System.out.println("测试实现Comparator接口，作为一个比较器来进行比较的功能");
		//测试实现Comparator接口，作为一个比较器来进行比较的功能
		testComparatorDemo();
		
	}

	public static void testComparatorDemo() {
		TreeSet ts=new TreeSet(new ComparatorByName());//实例化对象,并且确定比较器
		//添加自定义对象
		//在添加元素时，自定义的对象必须实现Comparator接口，同时要覆盖compare方法
		//否则就会报错
		ts.add(new Person("zhangsan",22));
		ts.add(new Person("zhaoliu",24));
		ts.add(new Person("zhouqi",25));
		ts.add(new Person("wuba",28));
		ts.add(new Person("lisi",26));
		ts.add(new Person("wangwu",25));
		
		for(Iterator it=ts.iterator();it.hasNext();){
			Person per=(Person)it.next();
			System.out.println(per);
		}
	}

	public static void testComparableDemo() {
		TreeSet ts=new TreeSet();//实例化对象,
		//添加自定义对象
		//在添加元素时，自定义的对象必须实现Comparable接口，同时要覆盖compareTo方法
		//否则就会报错
		ts.add(new Person("zhangsan",22));
		ts.add(new Person("zhaoliu",24));
		ts.add(new Person("zhouqi",25));
		ts.add(new Person("wuba",28));
		ts.add(new Person("lisi",26));
		ts.add(new Person("wangwu",25));
		
		for(Iterator it=ts.iterator();it.hasNext();){
			Person per=(Person)it.next();
			System.out.println(per);
		}
	}

}

运行结果如下：

测试实现Comparable接口的比较功能（以年龄大小）

zhangsan....22

zhaoliu....24

wangwu....25

zhouqi....25

lisi....26

wuba....28

测试实现Comparator接口，作为一个比较器来进行比较的功能（以名字的字典顺序）

lisi....26

wangwu....25

wuba....28

zhangsan....22

zhaoliu....24

zhouqi....25

练习：TreeSet集合练习，字符串长度的排序

    分析：Java代码中。TreeSet默认的会为字符串进行字典顺序大小的排序，但这不符合我们的要求。这个时候怎么办，我们必须要用到比较器。即comparator接口来实现。

具体代码实现如下：

//自定义的比较器
package com.wq.comparator;

import java.util.Comparator;

import com.wq.person.Person;
/*
 * 生成一个比较器，用来比较字符串的长度大小，如果长度相等则比较字符的字典顺序大小
 */
public class ComparatorByLength implements Comparator {

	@Override
	public int compare(Object o1, Object o2) {
		// TODO Auto-generated method stub
		String str1=(String)o1;
		String str2=(String)o2;
		int temp=str1.length()-str2.length();
		return temp==0?str1.compareTo(str2):temp;
	}

}

//测试类
package com.wq.TreeSet;

import java.util.Iterator;
import java.util.TreeSet;

import com.wq.comparator.ComparatorByLength;
import com.wq.person.Person;

/**
 * 这个练习是对TreeSet集合的练习
 * 主要是进行字符串的长度的排序
 * @author LULEI
 *
 */
public class testTreeSetDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TreeSet ts=new TreeSet(new ComparatorByLength());//在构造函数中添加相应的构造器
		
		ts.add("asdfdf");
		ts.add("dds");
		ts.add("fghf");
		ts.add("as");
		ts.add("t");
		ts.add("fdsfsg");
		
		for(Iterator it=ts.iterator();it.hasNext();){
			Object o=(Object)it.next();
			System.out.println(o);
		}
	}

}

运行结果如下：

t

as

dds

fghf

asdfdf

fdsfsg

总结：List:       1---ArrayList     2---LinkedList

         Set         1---HashSet    --LinkedHashSet

                  2---TreeSet

注意，后缀名就是该集合所属的体系，前缀名就是该集合的数据结构。

     看到array:就要想到数组，就要想到查询快，有角标。如果不希望出现重复的元素则需要覆盖equals（）方法。

     看到link就要想到链表，就要想到增删快，就要想到add,get,remove+first(last)的方法。

     看到hash就要想到哈希表，就要想到唯一性，就要想到元素需要覆盖hashCode()和equals（）方法。

     看到tree就要想到二叉树，就要想到排序，就要想到两个接口：comparator和comparable。

 

并且通常这些常用的容器都是不同步的。

五、Map集合

Map<K,V>；一次添加一对元素。而Collection一次添加一个元素。Map集合也称为双列集合，Collection集合也称为单列集合。其实Map集合中存储的就是键值对，且保证键（K）的唯一性。

常用的方法：

1、添加

value   put(key,value);//返回前一个与key关联的值，如果没有则返回null

 

2、删除

value  remove(key);//根据指定的key删除这个键值对

void clear();//清除这个Map集合

 

3、判断

boolean  containsKey(key);

boolean  containsValue(value);

boolean  isEmpty();//判断是否为空

 

4、获取

value get(key);//用过键来返回值，如果没值该键返回null。当然可以通过返回null来判断是否包含指            //定的键（K）

 

int size();//获取键值对的个数

 

 

Map接口是如何实例化的？？

如：Map<Integer,String> map=newHashMap<Integer,String>();//实例化一个                                                     //HashMap对象

 

5、注意：问题：如何获取map中的所有的元素？？？

取出map中的元素，原理如下：通过keySet方法获取map中所有键所在的Set集合中，再通过Set的迭代器获取到每个键。然后对每个键通过map集合的get()方法获取其所对应的值。

代码演示如下：

package com.wq.map;

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

/**
 * 测试Map的一些基本的方法
 * 
 * @author LULEI
 *
 */
public class mapDemo1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map<Integer, String> hm=new HashMap<Integer,String>();//实例化对象
		
		testMapDemo1(hm);//这个方法实现了一些基本方法
		
		
		System.out.println();
		System.out.println();
		testMapDemo2(hm);	//这个方法实现Map集合中如何取出所有的元素
							//1、要使用到keySet()方法来获取key值得Set集合
							//2、依次的迭代Set集合中的key值，最后通过get(key)来获取键值对
		
	}

	public static void testMapDemo2(Map<Integer, String> hm) {
		// TODO Auto-generated method stub
		String str2=hm.put(2, "lisi");
		//System.out.println("此时给相同的key赋键值,返回的上一个键值是："+str2);//此时lisi								//会覆盖wangcai的，同时put方法会返回之前的键值对
		hm.put(8, "wq");
		hm.put(7, "ll");
		hm.put(6, "pp");
		
		Set<Integer> s=hm.keySet();//获取key的Set集合
		//使用迭代器来迭代集合
		for(Iterator<Integer> it=s.iterator(); it.hasNext();){
			Integer i=it.next();
			System.out.println("使用迭代获取的元素："+hm.get(i)  );
		}
		
	}

	public static void testMapDemo1(Map<Integer, String> hm) {
		//添加
		String str1=hm.put(2, "wangcai");
		System.out.println("此时给相同的key赋键值,返回的上一个键值是："+str1);//此时由于key										//刚刚被赋值，所以之前是没有键值对的
		String str2=hm.put(2, "lisi");
		System.out.println("此时给相同的key赋键值,返回的上一个键值是："+str2);//此时lisi									//会覆盖wangcai的，同时put方法会返回之前的键值对
		hm.put(7, "ll");
		hm.put(8, "wq");
		hm.put(6, "pp");
		System.out.println("所有的键值对如下："+hm);
		//获取
		System.out.println("获取相应的key值得键值："+hm.get(7));
		System.out.println("获取相应的key值得键值："+hm.get(4));
		//删除
		hm.remove(6);//删除key为6的键值
		System.out.println("删除key为6的键值后的map"+hm);
	}

}

运行结果如下：

此时给相同的key赋键值,返回的上一个键值是：null

此时给相同的key赋键值,返回的上一个键值是：wangcai

所有的键值对如下：{2=lisi,6=pp, 7=ll, 8=wq}

获取相应的key值得键值：ll

获取相应的key值得键值：null

删除key为6的键值后的map{2=lisi, 7=ll, 8=wq}

 

 

使用迭代获取的元素：lisi

使用迭代获取的元素：pp

使用迭代获取的元素：ll

使用迭代获取的元素：wq

 

上面提到的只是一种方法，另一种方法是entrySet()。该方法将键与值得映射关系作为对象存储到了Set集合中，而这个映射关系的类型就是Map.EntryKey类型。（打个比方：键是丈夫，值就是妻子，映射关系就是结婚证）。

Entry本身就是一个嵌套的静态接口。

 

 

图解如下：

6、values方法（如果只想获取值不要键怎么办？？？）

Collection<V> values()方法：返回映射关系中包含的值得Collection集合。注意只含值，然后利用Iterator迭代器来迭代即可获取所有的值。

 

 

7、Map常用的子类

    --Hashtable:内部结构是哈希表，是同步的。不支持null作为键和值。

       ---Properties:Hashtable的子类，用来存储键值对配置文件的信息，               可以和IO口技术向结合。

   

    --HashMap:内部结构是哈希表，不是同步的，支持null作为键和值。

      

    --TreeMap:内部结构是二叉树，不是同步的，支持null作为键和值。

 

代码演示如下：

//Person类
package com.wq.person;

public class Person extends Object implements Comparable{
		private String name;
		private int age;
		
		public Person() {
			super();
			// TODO Auto-generated constructor stub
		}
		public Person(String name, int age) {
			super();
			this.name = name;
			this.age = age;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
	
		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + age;
			result = prime * result + ((name == null) ? 0 : name.hashCode());
			return result;
		}
		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (!(obj instanceof Person))
				return false;
			Person other = (Person) obj;
			if (age != other.age)
				return false;
			if (name == null) {
				if (other.name != null)
					return false;
			} else if (!name.equals(other.name))
				return false;
			return true;
		}
		@Override
		public String toString() {
			// TODO Auto-generated method stub
			return name+"...."+age;
		}
		//需要覆写的compareTo方法
		//这里我的思路是先比较age的大小，如果age相等，则
		//接着比较name的字典顺序大小
		@Override
		public int compareTo(Object o) {
			// TODO Auto-generated method stub
			Person per=(Person) o;//实现强制类型转换
			if(this.age>per.age){
				return 1;
			}else if(this.age<per.age){
				return -1;
			}else{//如果年纪相等就比较名字的字典顺序大小
				int temp=this.name.compareTo(per.name);
				return temp;
			}
			
			
		}
		
}

	//student类继承Person类
package com.wq.person;

public class Student extends Person{
	private String name;
	private int age;
	public Student(String name, int age) {
	
		super(name,age);
	}
	public Student(){
		super();
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
		
}



	//测试HashMap类
package com.wq.map;

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

import com.wq.person.Student;

public class Hashmaptest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HashMap<Student,String> hm=new HashMap<Student,String>();
		//添加学生对象，和学生的归属地
		hm.put(new Student("lisi",24 ),"南京");
		hm.put(new Student("zhangsan",44 ),"北京");
		hm.put(new Student("wangwu",32 ),"天津");
		hm.put(new Student("xiaoqiang",18 ),"上海");
		hm.put(new Student("xiaoqiang",18 ),"后海");
		
		Set<Student> s=hm.keySet();
		Iterator<Student> it=s.iterator();
		while(it.hasNext()){
			Student st=it.next();
			String value=hm.get(st);
			System.out.println(st.getName()+".."+st.getAge()+"...."+value);
		}
	}

}

运行代码如下：

xiaoqiang..18....后海

wangwu..32....天津

zhangsan..44....北京

lisi..24....南京

//测试TreeMap类
//自定义比较器
package com.wq.comparator;

import java.util.Comparator;

import com.wq.person.Person;

public class ComparatorByName implements Comparator {

	/**
	 * 覆写compare方法，生成一个比较器。这里我们用name的字典顺序来作为比较
	 */
	@Override
	public int compare(Object o1, Object o2) {
		// TODO Auto-generated method stub
		Person p1=(Person)o1;
		Person p2=(Person)o2;
		
		int temp=p1.getName().compareTo(p2.getName());//获取两个对象的name比较的结果
		return temp==0?p1.getAge()-p2.getAge():temp;
	}

}



//TreeMap测试部分
package com.wq.map;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

import com.wq.comparator.ComparatorByName;
import com.wq.person.Student;

public class TreeMaptest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//添加一个比较器，用来排序
		TreeMap<Student,String> hm=new TreeMap<Student,String>(new ComparatorByName());
		//添加学生对象，和学生的归属地
		hm.put(new Student("lisi",24 ),"南京");
		hm.put(new Student("zhangsan",44 ),"北京");
		hm.put(new Student("wangwu",32 ),"天津");
		hm.put(new Student("xiaoqiang",18 ),"上海");
		hm.put(new Student("xiaoqiang",28 ),"后海");
		
		//使用entrySet来获取全部元素
		Iterator<Map.Entry<Student, String>> it=hm.entrySet().iterator();
		
		while(it.hasNext()){
			Map.Entry<Student, String> mp=it.next();
			Student st=mp.getKey();
			String value=mp.getValue();
			System.out.println(st.getName()+".."+st.getAge()+"...."+value);
		}
	}

}

运行结果：

lisi..24....南京

wangwu..32....天津

xiaoqiang..18....上海

xiaoqiang..28....后海

zhangsan..44....北京

 

 

相信以上的代码能够帮助我们更好地理解Map的子类。以及获取所有子类元素的方法：keySet()和EntrySet()两种方法。接下来看看练习：

 

练习题：” aFGDHRTYdshgfd./,/g1uAAD898 styefbhbhad”,这样一个随机的字符串。获取该字符串中每个字符出现的次数。并最终以a(n),b(m)……这样的格式打印出来。

 

分析如下：对于结构的显示，字符和出现次数之间存在着映射的关系。而且这种关系很多。既然很多我们就需要存储，但是能存储映射关系的有数组和Map集合。这时我们需要考虑：关系一方有序号编码吗？答案是没有，于是我们就选用Map集合，同时又发现可以保证唯一性的一方具备着顺序如：a,b,c,d,……。所以最后的选择是TreeMap集合。

 

操作思路：这个集合最后存储的是字符与次数的对应关系。

1、因为操作的是字符串中的字符，所以先将字符串变成字符数组。

2、遍历字符数组，用每一个字符作为键去查询Map集合这个表。

3、如果该键不存在，就将该字母作为键，1作为值，存储到Map集合中。

4、如果该键存在，就将该字符键对应的值加1，在将该字母与加1后的值存在Map集合中。键相同，只会覆盖，这样就记录了字符的次数。

5、遍历字符数组结束后，Map集合就记录了所有的字符出现的次数。一次迭代输出即可是实现。

 

代码实现如下：

package com.wq.map;

import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

/**
 * 练习：" aFGDHRTYdshgfd./,/g1uAAD898 styefbhbhad "获取该字符串中，
 * 每一个字母出现的次数，要求打印的结果如下
 * a(1)b(2)c(..)...
 * @author LULEI
 *
 */
public class MapPrictice {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//声明要变换的字符串
		String str="aFGDHRTYdshgfd./,/g1uAAD898 styefbhbhad";
		str=StringTocharNum(str);
		System.out.println(str);
	}

	public static String StringTocharNum(String str) {
		// TODO Auto-generated method stub
		//1、第一步是将字符串转换成字符数组
		char[] ch=str.toCharArray();
		
		//2、定义一个map集合，用于存储字母（键）和出现的次数（值）
		Map<Character,Integer> mp=new TreeMap<Character,Integer>();
		//3、开始进行循环的判断
		
		//当出现非字母的字符时，增加如下的判断
		
		for (int i = 0; i < ch.length; i++) {
			if(!(ch[i]>='a' && ch[i]<='z'|| ch[i]>='A' && ch[i]<='Z')){
				continue;//如果不是字符则结束本次循环
			}
			Integer value=mp.get(ch[i]);//注意这里返回的是int的包装类。之前Map是这样定义的Map<Character,Integer>
			if(value==null){
				mp.put(ch[i], 1);
			}else{
				mp.put(ch[i], value+1);
			}
		}
		//4、将字母以次数打印出来
		return printCharNum(mp);//调用打印函数
	}

	private static String printCharNum(Map<Character, Integer> mp) {
		
		//定义一个可以改变字符长度的字符串
		StringBuilder sb=new StringBuilder();
		//取出Map中的所有元素
		Iterator<Character> it=mp.keySet().iterator();
		while(it.hasNext()){
			Character ch=it.next();
			Integer in=mp.get(ch);
			sb.append(ch+"("+in+")");//直接在后面添加字符串
		}
		return sb.toString();//最后转换为string类型输出
	}

}

运行结果如下：

A(2)D(2)F(1)G(1)H(1)R(1)T(1)Y(1)a(2)b(2)d(3)e(1)f(2)g(2)h(3)s(2)t(1)u(1)y(1)

补充：接下来补充一个Collection.Sort()方法的实例：可以看看代码：

 

//collection.sort()方法的测试类，这个类还需要Students类和一个自定义比较器//Studentscomparator类
package com.wq.list;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

import javax.swing.text.html.ListView;

/**
 * 将要完成
 * 1.通过Collections.sort(),对Integer泛型的List集合进行排序
 * @author LULEI
 *
 */

public class CollectionsTest {
	
	/**
	 * 通过Collections.sort(),对Integer泛型的List集合进行排序
	 * 使用Random类来生成不相等的随机数10个
	 */
	public void testListSort1(){
	List<Integer> integer=new ArrayList<Integer>();
		Random random=new Random();  //产生一个随机种子对象
		int k=0;
		//生成10个随机数
		for(int i=0;i<10;i++){
			do{
				k=random.nextInt(100);//生成100以内的一个随机数
			}while(integer.contains(k));//判断随机数是否重复，如果不重复就跳出while循环
			integer.add(k);		//向list集合中添加元素
			System.out.println(k+"已经成功添加");
		}
		System.out.println("-----排序前------");
		for(Integer it:integer){
			System.out.println("元素："+it);
		}
		
		//调用sort()方法来进行排序
		Collections.sort(integer);	//直接调用父方法的sort()进行排序
		System.out.println("--------排序后--------");
		for(Integer it:integer){
			System.out.println("元素："+it);
		}
	}
	/**
	 * 通过Collections.sort(),对String泛型的List集合进行排序
	 * 向List集合中添加3个字符串
	 */
	public void testListSort2()
	{
		List<String> str=new ArrayList<String>();
		str.add("microsoft");
		str.add("baidu");
		str.add("google");
		System.out.println("----排序前----");
		for(String ss:str){
			System.out.println(ss);
		}
		Collections.sort(str);
		System.out.println("----排序后----");
		for(String ss:str){
			System.out.println(ss);
		}
	}
	
	/**
	 *  通过Collections.sort(),对String泛型的List集合进行排序
	 *  向List里添加十条随机字符串
	 *  字符串的长度要不大于10
	 *  每个字符串的每个字符都是随机生成的，但可以重复
	 *  每个字符串是不可以重复的
	 * @param args
	 */
	public void testListOfString(){
		List<String> newStr=new ArrayList<String>();//用于存储字符串的
		Random randomLength=new Random();//随机生成字符串的长度
		
		//所有字符查询表
		String table="qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890";
		
		//生成10个字符串
		for(int i=0;i<10;i++){
			StringBuilder sb=new StringBuilder();//用来存储随机产生的字符串
			do{
				//确定当前字符串的长度
				
				int length=randomLength.nextInt(11);//注意每个字符串不能大于10个字符
				
				while(length==0){//避免length的值为0，否则这样就会产生空字符串
					length=randomLength.nextInt(11);
				}
				
				for(int m=0;m<length;m++){
					int pos=randomLength.nextInt(table.length());//获取字符查询表中任意一个随机的位置
					sb.append(table.charAt(pos));//将该位置上的字符添加到sb中
				}
			}while(newStr.contains(sb.toString()));//判断是否有重复的字符串，如果集合中不含有该字符串则退出while循环
			newStr.add(sb.toString());//使用toString方法转化为String类型
		}
		
		System.out.println("====排序前=====");
		for(String stBd:newStr){
			System.out.println(stBd);
		}
		//调用sort()方法进行排序
		Collections.sort(newStr);
		
		System.out.println("====排序后=====");
		for(String stBd2:newStr){
			System.out.println(stBd2);
		}
		Collections.sort(newStr);
	}
	/**
	 * 如何给Students类型的List集合元素进行排序
	 * 直接使用Collections.sort()方法是不行的，必须先让Students类继承comparable接口
	 * 并且覆写comparable接口的compareTo()方法。然后确定新的比较规则：此处我们设置如下
	 * this.id.compareTo(o.id);通过比较id号的字符大小顺序来进行排序
	 * @param args
	 */
	public void testStudentsList(){
		List<Students> liStu=new ArrayList<Students>();//实例化一个集合，用来存储Students对象
		Random random=new Random();//生成随机种子用于随机生成几个不相等的id号
		//添加3个Students的对象
		liStu.add(new Students(Integer.toString(random.nextInt(1000)), "tim"));
		liStu.add(new Students(Integer.toString(random.nextInt(1000)), "jack"));
		liStu.add(new Students(Integer.toString(random.nextInt(1000)), "lucy"));
		liStu.add(new Students(Integer.toString(100000), "lily"));
		/*
		 * 直接使用Collections.sort()方法是不行的，必须先让Students类继承comparable接口
		 * 并且覆写comparable接口的compareTo()方法。然后确定新的比较规则：此处我们设置如下
		 * this.id.compareTo(o.id);通过比较id号的字符大小顺序来进行排序
		 */
		System.out.println("=====排序前====");
		for(Students stu:liStu){
			System.out.println(stu.getId()+"."+stu.getName());
		}
		Collections.sort(liStu);
		
		System.out.println("=====排序后====");
		for(Students stu:liStu){
			System.out.println(stu.getId()+"."+stu.getName());
		}
		
		/**
		 * 接下来是用comparator接口来确定新的临时比较规则：使用姓名来排序
		 * 过程如下：1、定义一个StudentComparator类，然后
		 * 让这个类继承comparator接口，然后覆写该接口的compare()方法
		 * 2、然后调用Collections.sort()方法来进行排序
		 */
		Collections.sort(liStu,new StudentsComparator());
		System.out.println("-------按照名字进行排序---------");
		System.out.println("=====排序后====");
		for(Students stu:liStu){
			System.out.println(stu.getId()+"."+stu.getName());
		}
	}
	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CollectionsTest ct=new CollectionsTest();
		//排序Integer类型的List
		ct.testListSort1();
		//排序String类型的List
	//	ct.testListSort2();
		//排序随机生成的String类型的List
		ct.testListOfString();
		//排序Students类
		ct.testStudentsList();
	}

}

//Students类
package com.wq.list;

import java.util.HashSet;
import java.util.Set;
/**
 * 学生类
 * @author LULEI
 *
 */
public class Students implements Comparable<Students>{
	private String name;
	private String id;
	public Set<Courses> courses;//用于后面添加课程
	
	public Students(String id,String name){
		this.setId(id);
		this.setName(name);
		//Set是一个接口，不能直接实例化，通过HashSet()对courses进行实例化
		this.courses=new HashSet<Courses>();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (!(obj instanceof Students))
			return false;
		Students other = (Students) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public int compareTo(Students o) {
		// TODO Auto-generated method stub
		//将比较规则设置为id号
		return this.id.compareTo(o.id);
	}
	
}

//StudentsComparator类
package com.wq.list;

import java.util.Comparator;

public class StudentsComparator implements Comparator<Students> {

	@Override
	public int compare(Students o1, Students o2) {
		// TODO Auto-generated method stub
		//将规则改成比较名字
		return o1.getName().compareTo(o2.getName());
	}

}

运行结果如下：

57已经成功添加

22已经成功添加

65已经成功添加

52已经成功添加

27已经成功添加

90已经成功添加

38已经成功添加

77已经成功添加

47已经成功添加

21已经成功添加

-----排序前------

元素：57

元素：22

元素：65

元素：52

元素：27

元素：90

元素：38

元素：77

元素：47

元素：21

--------排序后--------

元素：21

元素：22

元素：27

元素：38

元素：47

元素：52

元素：57

元素：65

元素：77

元素：90

====排序前=====

Zj

gkjvUfLB

WgPiL3VX

Xj2DtAtL9

kyrkT9ILYa

G

s0FfBD

bZR

eDA

pVihS

====排序后=====

G

WgPiL3VX

Xj2DtAtL9

Zj

bZR

eDA

gkjvUfLB

kyrkT9ILYa

pVihS

s0FfBD

=====排序前====

319.tim

606.jack

464.lucy

100000.lily

=====排序后====

100000.lily

319.tim

464.lucy

606.jack

-------按照名字进行排序---------

=====排序后====

606.jack

100000.lily

464.lucy

319.tim

XXiaoLEI整理于2015-04-06 。