20165324 第十周课下补做

知识点总结

20165324《Java程序设计》第六周

未完成作业为：

数据结构排序：

在数据结构和算法中，排序是很重要的操作，要让一个类可以进行排序，有两种方法：
1. 有类的源代码，针对某一成员变量排序，让类实现Comparable接口,调用Collection.sort(List)
2. 没有类的源代码，或者多种排序，新建一个类，实现Comparator接口调用Collection.sort(List, Compatator)
针对下面的Student类，使用Comparator编程完成以下功能：
1. 在测试类StudentTest中新建学生列表，包括自己和学号前后各两名学生，共5名学生,给出运行结果（排序前，排序后）
2. 对这5名同学分别用学号和总成绩进行增序排序，提交两个Comparator的代码
3. 课下提交代码到码云

补做：对这5名同学分别用学号和总成绩进行增序排序，提交两个Comparator的代码。
完整代码为：

/*
数据结构—排序
 */
/*
数据结构—排序
 */
package yan;
import java.util.*;
class StudentKey implements Comparable {
    double d=0;
    StudentKey (double d) {
        this.d=d;
    }
    public int compareTo(Object b) {
        StudentKey st=(StudentKey)b;
        if((this.d-st.d)==0)
            return -1;
        else
            return (int)((this.d-st.d)*1000);
    }
}
class Student  {
    private String name;
    private int ID;
    private double mathScore;
    private double englishScore;
    private double javaScore;
    private double sum = 0;
    Student(String name, int ID,double mathScore,double englishScore,double javaScore) {
        this.name = name;
        this.ID = ID;
        this.mathScore=mathScore;
        this.englishScore=englishScore;
        this.javaScore=javaScore;
    }
    public double getMathScore() {
        return mathScore;
    }
    public double getEnglishScore() {
        return englishScore;
    }
    public double getJavaScore(){
        return javaScore;
    }
    public double getSum() {
        return sum = mathScore + englishScore+javaScore;
    }
    public String getName() {
        return name;
    }
    public int getID() {
        return ID;
    }
}
public class Test1 {
    public static void main(String args[ ]) {
        TreeMap<StudentKey,Student>  treemap= new TreeMap<StudentKey,Student>();
        String str[]={"王瑶佳","杨金川","何春江","李东骏","陈卓"};
        int ID[]={22,23,24,25,26};
        double m[]={78,84,85,98,87};
        double p[]={79,77,87,89,91};
        double e[]={99,78,88,74,68};
        Student student[]=new Student[5];
        for(int k=0;k<student.length;k++) {
            student[k]=new Student(str[k],ID[k],m[k],p[k],e[k]);
        }
        StudentKey key[]=new StudentKey[5] ;
        for(int k=0;k<key.length;k++) {
            key[k]=new StudentKey(student[k].getID());
        }
        for(int k=0;k<student.length;k++) {
            treemap.put(key[k],student[k]);  //put方法添加结点
        }
        int number=treemap.size();
        System.out.println("按学号排序：:");
        Collection<Student> collection=treemap.values();//遍历
        Iterator<Student> iter=collection.iterator();//迭代
        while(iter.hasNext()) {
            Student stu=iter.next();
            System.out.println(stu.getName()+" ID："+stu.getID()+" 英语成绩："+stu.getEnglishScore()+" Java成绩:"+stu.getJavaScore()+" 数学成绩:"+stu.getMathScore());
        }
        treemap.clear();
        for(int k=0;k<key.length;k++) {
            key[k]=new StudentKey(student[k].getSum());
        }
        for(int k=0;k<student.length;k++) {
            treemap.put(key[k],student[k]);
        }
        number=treemap.size();
        System.out.println("按总成绩排序：:");
        collection=treemap.values();
        iter=collection.iterator();
        while(iter.hasNext()) {
            Student stu=(Student)iter.next();
            System.out.println(stu.getName()+" ID："+stu.getID()+" 总成绩："+stu.getSum());
        }
    }
}

测试截图：

未完成分析：

问题1：分类混乱，尤其Student类在src目录下多次改写
问题1解决方法：灵活使用包来对类进行区分，在课上进行测试时，重建一个IDEA项目，统一编写。
问题2：时间未能把握，未能提交任何截图
问题2解决方法：完成一部分内容，就可以尽快上传相应截图。

第十五章编程题：

编程题一

