使用Java集合完成学生选课系统

使用Java集合完成学生选课系统集合框架

概念与作用、体系结构、实际应用

集合概述集合的概念

现实生活中：很多的事物凑在一起
数学中的集合：具有共同属性的事物的总体
Java中的集合类：是一种工具类，就像是容器，储存任意数量的具有共同属性的对象

集合的作用

在类的内部，对数据进行组织;

简单而快速的搜索大数量的条目;
有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关元素;
有的集合接口，提供了映射关系，可以以通过关键字(key)去快速查找到对应的唯一对象，而这个关键字可以是任意类型。

与数组的对比——为何选择集合而不是数组
数组的长度固定，集合长度可变
数组只能通过下标访问元素，类型固同定，而有的集合可以通过任意类型查找所映射的具体对象

Java集合框架体系结构

Collection接口 &List接口简介

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

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

List接口及其实现类--ArrayLi st
List是元素有序并且可以重复的的集合，被称为序列
List可以精确的控制每个元素的的插入位置，或删除某个位置元素

ArrayList--数组序列，是L ist的一个重要实现类

ArrayList底层是由数组实现的

创建学生类和课程类：

package com.imooc.collection;
 
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 com.imooc.collection;
 

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

添加课程、查询课程、课程修改、课程删除：

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
 

public class ListTest {
 
	
	public List coursesToSelect;
	
	public ListTest() {
		this.coursesToSelect = new ArrayList();
	}
	
	
	public void testAdd() {
		//创建一个课程对象，并通过调用add方法，添加到备选课程List中
		Course cr1 = new Course("1" , "数据结构");
		coursesToSelect.add(cr1);
		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(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 void testGet() {
		int size = coursesToSelect.size();
		System.out.println("有如下课程待选：");
		for(int i= 0 ; i < size; i++) {
			Course cr = (Course) coursesToSelect.get(i);
			System.out.println("课程：" + cr.id + ":" + cr.name);
		}
	}
	
	
	public void testIterator() {
		//通过集合的iterator方法，取得迭代器的实例
		Iterator it = coursesToSelect.iterator();
		System.out.println("有如下课程待选(通过迭代器访问)：");
		while(it.hasNext()) {
			Course cr = it.next();
			System.out.println("课程：" + cr.id + ":" + cr.name);
		}
	}
	
	
	public void testForEach() {
		System.out.println("有如下课程待选(通过for each访问)：");
		for (Object obj : coursesToSelect) {
			Course cr = (Course) obj;
			System.out.println("课程：" + cr.id + ":" + cr.name);
		}
	}
	
	
	public void testModify() {
		coursesToSelect.set(4, new Course("7", "毛概"));
	}
	
	
	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 void testType() {
		System.out.println("能否往List中添加一些奇怪的东西呢！？");
		coursesToSelect.add("我不是课程，我只是一个无辜的字符串！！");
	}
	
	public static void main( String[] args) {
		ListTest lt = new ListTest();
		lt.testAdd();
		lt.testType();
		lt.testForEach();
//		lt.testGet();
//		lt.testIterator();
//		lt.testForEach();
//		lt.testModify();
//		lt.testForEach();
//		lt.testRemove();
	}
}

运行结果：

应用泛型管理课程：

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class SetTest {
 
	public List coursesToSelect;
 
	public SetTest() {
		coursesToSelect = new ArrayList();
	}
 
	
	public void testAdd() {
		// 创建一个课程对象，并通过调用add方法，添加到备选课程List中
		Course cr1 = new Course("1", "数据结构");
		coursesToSelect.add(cr1);
		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(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 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) {
		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);
					
					// student.courses.add(null);
					student.courses.add(cr);
				}
			}
		}
		st.testForEachForSet(student);
	}
 
	public void testForEachForSet(Student student) {
		// 打印输出，学生所选的课程！
		System.out.println("共选择了：" + student.courses.size() + "门课程！");
		for (Course cr : student.courses) {
			System.out.println("选择了课程：" + cr.id + ":" + cr.name);
		}
	}
 
}

ChildCourse 类继承 Course类：

package com.imooc.collection;
 
public class ChildCourse extends Course {
 
}

运行结果：

通过Set集合管理课程：

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.List;
 
public class TestGeneric {
 
	
	public List courses;
	
	public TestGeneric() {
		this.courses = new ArrayList();
	}
	
	
	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 list = new ArrayList();
		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();
	}
 
}

运行结果：

Map和HashMap简介

Map接口：
Map提供了一种映射关系，其中的元素是以键值对(key-value)的形式存储的，能够实现根据key快速查找value

