第十七次 Java作业使用Java集合完成学生选课系统

目录

1.Java中的集合框架概述

​编辑 2.学生选课

3.泛型

4.通过Set集合管理课程

5.Map和HashMap简介

6.判断List中课程是否存在

 7.判断Set中课程是否存在

8.获取List中课程的位置

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

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

11.尝试对学生序列排序

12.Comparable和Comparator简介

 13.实行学生序列排序

---

1.Java中的集合框架概述

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

        集合的作用：在类的内部，对数据进行组织； 简而快速的搜索查找其中的某一条元素； 有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关的元素； 有的集合接口，提供了映射关系，可以通过关键字(key)去快速查找到对应的唯一对象，而这个关键字可以使任意类型。

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

Java集合框架体系结构 Collection Map
List(元素排列有序，可重复：序列)-ArrayList(数组序列)
Queue(有序，可重复，不常用：队列)LinkedList(链表)（也属List）
Set(无序，不可重复：集)HashSet(哈希集)
Map接口:----<key,value>----HashMap(哈希表)
在Map的内部会以<key,value>两个对象，一个映射去存储数据。这个映射是Entry类（键值对）的实例
Entry类是Map类的内部类
ArrayList HashSet HashMap 最为常用

 2.学生选课

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

import java.util.Set;
import java.util.HashSet;
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();
	}
}
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<Course> 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 static void main( String[] args) {
		ListTest lt = new ListTest();
		lt.testAdd();
		lt.testForEach();
//		lt.testGet();
//		lt.testIterator();
//		lt.testForEach();
//		lt.testModify();
//		lt.testForEach();
//		lt.testRemove();
	}
}

 

3.泛型

1、规定List定义的容器只能存储某种类型的元素。

不用泛型的话是什么类型的元素都可以插入，因为插入集合是忽略其类型，把它看成为Object类型，取出时需要强行转换对应的类型。

2、如何声明

List<Course> courseToSelect;  

在构造方法中(实例化的时候也可以不在构造方法，直接实例就可以)

this.courseToSelect=new ArrayList<Course>();   

3、添加

泛型集合中，不能添加泛型规定的类型以及其子类型以外的对象，否则会报错。

4、遍历

用foreach存储变量是泛型的类型。

for(Course a:courseToSelect),不用Object取出再强转，因为已经规定容器里装的都是Course类型。

 总结关于list类型的一下用法：
1.创建对象

List list = new ArrayList();

2.向list对象中添加数据

（1）Course crre = new Course("1","数据结构");//一个类的对象
list.add(crre);//将对象添加到list中
（2）Course[] crre = {new Course("",""),new Course("","");//对象的数组
list.addAll(0,Arrays.asList(course));//切记Arrays.asList方法

3.获取集合中的元素

（1）Course temp = (Course)list.get(0);//注意强转
（2）Iterator it = list.iterator();
while(it.hasNext()){
Course cr = (Course)it.next();//迭代遍历，使用iterator方法
}
（3）for(Object obj:list){
Course cr = (Course)obj;
}//foreach方法 ，注意Object的使用

4.集合中参数的修改

list.set(2,new Course("",""));

5.集合中数据的删除

(1)list.remove(位置）;
(2)Course[] crr = {(Course)list.get(位置）(Course)list.get(位置）}；
list.removeAll(Arrays.asList(crr));

6.带有泛型的list

List<Course> course = new ArrayList<Course>();//相当于添加进去的元素有了具体类型，不再是Object

7.list可以添加子类型的对象
8.list不能直接添加基本类型（int,float等）的对象，如果要添加，需要使用其包装类

4.通过Set集合管理课程

Set接口及其实现类——HashSet
Set是元素无序并且不可以重复的集合，被称为集；
HashSet——哈希集，是Set的一个重要实现类。
1、Set没有像List中set()方法一样就修改，因为List是有序的，可以指定位置，而Set是无序的。
2、查询遍历时，Set不能用get()方法去获取，因为无序没有指定索引ID，但可以使用foreach和iterator来遍历，但是每次遍历出来可能顺序都不一样，还是因为无序造成的。
3、Set中的size(),add(),addAll(),remove(),removeAll()与List类似。
4、Set还可以添加null；

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

public class TestGeneric {
	public List<Course> coursesToSelect;
	public TestGeneric() {
		coursesToSelect = new ArrayList<Course>();
	}
	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) {
		TestGeneric st = new TestGeneric();
		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中，添加某个对象，无论添加多少次， 最终只会保留一个该对象（的引用）， 并且，保留的是第一次添加的那一个
					 */
					// 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.course) {
			System.out.println("选择了课程：" + cr.id + ":" + cr.name);
		}
	}
}

 

5.Map和HashMap简介

 Map接口 
1. Map接口提供了一中映射关系，其中的元素是键值对（key-value）的形式存储的，能够实现根据Key快速查找value。Key-value可以是任何对象，是以Entry类型的对象实例存在的。 
2.Key是不可以重复的，Value是可以重复的。Key-value都可以为null，不过只能有一个key是null。
3.map支持泛型，Map<K,V> 
4.每个键最多只能映射到一个值 
5.Map接口提供了分别返回key值集合、value值集合以及Entry（键值对）集合的方法
6.通过put<K key,V value>,remove<Object key>操作数据
7.HashMap中的Entry对象是无序排列的，HashMap是Map的一个重要实现类，也是最常用的，基于哈希表是实现

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

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<String, Student> students;
	    public MapTest() {
	        this.students = new HashMap<String, Student>();
	    }
	    public void testPut() {
	        // 创建一个Scanner对象，用来获取输入的学生ID和姓名