1.参照书上例题，使用List集合完成对教师工资的排序。

有5个教师，基本信息如下：
姓名：张老师 工资：7800
姓名：王老师 工资：9800
姓名：刘老师 工资：6800
姓名：李老师 工资：5800
姓名：孙老师 工资：8800
将5个教师信息存放到ArrayList集合中，并使用下面三种方法中的任意一种方法，完成对教师工资由高到低的排序。
（1）冒泡排序算法
（2）或定义教师比较器类TeacherComparator
（3）或让Teacher类实现Comparable接口
编写测试类，输出排序前的顺序和排序后的顺序。
输出结果如下：
排序前顺序：
姓名：张老师 工资：7800
姓名：王老师 工资：9800
姓名：刘老师 工资：6800
姓名：李老师 工资：5800
姓名：孙老师 工资：8800
排序后顺序：
姓名：王老师 工资：9800
姓名：孙老师 工资：8800
姓名：张老师 工资：7800
姓名：刘老师 工资：6800
姓名：李老师 工资：5800
说明
程序没有输入！

  1. import java.util.List;
  2. import java.util.ArrayList;
  4. class Teacher{
  5.     private String name;
  6.     private int age;
  7.     private int salary;
  9.     public Teacher(String name,int age,int salary){
  10.         this.name=name;
  11.         this.age=age;
  12.         this.salary=salary;
  13.     }
  15.     public String getName(){
  16.         return name;
  17.     }
  18.     public int getAge(){
  19.         return age;
  20.     }
  21.     public int getSalary(){
  22.         return salary;
  23.     }
  25. }
  29. class TeacherComparator{
  30.     private List<Teacher>TeaList;
  31.     private int size;
  33.     public TeacherComparator(){
  34.         size=0;
  35.         TeaList=null;
  36.     }
  37.     public void createComparator(){
  38.         String names[]={"张老师","王老师","刘老师","李老师","孙老师"};
  39.         int salarys[]={7800,9800,6800,5800,8800};
  40.         int ages[]={17,18,18,19,17};
  42.         size=names.length;
  43.         TeaList=new ArrayList<Teacher>();
  44.         Teacher temp;
  46.         for(int i=0;i<size;i++){
  47.             temp=new Teacher(names[i],ages[i],salarys[i]);
  48.             TeaList.add(temp);
  49.         }
  50.     }
  52.     public void sort(){
  53.         Teacher temp;//冒泡排序
  54.         for(int i=0;i<size;i++){
  55.             for(int j=1;j<size;j++){
  56.                 if(TeaList.get(j-1).getSalary()<TeaList.get(j).getSalary()){
  57.                     temp=TeaList.get(j-1);
  58.                     TeaList.set(j-1,TeaList.get(j));
  59.                     TeaList.set(j,temp);
  60.                 }
  61.             }    
  62.         }        
  63.     }      
  65.     public String output(){
  66.         StringBuilder TeacherInfo=new StringBuilder();
  68.         for(Teacher Tea : TeaList){
  69.             TeacherInfo.append("姓名："+Tea.getName()+"\t工资："+Tea.getSalary()+"\r\n");
  70.         }
  71.         return TeacherInfo.toString();
  72.     }
  73. }
  75. public class Main{
  76.     public static void main(String[] args){
  77.         TeacherComparator sComparator=new TeacherComparator();//创建Comparator对象
  79.         sComparator.createComparator();//给Comparator添加教师
  81.         System.out.println("排序前顺序：");
  82.         System.out.println(sComparator.output());//排序前输出
  84.         sComparator.sort();//冒泡排序
  86.         System.out.println("排序后顺序：");
  87.         System.out.println(sComparator.output());//排序后输出
  88.     }
  89. }

2.在第1题的基础上，为类添加一个增加学生的方法，该方法的方法头如下：

