【Java SE】记录一次Java实验(多态，集合，泛型)

Java第三次实验：

正文开始@Assassin

1. 实验目的：

• （1）理解List的应用场合
• （2）掌握Comparable和Comparator接口的使用方法
• （3）掌握迭代器接口Iterator和ListIterator遍历集合的方

2. 实验内容：

2.1 处理扑克牌:

每张扑克牌有点数和花色，定义Poker类，要求如下：

• （1）成员变量包括点数（point）和花色（color）；
• （2）定义构造方法初始化所有成员变量；
• （3）省略setter()，定义getter()方法；
• （4）重写toString()方法返回扑克牌的信息。

定义PokerComparator类实现Comparator接口，重写compare（Object obj1，Object obj2）方法，首先按照花色排序，如果花色相同则按照点数从大到小排序。
定义游戏类Game，要求如下：

• （1） 定义变量ArrayLIst类型保存Poker对象，并定义空参构造；
• （2） 省略setter和getter方法；
• （3） 定义showAll()方法显示成员变量ArrayList对象的所有内容；
• （4） 定义成员方法sort对成员变量ArrayList元素按照花色点数排序。

定义测试类TestDemo，完成以下任务：

• （1） 创建 ArrayList对象 al ，有若干个不容的Poker对象；
• （2） 创建Game对象，参数是al；
• （3） 调用Game中的showAl()方法显示所有牌；
• （4） 调用Game中的sort()方法对al进行排序

直接贴代码了~~

Poker.java:

package com.haut.iot.ninghai;

/**
 * @Author: 宁海
 * @Date: 2021/11/9
 * @Time: 20:35
 * @Version: 1.0
 */


@SuppressWarnings({"all"}) //忽略警告

enum Color {
    DIAMOND, //方块
    CLUB,   //梅花
    HEART,  //红桃
    SPADE;  //黑桃
    private String[] colors = {"方块", "梅花", "红桃", "黑桃"};

    @Override
    public String toString() {
        //返回对象的字符串信息
        return colors[this.ordinal()];
    }
}

@SuppressWarnings({"all"}) //忽略警告
public class Poker {
    private int point; //点数
    private Color color; //颜色

    //构造方法初始化成员属性
    public Poker(int point, Color color) {
        this.point = point;
        this.color = color;
    }

    //getter方法
    public int getPoint() { //get point
        return point;
    }

    public Color getColor() { //get color
        return color;
    }

    @Override  //重写toString方法
    public String toString() {
        return "\nPoker{" +
                "point=" + point +
                ", color='" + color.toString() + '\'' +
                '}';
    }
}

PokerComparator.java:

package com.haut.iot.ninghai;

import java.util.Comparator;
import java.util.Objects;

/**
 * @Author: 宁海
 * @Date: 2021/11/9
 * @Time: 20:37
 * @Version: 1.0
 */


//泛型
public class PokerComparator implements Comparator<Poker> {
    @Override //指定比较规则
    public int compare(Poker obj1, Poker obj2) {//重写compare方法
        //调用Objects的equals方法进行判断，若花色不相同，就进行花色的比较
        //按照黑桃>红桃>梅花>方块的规则进行排序
        if (!Objects.equals(obj1.getColor(), obj2.getColor())) {
            //调用Integer的compare方法
            return Integer.compare(obj2.getColor().ordinal(), obj1.getColor().ordinal());
        } else { //当花色相同时，按照点数进行排序，按照从大到小的规则进行排序
            return Integer.compare(obj2.getPoint(), obj1.getPoint());
        }
    }
}

Game.java:

package com.haut.iot.ninghai;

import java.util.ArrayList;
import java.util.Collections;

/**
 * @Author: 宁海
 * @Date: 2021/11/9
 * @Time: 20:36
 * @Version: 1.0
 */


public class Game {
    //定义变量ArrayList类型变量来保存Poker对象
    private ArrayList<Poker> al;
    //构造方法初始化成员属性
    public Game(ArrayList<Poker> al) {
        this.al = al;
    }
    //定义空参构造
    public Game() {
    }

    @Override
    //重写toString方法
    public String toString() {
        return "Game{" +
                "al=" + al.toString() +
                '}';
    }

    //调用重写后的toString方法进行信息的打印
    public void showAll() {
        String ret = toString();
        System.out.println(ret);
    }
    //sort方法自动调用compareTo方法进行自定义排序
    //冒泡排序
    public void sort() {
        PokerComparator pokerComparator = new PokerComparator();
        for (int bound = 0; bound < al.size(); bound++) {
            for (int cur = 0; cur < al.size() - 1 - bound; cur++) {
                if (pokerComparator.compare(al.get(cur), al.get(cur + 1)) >= 1) {
                    //swap方法
                    Collections.swap(al, cur, cur + 1);
                }
            }
        }
    }
}

TestDemo.java:

package com.haut.iot.ninghai;

import java.util.ArrayList;

/**
 * @Author: 宁海
 * @Date: 2021/11/9
 * @Time: 20:37
 * @Version: 1.0
 */


public class TestDemo {
    public static void main(String[] args) {
        ArrayList<Poker> al = new ArrayList<>();  //new一个泛型的ArrayList对象
        //添加Poker对象
        al.add(new Poker(2, Color.SPADE));
        al.add(new Poker(3, Color.HEART));
        al.add(new Poker(4, Color.CLUB));
        al.add(new Poker(5, Color.DIAMOND));
        al.add(new Poker(7, Color.DIAMOND));
        al.add(new Poker(6, Color.SPADE));
        //new一个game对象进行测试
        Game game = new Game(al);
        game.showAll();
        //排序
        System.out.println("\n===========排序后===========\n");
        game.sort();
        game.showAll();
    }
}

