（1）假设源程序StuList.java中的类实现了接口MyList，创建源程序MyList.java，其中的内容是接口MyList的声明。
（2）在StuList.java中学生信息不再存放在数组中，而是存放在双链表泛型类的对象中；排序时使用树映射泛型类的对象进行排序输出。
（4）StuList.java，MyList.java，Undergraduate.java，Postgraduate.java和Student.java在同一个包中。Main.java在无名包中。
创建学生链表，使用者根据提示信息，选择从键盘上输入本科生或者研究生的学生信息，将其加入学生链表，添加学生信息，删除学生信息，显示学生信息，按照学生成绩排序等。
实现方法：
（1） 树映射的第一个泛型为封装类Double
文件路径：
其中在StuList.java中
使用双链表泛型类对象存储学生信息
LinkedList list = new LinkedList();
使用树映射泛型类对象将学生信息按照成绩排序并且输出
TreeMap<Double,Student>treemap=new TreeMap<Double,Student>();
Collection collection = treemap.values();//集合
Iteratoriter = collection.iterator();
while(iter.hasNext())
{
Student s =iter.next();
s.print();
}
项目关键代码：
//
package 包;
import java.util.*;
public class StuList implements MyList
{
//使用双链表泛型类对象存储学生信息
LinkedList<Student> list = new LinkedList<Student>();
public StuList()
{
}
public int size()
{
return list.size();
}
public boolean addStu(Student x) //添加学生信息
{
list.add(x);
return true;
}
public Student removeStu(int index) //删除指定位置的学生信息
{
return list.remove(index);
}
public void clear()
{
list.clear();
}
public void sort(int x) //使用树映射泛型类对象将学生信息按照成绩排序并且输出，参数1按数学排序，参数2按计算机排序
{
TreeMap<Double,Student> treemap= new TreeMap<Double,Student>();
if(x==1)
{
for(int i =0;i<size();i++)
{
Student s1 = list.get(i);
treemap.put(s1.getMathScore(),s1);
}
System.out.println("按照数学成绩排序后为：");
Collection<Student> collection = treemap.values();//集合
Iterator<Student>iter = collection.iterator();
while(iter.hasNext())
{
Student s =iter.next();
s.print();
}
}
else if(x==2)
{
for(int i =0;i<size();i++)
{
Student s2 = list.get(i);
treemap.put(s2.getComputerScore(),s2);
}
System.out.println("按照计算机成绩排序后为：");
Collection<Student> collection = treemap.values();
Iterator<Student>iter = collection.iterator();
while(iter.hasNext())
{
Student s =iter.next();
s.print();
}
}
}
public void print()
{
Iterator<Student> t=list.iterator();
while(t.hasNext())
{
Student s =t.next();
s.print();
}
}
}
//测试类main.java
import 包.*;
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner in=new Scanner(System.in);
StuList list=new StuList(); //创建学生链表
int num; //实际输入的学生信息
System.out.println("要创建本科生信息表还是研究生信息表？\nA.本科生\tB.研究生");
switch(in.next().charAt(0))
{
case 'A':
case 'a':
System.out.println("请问要输入多少个本科生的信息？");
num=in.nextInt();
for(int i=0;i<num;i++)
{
System.out.println("请输入第"+(i+1)+"位学生的学号，姓名，数学、计算机成绩");
Student t=new Undergraduate(in.nextInt(),in.next(),in.nextDouble(),in.nextDouble());
list.addStu(t);
}
System.out.println("输入的学生信息为：");
list.print();
list.addStu(new Undergraduate(1312,"shgd",99,98.5));
list.addStu(new Undergraduate(1316,"ddsa",89,88.5));
System.out.println("添加学生后，学生的信息：");
list.print();
break;
case 'B':
case 'b':
System.out.println("请问要输入多少个研究生的信息？");
num=in.nextInt();
for(int i=0;i<num;i++)
{
System.out.println("请输入第"+(i+1)+"位学生的学号，姓名，数学、计算机成绩，导师和研究方向，以空格隔开");
Student t=new Postgraduate(in.nextInt(),in.next(),in.nextDouble(),in.nextDouble(),in.next(),in.next());
list.addStu(t);
}
System.out.println("输入的学生信息为：");
list.print();
list.addStu(new Postgraduate(1312,"shgd",99,98.5,"xyy","os"));
list.addStu(new Postgraduate(1316,"ddsa",89,88.5,"wcl","rgzn"));
System.out.println("添加学生后，学生的信息：");
list.print();
break;
default:
System.out.println("输入错误！！！");
break;
}
System.out.println("您要删除第几位同学的信息：");
int pos = in.nextInt();
list.removeStu(pos-1);
System.out.println("移除第"+pos+"位学生后的信息为：");
list.print();
list.sort(1);
list.sort(2);
in.close();
}
}
(2) 树映射的第一个泛型为Key类
观察到当有学生成绩相同时，排序后的显示结果，将出现缺少学生信息的问题，即相同成绩的学生信息将只保留一条。为解决此问题，使树映射的第一个泛型不是封装类即：
项目关键代码：
//StuList.java
package 包;
import java.util.*;
class Key implements Comparable
{
double num=0;
Key(double num)
{
this.num=num;
}
public int compareTo(Object b)
{
Key t=(Key)b;
if(this.num == t.num)
return 1;
else
return (int)((this.num-t.num)*10);
}
}
public class StuList implements MyList
{
//使用双链表泛型类对象存储学生信息
LinkedList<Student> list = new LinkedList<Student>();
public StuList()
{
}
public int size()
{
return list.size();
}
public boolean addStu(Student x) //添加学生信息
{
list.add(x);
return true;
}
public Student removeStu(int index) //删除指定位置的学生信息
{
return list.remove(index);
}
public void clear()
{
list.clear();
}
public void sort(int x) //参数1按数学排序，参数2按计算机排序
{
TreeMap<Key,Student> treemap= new TreeMap<Key,Student>();
if(x==1)
{
for(int i =0;i<size();i++)
{
Student s1 = list.get(i);
treemap.put(new Key(s1.getMathScore()),s1);
}
System.out.println("按照数学成绩排序后为：");
Collection<Student> collection = treemap.values();
Iterator<Student>iter = collection.iterator();
while(iter.hasNext())
{
Student s =iter.next();
s.print();
}
}
else if(x==2)
{
for(int i =0;i<size();i++)
{
Student s2 = list.get(i);
treemap.put(new Key(s2.getComputerScore()),s2);
}
System.out.println("按照计算机成绩排序后为：");
Collection<Student> collection = treemap.values();
Iterator<Student>iter = collection.iterator();
while(iter.hasNext())
{
Student s =iter.next();
s.print();
}
}
}
public void print()
{
Iterator<Student> t=list.iterator();
while(t.hasNext())
{
Student s =t.next();
s.print();
}
}
}
import 包.*;
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner in=new Scanner(System.in);
StuList list=new StuList(); //创建学生链表，和实验1不同了，构造方法中没有参数了
int num; //实际输入的学生信息
System.out.println("要创建本科生信息表还是研究生信息表？\nA.本科生\tB.研究生");
switch(in.next().charAt(0))
{
case 'A':
case 'a':
System.out.println("请问要输入多少个本科生的信息？");
num=in.nextInt();
for(int i=0;i<num;i++)
{
System.out.println("请输入第"+(i+1)+"位学生的学号，姓名，数学、计算机成绩");
Student t=new Undergraduate(in.nextInt(),in.next(),in.nextDouble(),in.nextDouble());
list.addStu(t);
}
System.out.println("输入的学生信息为：");
list.print();
list.addStu(new Undergraduate(1312,"shgd",99,98.5));
list.addStu(new Undergraduate(1316,"ddsa",89,88.5));
System.out.println("添加学生后，学生的信息：");
list.print();
break;
case 'B':
case 'b':
System.out.println("请问要输入多少个研究生的信息？");
num=in.nextInt();
for(int i=0;i<num;i++)
{
System.out.println("请输入第"+(i+1)+"位学生的学号，姓名，数学、计算机成绩，导师和研究方向，以空格隔开");
Student t=new Postgraduate(in.nextInt(),in.next(),in.nextDouble(),in.nextDouble(),in.next(),in.next());
list.addStu(t);
}
System.out.println("输入的学生信息为：");
list.print();
list.addStu(new Postgraduate(1312,"shgd",99,98.5,"xyy","os"));
list.addStu(new Postgraduate(1316,"ddsa",89,88.5,"wcl","rgzn"));
System.out.println("添加学生后，学生的信息：");
list.print();
break;
default:
System.out.println("输入错误！！！");
break;
}
System.out.println("您要删除第几位同学的信息：");
int pos = in.nextInt();
list.removeStu(pos-1);
System.out.println("移除第"+pos+"位学生后的信息为：");
list.print();
list.sort(1);
list.sort(2);
in.close();
}
}
结论分析
1.本例中用到了LinkedList和TreeMap<K,V>两个泛型类，
其中利用LinkedList list = new LinkedList();
创建双链表泛型类对象list存储学生信息。
利用Double封装类，通过TreeMap 是按键（学生的成绩）的升序排列。
TreeMap<Double,Student>treemap=new TreeMap<Double,Student>()。
但当学生成绩出现重复时，让Key类实现Comparable 接口重写CompareTo（）方法。
TreeMap<Key,Student> treemap= new TreeMap<Key,Student>();
2.对Comparable和Comparator接口的区别和用法不太理解。
Comparable 接口（排序接口）仅仅只包括一个函数,定义如下：
package java.lang;
import java.util.*;
public interface Comparable {
public int compareTo(T o);
}
通过 x.compareTo(y) 来“比较x和y的大小”。若返回“负数”，意味着“x比y小”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”.
Comparator 接口（比较器）仅仅只包括两个函数，定义如下：
package java.util;
public interface Comparator {
int compare(T o1, T o2);
boolean equals(Object obj);
}
int compare(T o1, T o2) 是“比较o1和o2的大小”。返回“负数”，意味着“o1比o2小”；返回“零”，意味着“o1等于o2”；返回“正数”，意味着“o1大于o2”， 若一个类要实现Comparator接口：它一定要实现compareTo(T o1, T o2) 函数。
即：Comparable是排序接口；若一个类实现了Comparable接口，就意味着“该类支持排序”。.而Comparator是比较器；我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。Comparable相当于“内部比较器”，而Comparator相当于“外部比较器。
1682
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