public void addTeacher(Teacher t)
为类添加一个删除学生的方法，该方法的方法头如下：
public void removeTeacher(Teacher t)
然后修改测试类，添加一个陈老师，工资为9000。输出添加后的排序结果。之后从列表中删除张老师，再输出删除后的排序结果。
程序的输出结果如下：
排序前顺序：
姓名：张老师 工资：7800
姓名：王老师 工资：9800
姓名：刘老师 工资：6800
姓名：李老师 工资：5800
姓名：孙老师 工资：8800
排序后顺序：
姓名：王老师 工资：9800
姓名：孙老师 工资：8800
姓名：张老师 工资：7800
姓名：刘老师 工资：6800
姓名：李老师 工资：5800
添加一个教师后的排序顺序：
姓名：王老师 工资：9800
姓名：陈老师 工资：9000
姓名：孙老师 工资：8800
姓名：张老师 工资：7800
姓名：刘老师 工资：6800
姓名：李老师 工资：5800
删除一个教师后的排序顺序：
姓名：王老师 工资：9800
姓名：陈老师 工资：9000
姓名：孙老师 工资：8800
姓名：刘老师 工资：6800
姓名：李老师 工资：5800

  1. import java.util.List;
  2. import java.util.ArrayList;
  4. class Teacher{
  5.     private String name;
  6.     private int age;
  7.     private int salary;
  9.     public Teacher(String name,int age,int salary){
  10.         this.name=name;
  11.         this.age=age;
  12.         this.salary=salary;
  13.     }
  15.     public String getName(){
  16.         return name;
  17.     }
  18.     public int getAge(){
  19.         return age;
  20.     }
  21.     public int getSalary(){
  22.         return salary;
  23.     }
  25. }
  29. class TeacherComparator{
  30.     private List<Teacher>TeaList;
  31.     private int size;
  33.     public TeacherComparator(){
  34.         size=0;
  35.         TeaList=null;
  36.     }
  37.     public void createComparator(){
  38.         String names[]={"张老师","王老师","刘老师","李老师","孙老师"};
  39.         int salarys[]={7800,9800,6800,5800,8800};
  40.         int ages[]={17,18,18,19,17};
  42.         size=names.length;
  43.         TeaList=new ArrayList<Teacher>();
  44.         Teacher temp;
  46.         for(int i=0;i<size;i++){
  47.             temp=new Teacher(names[i],ages[i],salarys[i]);
  48.             TeaList.add(temp);
  49.         }
  50.     }
  52.     public void sort(){
  53.         Teacher temp;//冒泡排序
  54.         for(int i=0;i<size;i++){
  55.             for(int j=1;j<size;j++){
  56.                 if(TeaList.get(j-1).getSalary()<TeaList.get(j).getSalary()){
  57.                     temp=TeaList.get(j-1);
  58.                     TeaList.set(j-1,TeaList.get(j));
  59.                     TeaList.set(j,temp);
  60.                 }
  61.             }    
  62.         }        
  63.     }      
  64.     public void addTeacher(Teacher t){
  65.         TeaList.add(t);
  66.         size=TeaList.size();
  67.     }
  68.     public void removeTeacher(Teacher t){
  69.         for(int i = 0; i < size; i++)  
  70.         if(TeaList.get(i).getName()==t.getName()){  
  71.            TeaList.remove(i);  
  72.            size=TeaList.size();
  73.          }
  74.     }
  75. public String output(){
  76.         StringBuilder TeacherInfo=new StringBuilder();
  78.         for(Teacher Tea : TeaList){
  79.             TeacherInfo.append("姓名："+Tea.getName()+"\t工资："+Tea.getSalary()+"\r\n");
  80.         }
  81.         return TeacherInfo.toString();
  82.     }
  83. }
  85. public class Main{
  86.     public static void main(String[] args){
  87.         TeacherComparator sComparator=new TeacherComparator();//创建Comparator对象
  89.         sComparator.createComparator();//给Comparator添加教师
  91.         System.out.println("排序前顺序：");
  92.         System.out.println(sComparator.output());//排序前输出
  94.         sComparator.sort();//冒泡排序
  96.         System.out.println("排序后顺序：");
  97.         System.out.println(sComparator.output());//排序后输出
  98.         System.out.println("添加一个教师后的排序顺序：");
  99.         sComparator.addTeacher(new Teacher("陈老师",25,9000));
  100.         sComparator.sort();
  101.         System.out.println(sComparator.output());//添加一个教师后的排序顺序：
  102.         System.out.println("删除一个教师后的排序顺序：");
  103.         Teacher t;
  104.            t=new Teacher("张老师",17,7800);
  105.            sComparator.removeTeacher(t);    
  106.            sComparator.sort();
  108.         System.out.println(sComparator.output());//一个教师后的排序顺序：
  110.     }
  111. }