实验结果：

由图可知：完全按照先花色后点数来排序

2.2 学生成绩管理：

定义学生类(Student)实现Comparable接口，要求：

• （1） 成员变量包括学号id，姓名name，年龄age，课程成绩ArrayList（至少三门课的成绩）；
• （2） 定义构造方法初始化所有成员变量
• （3） 省略getter和setter；
• （4） 功能方法：重写Comparable接口中的compareT()方法按照总分从大到小的顺序排序，重写toString方法返回学生的所有成员变量。

定义学生管理类Manager，要求：

• （1） 成员变量包括TreeSet ts；
• （2） 定义构造方法初始化成员变量
• （3） 定义功能方法：show()显示集合ts中的学生的学号、姓名、年龄、每门课程的成绩、总成绩，定义add(Student stu)方法把一个学生信息添加到ts中，利用remove(Student stu)方法删除一个学生，search(String id)方法根据学号查找学生。

定义测试类TestDemo，调用add()方法添加至少10个学生信息，调用show()方法显示学生信息，调用remove(String std)方法删除学生信息，调用search(String id)查找某学生信息。

Student.java:

package com.haut.iot._ninghai;

import java.util.List;

/**
 * @Author: 宁海
 * @Date: 2021/11/10
 * @Time: 14:11
 * @Version: 1.0
 */

public class Student implements Comparable<Student> {
    public String id; //学号
    public String name; //姓名
    public List<Integer> scoreList; //分数集合

    @Override
    //重写compareTo方法
    public int compareTo(Student o) {
        int scoreRet1 = 0; //计分器
        int scoreRet2 = 0; //计分器
        //增强for循环
        for (Integer next : scoreList) {
            scoreRet1 += next;
        }

        for (Integer next : o.scoreList) {
            scoreRet2 += next;
        }
        //按照总分从大到小排序
        return Integer.compare(scoreRet2, scoreRet1);

    }
    //默认的无参构造
    public Student() {
    }
    //构造方法初始化成员属性
    public Student(String id, String name, List<Integer> scoreList) {
        this.id = id;
        this.name = name;
        this.scoreList = scoreList;
    }

    @Override
    //重写toString
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", scoreList=" + scoreList +
                '}';
    }
}

Manager.java:

package com.haut.iot._ninghai;

import java.util.TreeSet;

/**
 * @Author: 宁海
 * @Date: 2021/11/10
 * @Time: 14:11
 * @Version: 1.0
 */


public class Manager {
    private TreeSet<Student> ts;//TreeSet集合，用来存放Student对象

    //默认的无参构造
    public Manager() {
    }
    //构造方法初始化成员属性
    public Manager(TreeSet<Student> ts) {
        this.ts = ts;
    }
    //show方法打印出各类信息
    public void show() {
        for (Student student : ts) {
            int total = 0;
            for (int i = 0; i < student.scoreList.size(); i++) {
                total = total + student.scoreList.get(i);
            }
            System.out.println("学生的学号为:" + student.id + ",姓名为:" + student.name +
                    ",成绩分别是" + student.scoreList + ",总成绩为:" + total);
        }
    }
    //调用TreeSet的add方法
    public void add(Student student) {
        this.ts.add(student);
    }
    //调用TreeSet的remove方法
    public void remove(Student student) {
        this.ts.remove(student);
    }
    //search方法
    public void search(String id) {
        int count = 0; //记录找不到的次数
        for (Student student : ts) {
            if (student.id.equals(id)) {
                System.out.print("找到了！！");
                System.out.println(student);
                break;
            }else {
                count++; //次数+1
                if (count == ts.size()) {
                    System.out.println("Sorry, the information could not be found!");
                }
            }
        }
    }
}

TestDemo.java:

package com.haut.iot._ninghai;

import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;

/**
 * @Author: 宁海
 * @Date: 2021/11/10
 * @Time: 14:12
 * @Version: 1.0
 */

public class TestDemo {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>(); //new一个泛型的TreeSet对象
        Manager manager = new Manager(ts); //new一个Manager对象
        //添加10个Student对象，每个对象带有三个不同的成绩
        for (int i = 0; i < 10; i++) {
            List<Integer> list = new ArrayList<>(); //泛型list对象，用来存放Student对象
            //添加分数
            list.add(99 - i);
            list.add(98 - i);
            list.add(97 - i);
            //Student对象
            Student student = new Student("" + i, "boy0" + i, list);
            //添加到manager中
            manager.add(student);
        }
        //显示排序结果
        manager.show();
        //演示add方法
        System.out.println("\n==========我是分割线===========\n");
        List<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(100);
        list.add(100);
        Student s1 = new Student("666", "王源", list);
        manager.add(s1);
        //演示show方法
        manager.show();
        //演示search方法+remove方法
        System.out.println("\n==========我是分割线===========\n");
        manager.search("666");
        System.out.println("\n==========我是分割线===========\n");
        manager.remove(s1);
        manager.show();

    }
}

实验结果：

添加10个信息：

add 宁海

search 宁海 && delete 宁海

可以看出，完全是按照总分从大到小排序的。