学生选课系统基础版

集合框架

概念与作用

概念

现实生活中：很多的事物凑在一起

数学中的集合：具有共同属性的事物的总体

Java中的集合类：是一种工具类，就像是容器，存储任意数量的具有共同属性的对象

作用

1. 在类的内部，对数据进行组织；
2. 简单而快捷的搜索大数量的条目；
3. 有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关元素
4. 有的集合接口，提供了映射关系，可以通过关键字（key）去快速查找到对应的唯一对象，而这个关键字可以是任意类型

集合与数组的对比

• 数组的长度固定，集合长度可变
• 数组只能通过下标访问元素，类型固定，而有的集合可以通过任意类型查找所有映射的具体对象

体系结构

Collection接口、子接口以及实现类

Collection接口

• 是List、Set和Queue的方法的父接口
• 定义了可用于操作List、Set和Queue的方法——增删改查

List接口及其实现类——ArrayList

• List是元素有序并且可以重复的集合，被称为序列
• List可以精确的控制每个元素的插入位置，或删除某个位置元素
• ArrayList——数组序列，是List的一个重要实现类
• ArrayList底层是由数组实现的

学生选课

创建学生类和课程类

创建项目imooc_collection_map_demo;

创建课程类

package imooc_collection_map_demo;
/*
 * 课程类
 */
public class Course {

	public String id;
	
	public String name;
	
	public Course(String id,String name) {
		this.id=id;
		this.name=name;
	}
}

创建学生类

package imooc_collection_map_demo;

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

/*
 * 学生类
 */
public class Student {
	public String id;
	
	public String name;
	
	public Set courses;
	
	public Student(String id,String name) {
		this.id=id;
		this.name=name;
		this.courses=new HashSet();
	}
}

添加课程

package imooc_collection_map_demo;

import java.util.ArrayList;
import java.util.List;
/*
 * 备选课程类
 */
public class ListTest {
	/*
	 * 用于存放备选课程的List
	 */
	public List coursesToSelect;  //创建属性
	public ListTest() { //构造方法
		this.coursesToSelect =new ArrayList();

	}
	/*
	 * 用于往coursesToSelect中添加备选课程
	 */
	public void testAdd() {
		//创建一个课程对象，并通过调用add方法，添加到备选课程List中
		Course cr1=new Course("1","数据结构");
		coursesToSelect.add(cr1);
		//当一个对象存入集合都变成Object类型取出时需要类型转换
		Course temp = (Course) coursesToSelect.get(0);
		System.out.println("添加了课程："+temp.id+":"+temp.name);
	}
	public static void main (String[]args) {
		ListTest It = new ListTest();
		It.testAdd();
	}
}

运行结果：

两个add的使用如下：

package imooc_collection_map_demo;

import java.util.ArrayList;
import java.util.List;
/*
 * 备选课程类
 */
public class ListTest {
	/*
	 * 用于存放备选课程的List
	 */
	public List coursesToSelect;  //创建属性
	public ListTest() { //构造方法
		this.coursesToSelect =new ArrayList();

	}
	/*
	 * 用于往coursesToSelect中添加备选课程
	 */
	public void testAdd() {
		//创建一个课程对象，并通过调用add方法，添加到备选课程List中
		Course cr1=new Course("1","数据结构");
		coursesToSelect.add(cr1);
		//当一个对象存入集合都变成Object类型取出时需要类型转换
		Course temp = (Course) coursesToSelect.get(0);
		System.out.println("添加了课程："+temp.id+":"+temp.name);
		Course cr2 =new Course("2","C语言");
		coursesToSelect.add(0, cr2);
		Course temp2=(Course)coursesToSelect.get(0);
		System.out.println("添加了课程："+temp2.id+":"+temp2.name);
	}
	
	public static void main (String[]args) {
		ListTest It = new ListTest();
		It.testAdd();
	}
}

运行结果如下：

 如果数组下标越界异常将会报错

另外的方法

addAll（具体实例）

方法一

package imooc_collection_map_demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/*
 * 备选课程类
 */
