JavaOJ实验 容器
7-6 学生列表2 (25 分)
编写学生类，包含学号no、姓名name、成绩score，提供必要的构造函数、toString函数和equals/hashcode函数，其中，toString函数的格式为“no:xxx name:xxx score:xxx”,no参与equals和hashcode的计算 在main函数中构造一个容器存放学生对象 从命令行输入多个学生对象，存入列表中 从命令行中读入在列表对象上的操作，具体操作包含： add 添加一个学生(包含学号和学生姓名） delete 删除一个学生（包含学号） set 修改一个学生信息(只修改某学号学生的成绩） 完成操作后按学生的学号从小到大的顺序输出集合中的学生
输入格式:
学生个数 学生对象数据 操作数 操作内容
输出格式:
列表顺序输出集合中的学生
输入样例:
在这里给出一组输入。例如：
4
1 wong 90
2 liu 80
3 chen 70
4 fang 60
3
add 5 duan 80
delete 3
set 4 70
输出样例:
在这里给出相应的输出。例如：
no:1 name:wong score:90
no:2 name:liu score:80
no:4 name:fang score:70
no:5 name:duan score:80
本题有两个需要注意的地方：
1： 从命令行中读入在列表对象上的操作，具体操作包含： add 添加一个学生(包含学号和学生姓名） delete 删除一个学生（包含学号） set 修改一个学生信息(只修改某学号学生的成绩）
从命令行中读取操作，此种方法第一次遇到，解决方法：定义一个字符串，然后用Scanner读取接下来输出的字符，用equals方法进行判断，如果相等，那么就执行相应的方法
String msg = sc.next();
if(msg.equals("add")){
int no = sc.nextInt();
String name = sc.next();
int score = sc.nextInt();
Student stu = new Student(no,name,score);
list.add(stu);
}else if(msg.equals("delete")){
int no = sc.nextInt();
for(j=0;j<list.size(); j++)
if (list.get(j).getNo()==no)
list.remove(j);
}else if(msg.equals("set")){
int no = sc.nextInt();
int score = sc.nextInt();
for(Student stu:list)
if(stu.no == no)
stu.setScore(score);
}
2：完成操作后按学生的学号从小到大的顺序输出集合中的学生
这次的操作需要明白一点：如果要对一个容器进行Collections.sort的排序，而这个容器的泛型并不是传统的数据类型（类似Interger,String），没有compareto方法
如同此题中的Student根据学号排序，那么我们就需要自定义排序
自定义排序：实现Comparator<>接口，重写其中的compare方法
在sort（list,new Comparator<>）如此定义参数即可实现自定义排序，适用场景较多，非常重要
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student t1, Student t2) {
if(t1.getNo()<t2.getNo())
return -1;
else if(t1.getNo()==t2.getNo())
return 0;
else
return 1;
}
});
关于Comparable和Comparator区别比较
Comparable是排序接口，若一个类实现了Comparable接口，就意味着“该类支持排序”。而Comparator是比较器，我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。
Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。
两种方法各有优劣， 用Comparable 简单， 只要实现Comparable 接口的对象直接就成为一个可以比较的对象，但是需要修改源代码。 用Comparator 的好处是不需要修改源代码， 而是另外实现一个比较器， 当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去就可以比大小了， 并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑，使其可以匹配一些比较简单的对象，那样就可以节省很多重复劳动了。
实质上，Comparable接口中只有唯一一个方法，即compareTo方法，引用 Collections.sort(l1);排序时就是调用的compareTo方法
本体也可以通过实现Comparable接口，实现compareto方法来进行sort的排序，并且直接sort(list)即可
代码如下
通过Student类实现Comparable接口，重写compareto方法，直接调用sort(list)方法即可实现要求
package unsafe1;
import java.util.Scanner;
import java.util.*;
public class Main{
public static void main(String[] args){
ArrayList<Student> list = new ArrayList<>();
Scanner sc = new Scanner(System.in);
int k = sc.nextInt();
int i,j;
for(i=0; i<k; i++){
int no = sc.nextInt();
String name = sc.next();
int score = sc.nextInt();
Student stu = new Student(no,name,score);
list.add(stu);
}
k = sc.nextInt();
for(i=0; i<k; i++){
String msg = sc.next();
if(msg.equals("add")){
int no = sc.nextInt();
String name = sc.next();
int score = sc.nextInt();
Student stu = new Student(no,name,score);
list.add(stu);
}else if(msg.equals("delete")){
int no = sc.nextInt();
for(j=0;j<list.size(); j++)
if (list.get(j).getNo()==no)
list.remove(j);
}else if(msg.equals("set")){
int no = sc.nextInt();
int score = sc.nextInt();
for(Student stu:list)
if(stu.no == no)
stu.setScore(score);
}
}
// Collections.sort(list, new Comparator() {
//
// @Override
// public int compare(Student t1, Student t2) {
// if(t1.getNo()
// return -1;
// else if(t1.getNo()==t2.getNo())
// return 0;
// else
// return 1;
// }
// });
Collections.sort(list);
for(Student s:list)
System.out.println(s);
}
}
class Student implements Comparable<Student>{
int no;
String name;
int score;
Student(int no,String name,int score){
this.no = no;
this.name = name;
this.score = score;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "no:"+no+" name:"+name+" score:"+score;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + no;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (no != other.no)
return false;
return true;
}
@Override
public int compareTo(Student student) {
if(this.getNo()>student.getNo())
return 1;
else if(this.getNo()==student.getNo())
return 0;
else return -1;
}
}
6-1 教师、学生排序 (30 分)
已知Main类、Person类的设计，完成Student类，Teacher类、MyTool类的设计。
函数接口定义：
class Student extends Person{ }
class Teacher extends Person{ }
class MyTool{ public static void separateStu_T(List persons,List teachers,List students){} }
Student类继承了Person，拥有私有属性int类型的sno和String类型的major，分别代表学号与所学专业；提供对应的set，get方法；比较方法完成按照学号比较。
Teacher类继承了Person，拥有私有属性int类型的tno和String类型的subject，分别代表教师编号与所授科目；提供对应的set，get方法；比较方法完成按年龄比较。
MyTool类中提供方法public static void separateStu_T(List persons,List teachers,List students){}，方法 separateStu_T的功能是将persons线性表中的 teacher，student分别放到teachers,students两个线性表中。
裁判测试程序样例：
import java.util.*;
public class Main {
public static void main(String[] args) {
List persons=getPersons(); //得到一个所有人的线性表
List teachers=new ArrayList();
List students=new ArrayList();
MyTool.separateStu_T( persons,teachers,students); //将persons线性表中的 teacher，student分别放到teachers,students两个线性表中
Collections.sort(teachers); //对教师线性表排序
Collections.sort(students); //对学生线性表排序
showResult(teachers); //显示教师线性表排序以后的结果
showResult(students); //显示学生线性表排序以后的结果
}
public static List getPersons()
{
List persons=new ArrayList();
Scanner in=new Scanner(System.in);
Person person=null;
int num=Integer.parseInt(in.nextLine());
for(int i=0;i<num;i++)
{ String str=in.nextLine();
String []data=str.split(",");
if(data[0].equalsIgnoreCase("student"))
person=new Student(Integer.parseInt(data[1]),data[2],data[3],Integer.parseInt(data[4]),data[5]);
else if (data[0].equalsIgnoreCase("teacher"))
person=new Teacher(Integer.parseInt(data[1]),data[2],data[3],Integer.parseInt(data[4]),data[5]);
else person=null;
persons.add(person);
}
return persons;
}
public static void showResult(List persons)
{
for(int i=0;i<persons.size();i++)
{
Person per=(Person)persons.get(i);
System.out.println(per.getName()+","+per.getGender()+","+per.getAge());
}
}
}
abstract class Person implements Comparable
{ private String name;
private String gender;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, String gender, int age) {
super();
this.name = name;
this.gender = gender;
this.age = age;
}
}
/* 请在这里写你的代码 */
输入样例：
输入的第一行是总人数n，紧跟着输入n行，每一行代表一个人的信息。下面的例子中n=5，输入了5个人的信息。
5
student,1001,Tom1,female,18,computer
teacher,2001,Jake1,female,35,datastructer
student,1002,Tom2,male,19,computer
student,1003,Tom3,female,20,software
teacher,2002,Jake2,female,33,database
输出样例：
注意：本样例输出结果中两名教师是按照年龄升序排序的，三名学生是按照学号降序排序的。
Jake2,female,33
Jake1,female,35
Tom3,female,20
Tom2,male,19
Tom1,female,18
Accept
package unsafe1;
import java.util.*;
public class Main {
public static void main(String[] args) {
List persons=getPersons(); //得到一个所有人的线性表
List teachers=new ArrayList();
List students=new ArrayList();
MyTool.separateStu_T( persons,teachers,students); //将persons线性表中的 teacher，student分别放到teachers,students两个线性表中
Collections.sort(teachers); //对教师线性表排序
Collections.sort(students); //对学生线性表排序
showResult(teachers); //显示教师线性表排序以后的结果
showResult(students); //显示学生线性表排序以后的结果
}
public static List getPersons()
{
List persons=new ArrayList();
Scanner in=new Scanner(System.in);
Person person=null;
int num=Integer.parseInt(in.nextLine());
for(int i=0;i<num;i++)
{ String str=in.nextLine();
String []data=str.split(",");
if(data[0].equalsIgnoreCase("student"))
person=new Student(Integer.parseInt(data[1]),data[2],data[3],Integer.parseInt(data[4]),data[5]);
else if (data[0].equalsIgnoreCase("teacher"))
person=new Teacher(Integer.parseInt(data[1]),data[2],data[3],Integer.parseInt(data[4]),data[5]);
else person=null;
persons.add(person);
}
return persons;
}
public static void showResult(List persons)
{
for(int i=0;i<persons.size();i++)
{
Person per=(Person)persons.get(i);
System.out.println(per.getName()+","+per.getGender()+","+per.getAge());
}
}
}
abstract class Person implements Comparable
{ private String name;
private String gender;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, String gender, int age) {
super();
this.name = name;
this.gender = gender;
this.age = age;
}
}
class Student extends Person implements Comparable{
private int sno;
private String major;
public Student(int sno,String name,String gender,int age,String major) {
super(name, gender, age);
this.sno = sno;
this.major = major;
}
public int getSno() {
return sno;
}
public void setSno(int sno) {
this.sno = sno;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
@Override
public int compareTo( Object o) {
Student student = (Student)o;
if(this.sno>student.sno)
return -1;
else if(this.sno == student.sno)
return 0;
else
return -1;
}
}
class Teacher extends Person{
private int tno;
private String subject;
public Teacher( int tno,String name, String gender, int age, String subject) {
super(name, gender, age);
this.tno = tno;
this.subject = subject;
}
public int getTno() {
return tno;
}
public void setTno(int tno) {
this.tno = tno;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
@Override
public int compareTo(Object o) {
Teacher teacher = (Teacher)o;
if(this.getAge()>teacher.getAge())
return 1;
else if(this.getAge() == teacher.getAge())
return 0;
else
return -1;
}
}
class MyTool{ public static void separateStu_T(List persons,List teachers,List students){
for(int i = 0; i < persons.size();i++)
{
if(persons.get(i) instanceof Student)
{
students.add(persons.get(i));
}
else
teachers.add(persons.get(i));
}
}
}
本题难点有二：给定程序Person类实现了Comparable，需要定义子类Teacher和Student来继承父类，但是不能使用泛型来定义compareto方法，所以重写的compareto方法如下
@Override
public int compareTo(Object o) {
Teacher teacher = (Teacher)o;
if(this.getAge()>teacher.getAge())
return 1;
else if(this.getAge() == teacher.getAge())
return 0;
else
return -1;
}
使用 Teacher teacher = (Teacher)o;来进行强制类型转换,在此之前也可以用instanceof来判断
这样就定义了一个Teacher类的引用变量，就可以调用teacher类的变量与this进行判断，返回优先级
实现排序效果
instanceof
boolean result = obj instanceof Class
其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。
注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。
详细方法不做阐述
instanceof