Map中的键值对以Entry类型的对象实例形式存在

键(key值)不可重复，value值可以

每个键最多只能映射到一个值

Map接口提供了分别返回key值集合、value值集合以及Entry(键值对)集合的方法
Map支持泛型，形式如:Map

HashMap类

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

案例功能说明

通过Map进行学生信息管理其中key为学生ID，value为学生对象
通过键盘输入学生信息
对集合中的学生信息进行增、删、改、查操作

使用Map添加学生：

package com.imooc.collection;
 
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
 
public class MapTest {
 
	
	public Map students;
	
	
	public MapTest() {
		this.students = new HashMap();
	}
	
	
	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 newStudent = 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;
			}
		}
	}
	
	
	public void testKeySet() {
		// 通过keySet方法，返回Map中的所有“键”的Set集合
		Set 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);
		}
	}
	
	
	public void testEntrySet() {
		// 通过entrySet方法，返回Map中的所有键值对
		Set> entrySet = students.entrySet();
		for (Entry entry : entrySet) {
			System.out.println("取得键：" + entry.getKey());
			System.out.println("对应的值为：" + entry.getValue().name);
		}
	}
	
	
	public static void main(String[] args) {
		MapTest mt = new MapTest();
		mt.testPut();
		mt.testKeySet();
//		mt.testRemove();
//		mt.testEntrySet();
//		mt.testModify();
//		mt.testEntrySet();
//		mt.testContainsKeyOrValue();
	}
 
}

运行结果：

使用Map删除中的学生

删除学生：

package com.imooc.collection;
 
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
 
public class MapTest {
 
	
	public Map students;
	
	
	public MapTest() {
		this.students = new HashMap();
	}
	
	
	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 newStudent = 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;
			}
		}
	}
	
	
	public void testKeySet() {
		// 通过keySet方法，返回Map中的所有“键”的Set集合
		Set 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);
		}
	}
	
	
	public void testRemove() {
		// 获取从键盘输入的待删除学生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;
		}
	}
	
	
	public void testEntrySet() {
		// 通过entrySet方法，返回Map中的所有键值对
		Set> entrySet = students.entrySet();
		for (Entry entry : entrySet) {
			System.out.println("取得键：" + entry.getKey());
			System.out.println("对应的值为：" + entry.getValue().name);
		}
	}
	
	
	public static void main(String[] args) {
		MapTest mt = new MapTest();
		mt.testPut();
		mt.testKeySet();
		mt.testRemove();
//		mt.testEntrySet();
//		mt.testModify();
//		mt.testEntrySet();
//		mt.testContainsKeyOrValue();//
	}
 
}

运行结果：

修改Map中的学生

测试、修改学生：

package com.imooc.collection;
 
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
 