public class ListTest {
	/*
	 * 用于存放备选课程的List
	 */
	public List coursesToSelect;  //创建属性
	public ListTest() { //构造方法
		this.coursesToSelect =new ArrayList();

	}
	/*
	 * 用于往coursesToSelect中添加备选课程
	 */
	public void testAdd() {
		//创建一个课程对象，并通过调用add方法，添加到备选课程List中
		Course cr1=new Course("1","数据结构");
		coursesToSelect.add(cr1);
		//当一个对象存入集合都变成Object类型取出时需要类型转换
		Course temp = (Course) coursesToSelect.get(0);
		System.out.println("添加了课程："+temp.id+":"+temp.name);
		Course cr2 =new Course("2","C语言");
		coursesToSelect.add(0, cr2);
		Course temp2=(Course)coursesToSelect.get(0);
		System.out.println("添加了课程："+temp2.id+":"+temp2.name);
		//以下方法会抛出数组下标越界异常
		//Course cr3=new Course("3","test");
		//coursesToSelect.add(4,cr3);
	
		Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};
		coursesToSelect.addAll(Arrays.asList(course));
		Course temp3 =(Course)coursesToSelect.get(2);
		Course temp4 =(Course)coursesToSelect.get(3);
		System.out.println("添加了两门课程："+temp3.id+":"+temp3.name+";"+temp4.id+":"+temp4.name);
	}
		public static void main (String[]args) {
		ListTest It = new ListTest();
		It.testAdd();
	}
}

运行结果如下：

方法二

package imooc_collection_map_demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/*
 * 备选课程类
 */
public class ListTest {
	/*
	 * 用于存放备选课程的List
	 */
	public List coursesToSelect;  //创建属性
	public ListTest() { //构造方法
		this.coursesToSelect =new ArrayList();

	}
	/*
	 * 用于往coursesToSelect中添加备选课程
	 */
	public void testAdd() {
		//创建一个课程对象，并通过调用add方法，添加到备选课程List中
		Course cr1=new Course("1","数据结构");
		coursesToSelect.add(cr1);
		//当一个对象存入集合都变成Object类型取出时需要类型转换
		Course temp = (Course) coursesToSelect.get(0);
		System.out.println("添加了课程："+temp.id+":"+temp.name);
		Course cr2 =new Course("2","C语言");
		coursesToSelect.add(0, cr2);
		Course temp2=(Course)coursesToSelect.get(0);
		System.out.println("添加了课程："+temp2.id+":"+temp2.name);
		//以下方法会抛出数组下标越界异常
		//Course cr3=new Course("3","test");
		//coursesToSelect.add(4,cr3);
	
		Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};
		coursesToSelect.addAll(Arrays.asList(course));
		Course temp3 =(Course)coursesToSelect.get(2);
		Course temp4 =(Course)coursesToSelect.get(3);
		System.out.println("添加了两门课程："+temp3.id+":"+temp3.name+";"+temp4.id+":"+temp4.name);
		Course[] course2 = {new Course("5","高等数学"),new Course("6","大学英语")};
		coursesToSelect.addAll(2, Arrays.asList(course2));
		Course temp5 =(Course) coursesToSelect.get(2);
		Course temp6 =(Course) coursesToSelect.get(3);
		System.out.println("添加了两门课程："+temp5.id+":"+temp5.name+";"+temp6.id+":"+temp6.name);
	}
		public static void main (String[]args) {
		ListTest It = new ListTest();
		It.testAdd();
	}
}

运行结果如下：

课程查询

 

list中元素可以重复

代码：

public void testAdd() {
		//创建一个课程对象，并通过调用add方法，添加到备选课程List中
		Course cr1=new Course("1","数据结构");
		coursesToSelect.add(cr1);
		//当一个对象存入集合都变成Object类型取出时需要类型转换
		Course temp = (Course) coursesToSelect.get(0);
		System.out.println("添加了课程："+temp.id+":"+temp.name);
		
		Course cr2 =new Course("2","C语言");
		coursesToSelect.add(0, cr2);
		Course temp2=(Course)coursesToSelect.get(0);
		System.out.println("添加了课程："+temp2.id+":"+temp2.name);
		
		coursesToSelect.add(cr1);
		Course temp0 = (Course) coursesToSelect.get(2);
		System.out.println("添加了课程："+temp.id+":"+temp.name);
		//以下方法会抛出数组下标越界异常
		//Course cr3=new Course("3","test");
		//coursesToSelect.add(4,cr3);
	
		Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};
		coursesToSelect.addAll(Arrays.asList(course));
		Course temp3 =(Course)coursesToSelect.get(3);
		Course temp4 =(Course)coursesToSelect.get(4);
		System.out.println("添加了两门课程："+temp3.id+":"+temp3.name+";"+temp4.id+":"+temp4.name);
		Course[] course2 = {new Course("5","高等数学"),new Course("6","大学英语")};
		coursesToSelect.addAll(2, Arrays.asList(course2));
		Course temp5 =(Course) coursesToSelect.get(2);
		Course temp6 =(Course) coursesToSelect.get(3);
		System.out.println("添加了两门课程："+temp5.id+":"+temp5.name+";"+temp6.id+":"+temp6.name);
	}

