使用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;
/**
* 学生类
* @author Administrator
*
*/
public class Student {
public String id;
public String name;
public Set<Course> courses;
public Student(String id, String name) {
this.id = id;
this.name = name;
this.courses = new HashSet<Course>();
}
}package com.imooc.collection;
/**
* 课程类
* @author Administrator
*
*/
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;
/**
* 备选课程类
* @author Administrator
*
*/
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);
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);
}
/**
* 取得List中的元素的方法
* @param args
*/
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);
}
}
/**
* 通过迭代器来遍历List
* @param args
*/
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);
}
}
/**
* 通过for each方法访问集合元素
* @param args
*/
public void testForEach() {
System.out.println("有如下课程待选(通过for each访问)：");
for (Object obj : coursesToSelect) {
Course cr = (Course) obj;
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
/**
* 修改List中的元素
* @param args
*/
public void testModify() {
coursesToSelect.set(4, new Course("7", "毛概"));
}
/**
* 删除List中的元素
* @param args
*/
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();
}
/**
* 往List中添加一些奇怪的东西
* @param args
*/
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<Course> coursesToSelect;
public SetTest() {
coursesToSelect = new ArrayList<Course>();
}
/**
* 用于往coursesToSelect中添加备选课程
*/
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);
}
/**
* 通过for each方法访问集合元素
*
* @param args
*/
public void testForEach() {
System.out.println("有如下课程待选(通过for each访问)：");
for (Object obj : coursesToSelect) {
Course cr = (Course) obj;
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
/**
* @param args
*/
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中，添加某个对象，无论添加多少次， 最终只会保留一个该对象（的引用）， 并且，保留的是第一次添加的那一个
*/
// 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 {
/**
* 带有泛型——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));
}
/**
* @param args
*/
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快速查找valueMap中的键值对以Entry类型的对象实例形式存在
键(key值)不可重复，value值可以
每个键最多只能映射到一个值
Map接口提供了分别返回key值集合、value值集合以及Entry(键值对)集合的方法
Map支持泛型，形式如:Map<KV>
HashMap类
HashMap是Map的一个重要实现类，也是最常用的，基于哈希表实现
HashMap中的Entry对象是无序排列的
Key值和value值都可以为null，但是一个HashMap只能有一个 key值为null的映射(key值不可重复)
案例功能说明
通过Map<String,Student>进行学生信息管理其中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<String, Student> students;
/**
* 在构造器中初始化students属性
*/
public MapTest() {
this.students = new HashMap<String, Student>();
}
/**
* 测试添加：输入学生ID，判断是否被占用
* 若未被占用，则输入姓名，创建新学生对象，并且
* 添加到students中
*/
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;
}
}
}
/**
* 测试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);
}
}
/**
* 通过entrySet方法来遍历Map
*/
public void testEntrySet() {
// 通过entrySet方法，返回Map中的所有键值对
Set<Entry<String, Student>> entrySet = students.entrySet();
for (Entry<String, Student> entry : entrySet) {
System.out.println("取得键：" + entry.getKey());
System.out.println("对应的值为：" + entry.getValue().name);
}
}
/**
* @param args
*/
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<String, Student> students;
/**
* 在构造器中初始化students属性
*/
public MapTest() {
this.students = new HashMap<String, Student>();
}
/**
* 测试添加：输入学生ID，判断是否被占用
* 若未被占用，则输入姓名，创建新学生对象，并且
* 添加到students中
*/
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;
}
}
}
/**
* 测试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字符串
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 : entrySet) {
System.out.println("取得键：" + entry.getKey());
System.out.println("对应的值为：" + entry.getValue().name);
}
}
/**
* @param args
*/
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<String, Student> students;
/**
* 在构造器中初始化students属性
*/
public MapTest() {
this.students = new HashMap<String, Student>();
}
/**
* 测试添加：输入学生ID，判断是否被占用
* 若未被占用，则输入姓名，创建新学生对象，并且
* 添加到students中
*/
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;
}
}
}
/**
* 测试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字符串
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 : entrySet) {
System.out.println("取得键：" + entry.getKey());
System.out.println("对应的值为：" + entry.getValue().name);
}
}
/**
* 利用put方法修改Map中的已有映射
*/
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;
}
}
/**
* @param args
*/
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<Course> coursesToSelect;
private Scanner console;
public Student student;
public SetTest() {
coursesToSelect = new ArrayList<Course>();
console = new Scanner(System.in);
}
/**
* 用于往coursesToSelect中添加备选课程
*/
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);
}
/**
* 通过for each方法访问集合元素
* @param args
*/
public void testForEach() {
System.out.println("有如下课程待选(通过for each访问)：");
for (Object obj : coursesToSelect) {
Course cr = (Course) obj;
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
/**
* 测试List的contains方法
*/
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));
}
/**
* @param args
*/
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<Course> coursesToSelect;
private Scanner console;
public Student student;
public SetTest() {
coursesToSelect = new ArrayList<Course>();
console = new Scanner(System.in);
}
/**
* 用于往coursesToSelect中添加备选课程
*/
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);
}
/**
* 通过for each方法访问集合元素
* @param args
*/
public void testForEach() {
System.out.println("有如下课程待选(通过for each访问)：");
for (Object obj : coursesToSelect) {
Course cr = (Course) obj;
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
/**
* 测试List的contains方法
*/
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));
}
/**
* 测试Set的contains方法
*/
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);
/**
* Set中，添加某个对象，无论添加多少次，
* 最终只会保留一个该对象（的引用），
* 并且，保留的是第一次添加的那一个
*/
// student.courses.add(null);
// student.courses.add(cr);
}
}
}
}
/**
* @param args
*/
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<Course> coursesToSelect;
private Scanner console;
public Student student;
public SetTest() {
coursesToSelect = new ArrayList<Course>();
console = new Scanner(System.in);
}
/**
* 用于往coursesToSelect中添加备选课程
*/
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);
}
/**
* 通过for each方法访问集合元素
* @param args
*/
public void testForEach() {
System.out.println("有如下课程待选(通过for each访问)：");
for (Object obj : coursesToSelect) {
Course cr = (Course) obj;
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
/**
* 测试List的contains方法
*/
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);
/**
* Set中，添加某个对象，无论添加多少次，
* 最终只会保留一个该对象（的引用），
* 并且，保留的是第一次添加的那一个
*/
// student.courses.add(null);
// student.courses.add(cr);
}
}
}
}
/**
* 测试Set的contains方法
*/
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));
}
/**
* @param args
*/
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<String, Student> students;
/**
* 在构造器中初始化students属性
*/
public MapTest() {
this.students = new HashMap<String, Student>();
}
/**
* 测试添加：输入学生ID，判断是否被占用
* 若未被占用，则输入姓名，创建新学生对象，并且
* 添加到students中
*/
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;
}
}
}
/**
* 测试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字符串
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 : entrySet) {
System.out.println("取得键：" + entry.getKey());
System.out.println("对应的值为：" + entry.getValue().name);
}
}
/**
* 利用put方法修改Map中的已有映射
*/
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;
}
}
/**
* 测试Map中，是否包含某个Key值或者某个Value值
*/
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("在学生映射表中不存在该学生！");
}
/**
* @param args
*/
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;
/**
* 将要完成：
* 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>();
// 插入十个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);
}
}
/**
* @param args
*/
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;
/**
* 将要完成：
* 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>();
// 插入十个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);
}
}
/**
* 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);
}
}
/**
* @param args
*/
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<Student>接口：
package com.imooc.collection;
import java.util.Comparator;
public class StudentComparator implements Comparator<Student> {
@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;
/**
* 将要完成：
* 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>();
// 插入十个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);
}
}
/**
* 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);
}
}
/**
* 3.对其他类型泛型的List进行排序，以Student为例。
*/
public void testSort3() {
List<Student> studentList = new ArrayList<Student>();
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);
}
}
/**
* @param args
*/
public static void main(String[] args) {
CollectionsTest ct = new CollectionsTest();
// ct.testSort1();
// ct.testSort2();
ct.testSort3();
}
}运行结果：
779
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