public class MapTest {
 
	
	public Map students;
	
	
	public MapTest() {
		this.students = new HashMap();
	}
	
	
	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 newStudent = 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;
			}
		}
	}
	
	
	public void testKeySet() {
		// 通过keySet方法，返回Map中的所有“键”的Set集合
		Set 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);
		}
	}
	
	
	public void testRemove() {
		// 获取从键盘输入的待删除学生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;
		}
	}
	
	
	public void testEntrySet() {
		// 通过entrySet方法，返回Map中的所有键值对
		Set> entrySet = students.entrySet();
		for (Entry entry : entrySet) {
			System.out.println("取得键：" + entry.getKey());
			System.out.println("对应的值为：" + entry.getValue().name);
		}
	}
	
	
	public void testModify() {
		// 提示输入要修改的学生ID
		System.out.println("请输入要修改的学生ID：");
		// 创建一个Scanner对象，去获取从键盘上输入的学生ID字符串
		Scanner console = new Scanner(System.in);
		while (true) {
			// 取得从键盘输入的学生ID
			String stuID = console.next();
			// 从students中查找该学生ID对应的学生对象
			Student student = students.get(stuID);
			if (student == null) {
				System.out.println("该ID不存在！请重新输入！");
				continue;
			}
			// 提示当前对应的学生对象的姓名
			System.out.println("当前该学生ID，所对应的学生为：" + student.name);
			// 提示输入新的学生姓名，来修改已有的映射
			System.out.println("请输入新的学生姓名：");
			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中课程是否存在

判断List中课程是否存在 :

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class SetTest {
 
	public List coursesToSelect;
	
	private Scanner console;
	
	public Student student;
	
	public SetTest() {
		coursesToSelect = new ArrayList();
		console = new Scanner(System.in);
	}
	
	
	public void testAdd() {
		//创建一个课程对象，并通过调用add方法，添加到备选课程List中
		Course cr1 = new Course("1" , "数据结构");
		coursesToSelect.add(cr1);
		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(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 void testForEach() {
		System.out.println("有如下课程待选(通过for each访问)：");
		for (Object obj : coursesToSelect) {
			Course cr = (Course) obj;
			System.out.println("课程：" + cr.id + ":" + cr.name);
		}
	}
	
	
	public void testListContains() {
		// 取得备选课程序列的第0个元素
		Course course = coursesToSelect.get(0);
		// 打印输出coursesToSelected是否包含course对象
		System.out.println("取得课程：" + course.name);
		System.out.println("备选课程中是否包含课程：" + course.name + ", " + 
				coursesToSelect.contains(course));
		// 提示输入课程名称
		System.out.println("请输入课程名称：");
		String name = console.next();
		// 创建一个新的课程对象，ID和名称，与course对象完全一样
		Course course2 = new Course();
		course2.name = name;
		System.out.println("新创建课程：" + course2.name);
		System.out.println("备选课程中是否包含课程：" + course2.name + ", " +
				coursesToSelect.contains(course2));
		// 通过indexOf方法来取得某元素的索引位置
		if (coursesToSelect.contains(course2))
			System.out.println("课程：" + course2.name + "的索引位置为：" + 
					coursesToSelect.indexOf(course2));
	}
	
	
	public static void main(String[] args) {
		SetTest st = new SetTest();
		st.testAdd();
		st.testListContains();
		st.testForEach();
 
 
	}
	
}

运行结果：

判断set中课程是否存在

判断set中课程是否存在 :

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class SetTest {
 
	public List coursesToSelect;
	
	private Scanner console;
	
	public Student student;
	
	public SetTest() {
		coursesToSelect = new ArrayList();
		console = new Scanner(System.in);
	}
	
	
	public void testAdd() {
		//创建一个课程对象，并通过调用add方法，添加到备选课程List中
		Course cr1 = new Course("1" , "数据结构");
		coursesToSelect.add(cr1);
		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(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 void testForEach() {
		System.out.println("有如下课程待选(通过for each访问)：");
		for (Object obj : coursesToSelect) {
			Course cr = (Course) obj;
			System.out.println("课程：" + cr.id + ":" + cr.name);
		}
	}
	
	
	public void testListContains() {
		// 取得备选课程序列的第0个元素
		Course course = coursesToSelect.get(0);
		// 打印输出coursesToSelected是否包含course对象
		System.out.println("取得课程：" + course.name);
		System.out.println("备选课程中是否包含课程：" + course.name + ", " + 
				coursesToSelect.contains(course));
		// 提示输入课程名称
		System.out.println("请输入课程名称：");
		String name = console.next();
		// 创建一个新的课程对象，ID和名称，与course对象完全一样
		Course course2 = new Course();
		course2.name = name;
		System.out.println("新创建课程：" + course2.name);
		System.out.println("备选课程中是否包含课程：" + course2.name + ", " +
				coursesToSelect.contains(course2));
		
	}
	
	
	public void testSetContains() {
		// 提示输入课程名称
		System.out.println("请输入学生已选的课程名称：");
		String name = console.next();
		// 创建一个新的课程对象，ID和名称，与course对象完全一样
		Course course2 = new Course();
		course2.name = name;
		System.out.println("新创建课程：" + course2.name);
		System.out.println("备选课程中是否包含课程：" + course2.name + ", " +
				student.courses.contains(course2));
	}
	
// 创建学生对象并选课
	public void createStudentAndSelectCours() {
		//创建一个学生对象
		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 : coursesToSelect) {
				if(cr.id.equals(courseId)) {
					student.courses.add(cr);
					
//					student.courses.add(null);
//					student.courses.add(cr);
				}
			}
		}
	}
 
	
	public static void main(String[] args) {
		SetTest st = new SetTest();
		st.testAdd();
//		st.testListContains();
		st.testForEach();
 
        st.createStudentAndSelectCours();
		st.testSetContains();
		
//		st.testForEachForSet(student);
	}
 
	public void testForEachForSet(Student student) {
		//打印输出，学生所选的课程！
		System.out.println("共选择了：" + student.courses.size() + "门课程！");
		for (Course cr : student.courses) {
			System.out.println("选择了课程：" + cr.id + ":" + cr.name);
		}
	}
	
}

运行结果：

获取List中课程的位置

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class SetTest {
 
	public List coursesToSelect;
	
	private Scanner console;
	
	public Student student;
	
	public SetTest() {
		coursesToSelect = new ArrayList();
		console = new Scanner(System.in);
	}
	
	
	public void testAdd() {
		//创建一个课程对象，并通过调用add方法，添加到备选课程List中
		Course cr1 = new Course("1" , "数据结构");
		coursesToSelect.add(cr1);
		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(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 void testForEach() {
		System.out.println("有如下课程待选(通过for each访问)：");
		for (Object obj : coursesToSelect) {
			Course cr = (Course) obj;
			System.out.println("课程：" + cr.id + ":" + cr.name);
		}
	}
	
	
	public void testListContains() {
		// 取得备选课程序列的第0个元素
		Course course = coursesToSelect.get(0);
		// 打印输出coursesToSelected是否包含course对象
		System.out.println("取得课程：" + course.name);
		System.out.println("备选课程中是否包含课程：" + course.name + ", " + 
				coursesToSelect.contains(course));
		// 提示输入课程名称
		System.out.println("请输入课程名称：");
		String name = console.next();
		// 创建一个新的课程对象，ID和名称，与course对象完全一样
		Course course2 = new Course();
		course2.name = name;
		System.out.println("新创建课程：" + course2.name);
		System.out.println("备选课程中是否包含课程：" + course2.name + ", " +
				coursesToSelect.contains(course2));
		// 通过indexOf方法来取得某元素的索引位置
		if (coursesToSelect.contains(course2))
			System.out.println("课程：" + course2.name + "的索引位置为：" + 
					coursesToSelect.indexOf(course2));
	}
	
	// 创建学生对象并选课
	public void createStudentAndSelectCours() {
		//创建一个学生对象
		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 : coursesToSelect) {
				if(cr.id.equals(courseId)) {
					student.courses.add(cr);
					
//					student.courses.add(null);
//					student.courses.add(cr);
				}
			}
		}
	}
	
	
	public void testSetContains() {
		// 提示输入课程名称
		System.out.println("请输入学生已选的课程名称：");
		String name = console.next();
		// 创建一个新的课程对象，ID和名称，与course对象完全一样
		Course course2 = new Course();
		course2.name = name;
		System.out.println("新创建课程：" + course2.name);
		System.out.println("备选课程中是否包含课程：" + course2.name + ", " +
				student.courses.contains(course2));
	}
	
	
	public static void main(String[] args) {
		SetTest st = new SetTest();
		st.testAdd();
		st.testListContains();
		st.testForEach();
 
//		st.createStudentAndSelectCours();
//		st.testSetContains();
 
//		st.testForEachForSet(student);
	}
 
	public void testForEachForSet(Student student) {
		//打印输出，学生所选的课程！
		System.out.println("共选择了：" + student.courses.size() + "门课程！");
		for (Course cr : student.courses) {
			System.out.println("选择了课程：" + cr.id + ":" + cr.name);
		}
	}
	
}

运行结果：

判断 Map 中是否包含指定的 key 和value

package com.imooc.collection;
 
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
 
public class MapTest {
 
	
	public Map students;
	
	
	public MapTest() {
		this.students = new HashMap();
	}
	
	
	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 newStudent = 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;
			}
		}
	}
	
	
	public void testKeySet() {
		// 通过keySet方法，返回Map中的所有“键”的Set集合
		Set 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);
		}
	}
	
	
	public void testRemove() {
		// 获取从键盘输入的待删除学生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;
		}
	}
	
	
	public void testEntrySet() {
		// 通过entrySet方法，返回Map中的所有键值对
		Set> entrySet = students.entrySet();
		for (Entry entry : entrySet) {
			System.out.println("取得键：" + entry.getKey());
			System.out.println("对应的值为：" + entry.getValue().name);
		}
	}
	
	
	public void testModify() {
		// 提示输入要修改的学生ID
		System.out.println("请输入要修改的学生ID：");
		// 创建一个Scanner对象，去获取从键盘上输入的学生ID字符串
		Scanner console = new Scanner(System.in);
		while (true) {
			// 取得从键盘输入的学生ID
			String stuID = console.next();
			// 从students中查找该学生ID对应的学生对象
			Student student = students.get(stuID);
			if (student == null) {
				System.out.println("该ID不存在！请重新输入！");
				continue;
			}
			// 提示当前对应的学生对象的姓名
			System.out.println("当前该学生ID，所对应的学生为：" + student.name);
			// 提示输入新的学生姓名，来修改已有的映射
			System.out.println("请输入新的学生姓名：");
			String name = console.next();
			Student newStudent = new Student(stuID, name);
			students.put(stuID, newStudent);
			System.out.println("修改成功！");
			break;
		}
	}
	
	
	public void testContainsKeyOrValue() {
		// 提示输入学生id
		System.out.println("请输入要查询的学生ID：");
		Scanner console = new Scanner(System.in);
		String id = console.next();
		// 在Map中，用containsKey()方法，来判断是否包含某个Key值
		System.out.println("您输入的学生ID为：" + id + "，在学生映射表中是否存在："
				+ students.containsKey(id));
		if (students.containsKey(id))
			System.out.println("对应的学生为：" + students.get(id).name);
		// 提示输入学生姓名
		System.out.println("请输入要查询的学生姓名：");
		String name = console.next();
		// 用containsValue()方法，来判断是否包含某个Value值
		if (students.containsValue(new Student(null,name)))
			System.out.println("在学生映射表中，确实包含学生：" + name);
		else
			System.out.println("在学生映射表中不存在该学生！");
	}
	
	
	public static void main(String[] args) {	//主方法
		MapTest mt = new MapTest();
		mt.testPut();	//输入学生ID，判断是否被占用,若未被占用，则输入姓名，创建新学生对象，并且添加到students中
		mt.testKeySet();	//测试Map的keySet方法
//		mt.testRemove();	//测试删除Map中的映射
//		mt.testEntrySet();	//通过entrySet方法来遍历Map
//		mt.testModify();	//利用put方法修改Map中的已有映射
//		mt.testEntrySet();	//通过entrySet方法来遍历Map
		mt.testContainsKeyOrValue();	//测试Map中，是否包含某个Key值或者某个Value值
	}
 
}