运行结果： 

通过迭代器遍历集合中的元素

iterator方法

代码：

/*
	 * 通过迭代器来遍历list
	 */
	public void testIterator() {
		//通过集合的iterator方法，取得迭代器的实例
		Iterator it = coursesToSelect.iterator();
		System.out.println("有如下课程待选(通过迭代器访问)：");
		while(it.hasNext()) {
			Course cr = (Course)it.next();
			System.out.println("课程："+cr.id+":"+cr.name);
		}
	}
		public static void main (String[]args) {
		ListTest It = new ListTest();
		It.testAdd();
		It.testGet();
		It.testIterator();
	}
}

 运行结果：

迭代器只是遍历集合中元素的，不具备任何存储元素的功能 

for each方法

代码：

/*
	 * 通过for each方法访问集合元素
	 */
	public void testForEach() {
		System.out.println("有如下课程待选(通过for each访问)：");
		for(Object obj:coursesToSelect) {
			Course cr =(Course) obj;
			System.out.println("课程："+cr.id+":"+cr.name);
		}
	}
		public static void main (String[]args) {
		ListTest It = new ListTest();
		It.testAdd();
		It.testGet();
		It.testIterator();
		It.testForEach();
	}
}

运行结果：

 

课程修改

修改list中的元素

代码：

/*
	 * 修改List中的元素
	 */
	public void testModify() {
		
		coursesToSelect.set(4, new Course("7","毛概"));
	}
		public static void main (String[]args) {
		ListTest It = new ListTest();
		It.testAdd();
		It.testGet();
		It.testIterator();
		It.testForEach();
		It.testModify();
		It.testForEach();
	}
}

 运行结果：

课程删除

删除方法

remove方法 （取得某个位置的元素）

代码：

/*
	 * 删除List中的元素
	 */
	public void testRemove() {
		Course cr =(Course) coursesToSelect.get(4);
		System.out.println("我是课程："+cr.id+":"+cr.name+"我即将被删除");
		coursesToSelect.remove(cr);
		System.out.println("成功删除课程！");
		testForEach();
	}
		public static void main (String[]args) {
		ListTest It = new ListTest();
		It.testAdd();
		It.testGet();
		It.testIterator();
		It.testForEach();
		It.testModify();
		It.testForEach();
		It.testRemove();
	}
}

 运行结果：

 

remove方法（传入指令索引位置） 

public void testRemove() {
		//Course cr =(Course) coursesToSelect.get(4);
		System.out.println("即将删除4位置上的课程");
		coursesToSelect.remove(4);
		System.out.println("成功删除课程！");
		testForEach();
	}
		public static void main (String[]args) {
		ListTest It = new ListTest();
		It.testAdd();
		It.testGet();
		It.testIterator();
		It.testForEach();
		It.testModify();
		It.testForEach();
		It.testRemove();
	}
}

 运行结果和上一个方法一样

 

 removeALL方法

代码：

/*
	 * 删除List中的元素
	 */
	public void testRemove() {
		//Course cr =(Course) coursesToSelect.get(4);
		System.out.println("即将删除4位置和5位置上的课程");
		Course[] courses = {(Course)coursesToSelect.get(4),(Course)coursesToSelect.get(5)};
		coursesToSelect.removeAll(Arrays.asList(courses));
		//coursesToSelect.remove(4);
		System.out.println("成功删除课程！");
		testForEach();
	}
		public static void main (String[]args) {
		ListTest It = new ListTest();
		It.testAdd();
		It.testGet();
		It.testIterator();
		It.testForEach();
		It.testModify();
		It.testForEach();
		It.testRemove();
	}

 运行结果：

代码：