import java.util.*;
public class Dome01 {
    public static void main(String[] args) {
        Stack<Integer> stack=new Stack<Integer>();
        int temp,m,n;
        stack.push(3);
        stack.push(8);
        System.out.println("输入需要打印的前n项的值(n至少为3)：");
        Scanner sc=new Scanner(System.in);
        int number=sc.nextInt();
        if(number>2){
            System.out.println(3);
            System.out.println(8);
        }
        for (int i = 0; i < number-2; i++) {
            m=stack.pop();//出栈8
            n=stack.pop();//出栈3
            temp = 2*(m+n);
            stack.push(n);//入栈3
            stack.push(m);//入栈8
            stack.push(temp);//入栈22
            System.out.println(temp);
        }
    }
}

实验截图：

编程题二

import java.util.Iterator;
import java.util.LinkedList;
import java.util.TreeMap;
import java.util.TreeSet;

/*
1.定义链表保存学生英语成绩
2.遍历链表
3.英语成绩保存至树中
 */
public class Dome02 {
    public static void main(String[] args) {
        LinkedList<Munber> mylist=new LinkedList<Munber>();
        TreeSet<Integer> mytree=new TreeSet<Integer>();
        String name[]={"hcj","aaa","bbb","ccc"};
        int  score[]={45,99,78,98};
        Munber munber[]=new Munber[4];
        for(int i=0;i<4;i++) {
            munber[i]=new Munber(name[i],score[i]);
            mylist.add(munber[i]);
        }
        Iterator<Munber> iter=mylist.iterator();
        while (iter.hasNext()) {
            Munber m=iter.next();
            mytree.add((int) m.getEnglishScore());
        }
        Iterator<Integer> te=mytree.iterator();
        while (te.hasNext()) {
            int temp=te.next();
            System.out.println(temp);
        }
    }
}
class Munber implements Comparable {
    private String name;
    private int EnglishScore;
    Munber(String name,int EnglishScore) {
        this.name=name;
        this.EnglishScore=EnglishScore;
    }
    public String getName() {
        return name;
    }
    public int  getEnglishScore() {
        return  EnglishScore;
    }
    public int compareTo(Object b) {
        Munber st=(Munber) b;
        return (this.getEnglishScore()-st.getEnglishScore());
    }
}

实验截图

编程题三

/*
使用树
 */
import java.util.Collection;
import java.util.Iterator;
import java.util.TreeMap;
public class Dome03 {
    public static void main(String[] args) {
        TreeMap<Key,Yan> treeMap=new TreeMap<Key,Yan>();
        double  price[]={100,101,102,99,98,97,103,104,96,95};
        double capacity[]={45,65,25,78,58,47,88,13,24,77};

        Yan Upan[]=new Yan[10];
        Key key[]=new Key[10];
        for(int i=0;i<10;i++) {
            Upan[i]=new Yan(price[i],capacity[i]);
            key[i]=new Key(Upan[i].getCapacity());
            treeMap.put(key[i],Upan[i]);
        }
        int number=treeMap.size();
        System.out.println("按价格排序");
        Collection<Yan> collection=treeMap.values();
        Iterator<Yan> iter=collection.iterator();
        while(iter.hasNext()) {
            Yan yan=iter.next();
            System.out.println(yan.getPrice()+" "+yan.getCapacity());
        }
        treeMap.clear();
        for(int i=0;i<10;i++) {
            key[i]=new Key(Upan[i].getPrice());
            treeMap.put(key[i],Upan[i]);
        }
        System.out.println("按容量排序");
        collection=treeMap.values();
        iter=collection.iterator();
        while (iter.hasNext()) {
            Yan yan=iter.next();
            System.out.println(yan.getPrice()+" "+yan.getCapacity());
        }
    }
}
class Yan {
    private double capacity;
    private double price;

    Yan(double capacity, double price) {
        this.price = price;
        this.capacity = capacity;

    }

    public double getPrice() {
        return price;
    }

    public double getCapacity() {
        return capacity;
    }
}
class Key implements Comparable{
    double score=0;
    Key(double score) {
        this.score=score;
    }
    @Override
    public int compareTo(Object o) {
        Key key=(Key)o;
        if(this.score-((Key) o).score==0) {
            return -1;
        }
        else {
            return (int)(this.score-((Key) o).score)*1000;
        }
    }
}

实验截图