运行结果：

应用Collections.sort()实现 List排序

通过Collections.sort()方法，对Integer泛型的List进行排序

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
 

public class CollectionsTest {
 
	
	public void testSort1() {
		List integerList = new ArrayList();
		// 插入十个100以内的不重复随机整数
		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);
		}
	}
	
	
	public static void main(String[] args) {
		CollectionsTest ct = new CollectionsTest();
		ct.testSort1();
	}
 
}

运行结果：

创建String泛型的List，添加三个乱序的String元素，调用sort方法，再次输出排序后的顺序

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
 

public class CollectionsTest {
 
	
	public void testSort1() {
		List integerList = new ArrayList();
		// 插入十个100以内的不重复随机整数
		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);
		}
	}
	
	
	public void testSort2() {
		List stringList = new ArrayList();
		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和Comparator简介

Comparable接口——可比较的
实现该接口表示:这个类的实例可以比较大小，可以进行自然排序

定义了默认的比较规则
其实现类需实现compareTo()方法
compareTo()方法返回正数表示大，负数表示小，0表示相等

Comparator接口——比较工具接口
        用于定义临时比较规则，而不是默认人比较规则

        其实现类需要实现compare()方法
        Comparator和Comparable都是J ava集合框架的成员

实行学生序列排序

创建StudentComparator类，实现Comparator接口：

package com.imooc.collection;
 
import java.util.Comparator;
 
public class StudentComparator implements Comparator {
 
	@Override
	public int compare(Student o1, Student o2) {
		// TODO Auto-generated method stub
		return o1.name.compareTo(o2.name);
	}
 
}

对其他类型泛型的List进行排序，以Student为例。

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
 

public class CollectionsTest {
 
	
	public void testSort1() {
		List integerList = new ArrayList();
		// 插入十个100以内的不重复随机整数
		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);
		}
	}
	
	
	public void testSort2() {
		List stringList = new ArrayList();
		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 void testSort3() {
		List studentList = new ArrayList();
		Random random = new Random();
		studentList.add(new Student(random.nextInt(1000) + "", "Mike"));
		studentList.add(new Student(random.nextInt(1000) + "", "Angela"));
		studentList.add(new Student(random.nextInt(1000) + "", "Lucy"));
		studentList.add(new Student(10000 + "", "Beyonce"));
		System.out.println("--------------排序前---------------");
		for (Student student : studentList) {
			System.out.println("学生：" + student.id + ":" + student.name);
		}
		Collections.sort(studentList);
		System.out.println("----------------排序后------------------");
		for (Student student : studentList) {
			System.out.println("学生：" + student.id + ":" + student.name);
		}
		Collections.sort(studentList, new StudentComparator());
		System.out.println("----------------按照姓名排序后-----------------");
		for (Student student : studentList) {
			System.out.println("学生：" + student.id + ":" + student.name);
		}
	}
	
	
	public static void main(String[] args) {
		CollectionsTest ct = new CollectionsTest();
//		ct.testSort1();
//		ct.testSort2();
		ct.testSort3();
	}
 
}

运行结果：

使用Java集合完成学生选课系统

Java相关栏目本月热门文章