/*
	 * 往List中添加一些奇怪的东西
	 */
	public void testType() {
		System.out.println("能否往List中添加一些奇怪的东西呢！？");
		coursesToSelect.add("我不是课程，我只是一个无辜的字符串!!");
	}
		public static void main (String[]args) {
		ListTest It = new ListTest();
		It.testAdd();
		It.testAdd();
		It.testType();
		It.testForEach();
		//It.testGet();
		//It.testIterator();
		//It.testForEach();
	    //It.testModify();
		//It.testForEach();
		//It.testRemove();
	}
}

运行结果：

泛型

 

集合中的元素，可以是任意类型的对象（对象的引用）；如果把某个对象放入集合，则会忽略他的类型，而把Object处理。

      泛型则是规定了某个集合只可以存放特定类型的对象，会在编译期间进行类型检查，可以直接按指定类型获取集合元素。

注意：

• 泛型集合可以添加泛型的子类型的对象实例
•  泛型不能使用基本类型
• 泛型集合中，不能添加泛型规定的类型及其子类类型以外的对象，否则会报错
   

public class ChildCourse extends Course {
	
 
}

import java.util.ArrayList;
import java.util.List;
 
public class TestGeneric {
/*
 * 带有泛型——Course，的List类型属性
 */
	public List<Course>courses;
	
	public TestGeneric() {
		this.courses=new ArrayList<Course>();		
	}
	
	/*
	 *测试添加 
	 */
	public void testAdd() {
		Course cr1=new Course("1","大学语文");
		courses.add(cr1);	
		//泛型集合中，不能添加泛型规定的类型及其子类类型以外的对象，否则会报错！
		//courses.add("能否添加一些奇怪的东西?");
		Course cr2=new Course("2","Java基础");
		courses.add(cr2);
	}
	
	/*
	 * 测试循环遍历
	 */
	public void testForeach() {
		for(Course cr:courses) {
			System.out.println(cr.id+":"+cr.name);
		}
	}
 
    /*
	 * 泛型集合可以添加泛型的子类型的对象实例
	 */
	public void testChild() {
		ChildCourse ccr=new ChildCourse();
		ccr.id="3";
		ccr.name="我是子类型的课程对象实例~";
		courses.add(ccr);
	}
 
 
    /*
	 * 泛型不能使用基本类型
	 */
	public void testBasicType() {
		List<Integer>list=new ArrayList<Integer>();
		list.add(1);
		System.out.println("基本类型必须使用包装类作为泛型！"+list.get(0));
	}
	
	
	public static void main(String[] args) {
		TestGeneric tg=new TestGeneric();
		tg.testAdd();
		tg.testForeach();
        tg.testChild();
		tg.testForeach();
		tg.testBasicType();
		
	}
}

运行结果：

Set接口及其实现类

 

1. Set是元素无序并且不可以重复的集合，被称为集合
2. HashSet——哈希集，是Set的一个重要实现类 
3. Set中，添加某个对象，无论添加多少次， 最终只会保留一个该对象（的引用）， 并且保留的是第一次添加的那个

代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class SetTest {
	
	public List<Course>coursesToSelect;
	
	public SetTest() {
		coursesToSelect=new ArrayList<Course>();
	}
			
		public void testAdd() {
		Course cr1=new Course("1","数据结构");
		coursesToSelect.add(cr1);
		Course temp=(Course)coursesToSelect.get(0);
		
		
		Course cr2=new Course("2","C语言");
		coursesToSelect.add(0,cr2);
		Course temp2=(Course)coursesToSelect.get(0);
		
 
		
		
		Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};
		coursesToSelect.addAll(Arrays.asList(course));
		Course temp3=(Course)coursesToSelect.get(2);
		Course temp4=(Course)coursesToSelect.get(3);
		System.out.println("添加了课程："+temp3.id+":"+temp3.name+";"
		+temp4.id+":"+temp4.name);
		
		Course[] course2={new Course("5","高等数学"),new Course("6","大学英语")};
		coursesToSelect.addAll(2,Arrays.asList(course2));
		Course temp5=(Course)coursesToSelect.get(2);
		Course temp6=(Course)coursesToSelect.get(3);
		
	}
	
 
	/*
	 * 通过foreach方法访问集合元素
	 */
	public void testForeach() {
		System.out.println("有如下课程待选(通过foreach访问)：");
		for(Object obj:coursesToSelect) {
			Course cr=(Course)obj;
			System.out.println("课程："+cr.id+":"+cr.name);
		}
	}
	
 
	public static void main(String[] args) {
		SetTest st=new SetTest();
		st.testAdd();
		st.testForeach();
		//创建一个学生对象
		Student student=new Student("1","小明");
		System.out.println("欢迎学生："+student.name+"选课！");
		//创建一个Scanner对象，用来接受从键盘输入的课程ID
		Scanner console=new Scanner(System.in);
		
		for(int i=0;i<3;i++) {
			System.out.println("请输入课程ID");
			String courseId=console.next();
			for(Course cr:st.coursesToSelect) {
				if(cr.id.equals(courseId)) {
					student.courses.add(cr);
					/*
					 * Set中，添加某个对象，无论添加多少次
					 * 最终只会保留一个该对象（的引用）
					 * 并且，保留的是第一次添加的那个
					 */
				}
			}
		}
	
		st.testForeachSet(student);
	}
	
	public void testForeachSet(Student student) {
	//打印出输出，学生所选课程！
	for(Course cr:student.courses) {
		System.out.println("选择了课程："+cr.id+":"+cr.name);
	}
 
	}
}

