1、学生选课-判断List中课程是否存在
思考：
1、在课程序列中，如何判断是否包含某门课或者某几门课程？
2、如果课程序列包含某门课程，如何判断该课程的索引位置？
3、在学生映射表中，如何判断是否包含某个学生ID?
4、又该如何判断是否包含某个学生对象？
5、如果想把课程或者学生对象，按照课程名称或者学生姓名排序又该怎么办？按照ID排序呢？
在某序列中，如何判断是否包含某元素，list、set都是从collection接口中继承来的contains方法(还有判断多个元素的containsAll)
/**
* 测试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 static void main(String[] args) {
SetTest st = new SetTest();
st.testAdd();
st.testListContains();
}
Course.java
/*
* 重写某个类的equals方法的模板
*
*/
@Override
public boolean equals(Object obj) { //equals返回类型boolean
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Course))
return false;
Course other = (Course) obj; //
if (name == null) {
if (other.name == null)
return true;
else
return false;
}else{
if (name.equals(other.name))
return true;
else
return false;
}
}
2、学生选课-判断Set中课程是否存在
java中所有类都继承于object类，它定义了一个equals（Object obj)方法，这个方法需要一个参数,还定义了一个HashCode()方法，它返回的是哈希码
package student;
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);
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);
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);
}
/**
* 通过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);
}
}
// 创建学生对象并选课
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));
}
public static void main(String[] args) {
SetTest st = new SetTest();
st.testAdd();
st.testForEach();
st.createStudentAndSelectCours();
st.testSetContains();
}
package student;
/*
* 课程类
*/
public class Course {
public String id;
public String name;
public Course(String id, String name) {
this.id = id ;
this.name = name;
}
public Course(){
//否则ChildCourse会报错
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
}
3、学生选课-获取List中课程的位置
如果课程序列包含某门课程，如何判断该课程的索引位置
// 通过indexOf方法来取得某元素的索引位置
if (coursesToSelect.contains(course2))
System.out.println("课程：" + course2.name + "的索引位置为：" +
coursesToSelect.indexOf(course2));
4、学生选课-判断Map中是否包含指定的key和value
在学生映射列表中，如何判断是否包含某个学生的ID
又该如何判断是否包含某个学生对象
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中，是否包含某个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值
//这里需要重写student类的equals方法,否则映射表中不存在。。。
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();
mt.testKeySet();
mt.testContainsKeyOrValue();
}
5、应用Collections.sort()实现List排序
Arrays类--java.util.Arrays包含操作数组的各种静态方法
Collections工具类--java.util.Collections用来操作集合对象的工具类，也是Java集合框架的成员
Collections中定义了sort（）排序方法
package student;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
/*
* 将要完成：
* 1、通过Collections.sort()方法，对Interger泛型的List进行排序
* 2、对String泛型的List进行排序
* 3、对其他类型泛型的List进行排序，以Student为例
*/
public class CollectionsTest {
/*
* 1、通过Collections.sort()方法，对Interger泛型的List进行排序
* 创建一个Iteger类型的List,插入是个100以内的不重复的随机整数
* 调用Collections.sort()方法排序
* 练习：
* 创建List<String>后，往其中添加10条随机字符串，每条字符串长度为10以内的随机整数
* 每条字符串的每个字符都为随机生成的字符，字符可以重复，每条随机生成的字符串不可重复
*/
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));//如果已经包含随机数k则需要继续生成一个随机数
integerList.add(k);
System.out.println("成功添加整数："+k);
}
System.out.println("----------排序前----------");
//迭代integer中的每个元素
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) {
// TODO Auto-generated method stub
CollectionsTest ct=new CollectionsTest();
ct.testSort1();
ct.testSort2();
}
}
public void testSort3() {
List<String> stringList = new ArrayList<String>();
for (int i = 0; i < 10; i++) {
StringBuilder tempString = new StringBuilder();
Random random = new Random();
Character[] ku = { '0', 'A', 'a' };
do {
int k = (int) (Math.random() * 10);
// System.out.println(k);
for (int j = 0; j <= k; j++) {
int t = random.nextInt(3);
if (t == 0) {
tempString.append((char) (ku[t].charValue() + random .nextInt(10)));
} else {
tempString.append((char) (ku[t].charValue() + random .nextInt(26)));
}
}
} while (stringList.contains(tempString.toString()));
stringList.add(tempString.toString());
}
System.out.println("-------------排序前-------------");
for (String st : stringList) {
System.out.println("元素：" + st);
}
Collections.sort(stringList);
System.out.println("-------------排序后-------------");
for (String st : stringList) {
System.out.println("元素：" + st);
}
}
public void testSort4(){
List<String> stringList = new ArrayList<String>();
for (int i = 0; i < 10; i++) {
StringBuilder tempString = new StringBuilder();
Random random = new Random();
do {
int k = random.nextInt(10);
for (int j = 0; j <= k; j++){
int t = random.nextInt(3);
if (t == 0) {
tempString.append((char)('0' + random.nextInt(10)));
} else if (t == 1) {
tempString.append((char)('A' + random.nextInt(26)));
} else {
tempString.append((char)('a' + random.nextInt(26)));
}
}
} while(stringList.contains(tempString.toString()));
stringList.add(tempString.toString());
}
System.out.println("--------排序前--------");
for (String st : stringList) {
System.out.println("将要添加字符串：'" + st + "'");
}
Collections.sort(stringList);
System.out.println("--------排序后--------");
for (String st : stringList) {
System.out.println("元素：" + st);
}
}
6、学生选课-尝试对学生序列排序
7、Cpmparable&Comparator简介
8、学生选课-实现学生序列排序
java 集合框架--collection接口--collections工具类--Map接口--Comparator接口--Comparable接口
// 3、对其他类型泛型的List进行排序，以Student为例
/*
* comparable接口，给对象定义了默认的排序规则，comparator接口--临时比较规则，
* comparable接口--可比较的
* --实现该接口表示：这个类的实例可以比较大小，可以进行自然排序
* --定义了默认的比较规则
* --其实现类需实现compareTo()方法
* --compareTo()方法返回正数表示的，负数表示小，0表示相等
* comparator接口--比较工具
* --用于定义临时比较规则，而不是默认比较规则
* --其实现类需要实现compare()方法
* --comparator和comparable都是Java集合框架的成员
*/
public void testSort5(){
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+"","Lake"));
System.out.println("--------排序前--------");
for (Student student: studentList) {
System.out.println("学生：" +student.id+":"+ student.name );
}
//需要对Student类进行改造，使它实现comparable接口
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 );
}
}
student.java
public class Student implements Comparable<Student> {
...........
@Override
public int compareTo(Student o) {
// TODO Auto-generated method stub
return this.id.compareTo(o.id);
}
}