运行结果：

Map&HashMap

Map接口

• Map提供了一种映射关系，其中的元素是以键值对(key-value)的形式存储的，能够实现根据key快速查找value
• Map中的键值对以Entry类型的对象实例形式存在
• 键（key值）不可以重复，value值可以
• 每个键最多只能映射到一个值
• Map接口提供了分别返回key值集合、value值集合以及Entry(j键值对）集合的方法
• Map支持泛型，形式如：Map<K,V>
   

HashMap

• HashMap是Map的一个重要实现类，也是最常用的，基于哈希表实现
• HashMap中的Entry对象是无序排列的
• key值和value值都可以为null，但是一个HashMap只能有一个key值为null的映射（key值不可重复）

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
 
public class MapTest {
	
	/*用来承装学生类型对象
	 * 
	 */
	public Map<String,Student>students;
	public Student newStudent;
	
	/*
	 * 构造器中初始化student属性
	 */
	public MapTest() {
		this.students=new HashMap<String,Student>();
	}
	
	/*
	 * 测试添加：输入学生ID，判断是否被占用
	 * 若未被占用，则输入姓名，创建新学生，并且
	 * 添加到student中
	 */
	public void testPut() {
		//创建一个Scanner对象，用来获取输入的学生ID和姓名
		Scanner console=new Scanner(System.in);
		int i=0;
		while(i<3) {
			System.out.println("请输入学生ID：");
			String ID=console.next();
			//判断该ID是否被占用
			Student st=students.get(ID);
			if(st==null) {
			//提示输入学生姓名
			System.out.println("请输入学生姓名：");
			String name=console.next();
			//创建新的学生对象
			Student newStuent=new Student(ID,name);
			//通过调用students的put方法，添加ID-学生映射
			students.put(ID,newStudent);
			System.out.println("成功添加学生："+students.get(ID).name);
			i++;		
			}else {
				System.out.println("该学生ID已被占用！");
				continue;
			}
		}
	}
	
	/*
	 * 测试Map的keySet方法
	 */
	public void testKeySet() {
	//通过keySet方法，返回Map中的所有"键”的Set集合
	Set<String>keySet=students.keySet();
	//取得students的容量
	System.out.println("总共有："+students.size()+"个学生！");
	//
 
	//遍历keySet,取得每一个键，再调用get方法取得每个键对应的value
	for(String stuId:keySet) {
		Student st=students.get(stuId);
		if(st!=null)
			System.out.println("学生："+st.name);
	}
	}
	
	/*
	 * 测试删除Map中的映射
	 */
	public void testRemove() {
		//提示输入待删除的学生的ID
		System.out.println("请输入要删除的学生ID！");
		//获取从键盘输入的待删除学生ID字符串
		Scanner console=new Scanner(System.in);
		while(true) {
		//提示输入待删除的学生的ID
		System.out.println("请输入要删除的学生ID！");
		String ID=console.next();
		//判断该ID是否有对应的学生对象
		Student st=students.get(ID);
		if(st==null) {
			//提示输入的ID并不存在
			System.out.println("该ID不存在");
			continue;
		}
		students.remove(ID);
		System.out.println("成功删除学生："+st.name);
		break;
		}		
	}
	
	/*
	 * 通过entrySet方法来遍历Map
	 */
	public void testEntrySet() {
		//通过entrySet方法，返回Map中的所有键值对
		Set<Entry<String,Student>>entrySet=students.entrySet();
		for(Entry<String,Student>entry:entrySey());
		System.out.println("取得键："+entry.getKey());
		System.out.println("对应的值为："+entry.getValue());
	}
 
	/*
	 * 利用put方法修改Map中的已有映射
	 */
	public void testModify() {
		//提示输入要修改的学生ID
		System.out.println("请输入要修改的学生ID：");
		//创建一个Scanner对象，去获取从键盘输入的学生ID字符串
		Scanner console=new Scanner(System.in);
		while(true) {
		//提示输入待删除的学生的ID
		String ID=console.next();
		//判断该ID是否有对应的学生对象
		Student student=students.get(ID);
		if(student==null) {
			//提示输入的ID并不存在
			System.out.println("该ID不存在！请重新输入！");
			continue;
		}
		//提示当前对应的学生对象的姓名
		System.out.println("当前该学生ID，所对应的学生为："+student.name);
		String name=console.next();
		Student newStudent=new Student(stuID,name);
		students.put(stuID, newStudent);
		System.out.println("修改成功！");
		break;
		
		}
	}
	public static void main(String[] args) {
		MapTest mt=new MapTest();
		mt.testPut();
		mt.testKeySet();
		mt.testRemove();
		mt.testEntrySet();
		mt.testModify();
		mt.testEntrySet();
		
	}
}

判断List中课程是否存在 

判断Set中课程是否存在

判断Map中是否包含某个key值或者某个value值

 

Collections工具类 

      Collections工具类是 Java集合框架中，用来操作集合对象的工具类，也是Java集合框架的成员

sort()(排序）方法

代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
 
/*
 * 将要完成：
 * 1、通过Collections.sort()方法，对Integer泛型的List进行排序；
 * 2、对String泛型的List进行排序；
 * 3、对其他类型泛型的List进序，以Student为例。
 */
public class CollectionsTest {
 
	/*
	 * 1、通过Collections.sort()方法，对Integer泛型的List进行排序；
	 * 创建一个Integer泛型的List,插入十个100以内的不重复随机整数，
	 * 调用Collections.sort()方法对其进行排序
	 */
	public void testSort1() {
		List<Integer>integerList=new ArrayList<Integer>();
		//插入十个1001以内的不重复随机数
		Random random=new Random();
		Integer k;
		for(int i=0;i<10;i++) {
			do {
			k=random.nextInt(100);
		}while(integerList.contains(k));
			integerList.add(k);
			System.out.println("成功添加整数："+k);
		}
		System.out.println("-------排序前-------");
		for(Integer integer:integerList) {
			System.out.println("元素："+integer);
		}
		Collections.sort(integerList);
		System.out.println("-------排序后-------");
		for(Integer integer:integerList) {
		System.out.println("元素："+integer);
	}
	}
	
	/*
	 * 2、对String泛型的List进行排序；
	 * 创建String泛型List,添加三个乱序的String元素，
	 * 调用sort方法，再次输出排序后的顺序
	 */
	public void testSort2() {
		List<String>stringList=new ArrayList<String>();
		stringList.add("microsoft");
		stringList.add("google");
		stringList.add("lenovo");
		System.out.println("------排序前------");
		for(String string:stringList) {
			System.out.println("元素："+string);
		}
		Collections.sort(stringList);
		System.out.println("------排序后------");
		for(String string:stringList) {
			System.out.println("元素："+string);
		
		}	
	}
	public static void main(String[] args) {
	CollectionsTest ct=new CollectionsTest();
	ct.testSort1();
	ct.testSort2();
	}
}

运行结果：

 Comparable接口——可比较的

• 实现该接口表示：这个类的实例可以比较大小，可以进行自然排序
• 定义了默认的比较规则
• 其实现实需要实现compara To()方法
• compara To()方法返回正数表示大，负数表示小，0表示相等

Comparator接口——比较工具接口

• 用于定于临时比较规则，而不是默认比较规则
• 其实现类需要实现compara ()方法
•  Comparator和Comparable都是Java集合框架的成员