• Java 类集 习题

    活动地址：CSDN21天学习挑战赛

    题目目录

    1、编写学生类

    题目：编写学生类，该类定义了3个属性：学号、姓名、成绩。可以通过构造方法设置3 个属性的内容，并覆写Object类中的tostring()方法，在List集合中加入5个学生对象，并将内容输出，之后使用比较器将对象的内容进行排序并显示在屏幕上。

    代码如下：

    import java.util.List;
import java.util.ArrayList;
class Student implements Comparable<Student>{
    private int number;
    private String name;
    private float score;
    public Student(int number,String name,float score){
        this.setNumber(number);
        this.setName(name);
        this.setScore(score);
    }
    public String toString(){
        return "学号："+this.getNumber()+"  姓名："+this.getName()+"  分数:"+this.getScore();
    }
    public int compareTo(Student stu){
        if(this.number>stu.number){
            return -1;
        }else if(this.number<stu.number){
            return 1;
        }else{
            if(this.score>stu.score){
                return 1;
            }else if(this.score<stu.score){
                return -1;
            }else{
                return 0;
            }
        }
    }
    public void setNumber(int number){
        this.number=number;
    }
    public int getNumber(){
        return this.number;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
    public void setScore(float score){
        this.score=score;
    }
    public float getScore(){
        return this.score;
    }
}
public class Demo1{
    public static void main(String[] args){
        Student stu1=new Student(20220808, "张三", 95);
        Student stu2=new Student(20220203, "李四", 99);
        Student stu3=new Student(20224010, "王五", 98);
        Student stu4=new Student(20220113, "朱六", 93);
        Student stu5=new Student(20221030, "赵七", 96);
        List<Student> stu=new ArrayList<>();
        stu.add(stu1);
        stu.add(stu2);
        stu.add(stu3);
        stu.add(stu4);
        stu.add(stu5);
        System.out.println("比较之前：");
        for(int i=0;i<stu.size();i++){
            System.out.println(stu.get(i));
        }
        System.out.println("比较之后：");
        Object[] str=stu.toArray();
        java.util.Arrays.sort(str);
        for(int i=0;i<str.length;i++){
            System.out.println(str[i]);
        }
    }
} 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73

    运行结果：

    比较之前：
    学号：20220808 姓名：张三 分数:95.0
    学号：20220203 姓名：李四 分数:99.0
    学号：20224010 姓名：王五 分数:98.0
    学号：20220113 姓名：朱六 分数:93.0
    学号：20221030 姓名：赵七 分数:96.0
    比较之后：
    学号：20224010 姓名：王五 分数:98.0
    学号：20221030 姓名：赵七 分数:96.0
    学号：20220808 姓名：张三 分数:95.0
    学号：20220203 姓名：李四 分数:99.0
    学号：20220113 姓名：朱六 分数:93.0

    2、完成一个学生管理程序

    题目：完成一个学生管理程序，使用学号作为键添加5个学生对象，并可以将全部的信息保存在文件中，可以实现对学生信息的学号查找、输出全部学生信息的功能。

    代码如下：

    import java.util.Map;
import java.util.HashMap;
import java.util.Collection;
import java.util.Iterator;
import java.io.File;
import java.io.OutputStream;
import java.io.FileOutputStream;
class Student{
    private int number;
    private String name;
    private float score;
    public Student(int number,String name,float score){
        this.setNumber(number);
        this.setName(name);
        this.setScore(score);
    }
    public void setNumber(int number){
        this.number=number;
    }
    public void setName(String name){
        this.name=name;
    }
    public void setScore(float score){
        this.score=score;
    }
    public int getNumber(){
        return this.number;
    }
    public String getName(){
        return this.name;
    }
    public float getScore(){
        return this.score;
    }
    public String toString(){
        return "学号："+this.number+"姓名："+this.name+"分数："+this.score;
    }
}
public class Demo2{
    public static void main(String[] args) throws Exception{
        File f=new File("C:\\Users\\Eastward\\Desktop\\student.txt");
        OutputStream out=new FileOutputStream(f);
        Student stu1=new Student(20080808, "张三", 95);
        Student stu2=new Student(20100203, "李四", 99);
        Student stu3=new Student(20071010, "王五", 98);
        Student stu4=new Student(20080113, "朱六", 93);
        Student stu5=new Student(20101030, "赵七", 96);
        Map<String,Student> map=new HashMap<>();
        map.put("1",stu1);
        map.put("2",stu2);
        map.put("3",stu3);
        map.put("4",stu4);
        map.put("5",stu5);
        String str=map.toString();
        byte[] b=str.getBytes();
        out.write(b);
        out.close();
        Student val=map.get("1");
        System.out.println("1号学生的信息是   "+val);
        System.out.println("全部的学生信息为：");
        Collection<Student> values=map.values();
        Iterator<Student> iter=values.iterator();
        while(iter.hasNext()){
            Student str1=iter.next();
            System.out.println(str1);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68

    全部的学生信息为：
    学号：20080808姓名：张三分数：95.0
    学号：20100203姓名：李四分数：99.0
    学号：20071010姓名：王五分数：98.0
    学号：20080113姓名：朱六分数：93.0
    学号：20101030姓名：赵七分数：96.0

    3、编写一个双向链表。

    /**
 * 双向链表
 */
public class Demo3{
    public static void main(String[] args) {
        //测试
        DoubleEdgedSword2 sword2 = new DoubleEdgedSword2(2, "鲨齿", "魏庄");
        DoubleEdgedSword2 sword1 = new DoubleEdgedSword2(1, "渊虹", "盖聂");
        DoubleEdgedSword2 sword11 = new DoubleEdgedSword2(11, "巨擘", "胜七");
        DoubleEdgedSword2 sword4 = new DoubleEdgedSword2(4, "干将莫邪", "傻胖");

        DoublyLinkedList doublyLinkedList = new DoublyLinkedList();

        //添加数据入链表（考虑顺序：这里自定义的顺序是按照no从小到大）
        doublyLinkedList.addByOrder(sword2);
        doublyLinkedList.addByOrder(sword1);
        doublyLinkedList.addByOrder(sword11);
        doublyLinkedList.addByOrder(sword4);
        //遍历链表
        doublyLinkedList.getLinked();

        //修改链表节点
        doublyLinkedList.updateLinkedList(new DoubleEdgedSword2(11,"巨阙","陈胜"));
        //修改后再次遍历链表
        System.out.println("=======================================");
        doublyLinkedList.getLinked();

        //测试删除链表节点
        doublyLinkedList.deleteLinkedList(1);
        //
        System.out.println("===========================");
        doublyLinkedList.getLinked();
    }
}

/**
 * 双向链表的增删改查操作
 */
class DoublyLinkedList {

    //定义一个头节点
    private DoubleEdgedSword2 head = new DoubleEdgedSword2(0,null,null);


    /**
     * 添加（考虑顺序：自定义顺序：no从小到大）
     */
    public void addByOrder(DoubleEdgedSword2 doubleEdgedSword2){
        //同样需要一个辅助节点
        DoubleEdgedSword2 item = head;
        Boolean logo = true;   //用来做标识，判断添加的数据是否存在
        //
        while (true){
            if (item.next == null){   //节点到达了最后一个节点
                break;
            }
            if (item.next.no > doubleEdgedSword2.no){   //找到了新节点应该存放的位置
                break;
            }else if (item.next.no == doubleEdgedSword2.no){   //说明新节点已经在链表中存在
                logo = false;
                break;
            }
            item = item.next;   //循环条件
        }

        if (logo == false){
            System.out.println("该元素已经存在于链表当中");
        }else {   //将节点插入链表
            doubleEdgedSword2.next = item.next;
            if (item.next != null){   //插入的节点不在链表最后
                item.next.pre = doubleEdgedSword2;
            }
            item.next = doubleEdgedSword2;
            doubleEdgedSword2.pre = item;
        }
    }


    /**
     * 修改链表
     * 根据no属性查找需要修改的节点
     * 传入新的节点信息，来修改节点
     */
    public void updateLinkedList(DoubleEdgedSword2 newDoubleEdgedSword2){
        //判断节点是否为空
        if (head.next == null){
            System.out.println("节点为空~~~");
            return;
        }
        //辅助节点
        DoubleEdgedSword2 item = head;
        Boolean logo = false;   //标识是否找到需要修改的节点
        //
        while (true){
            if (item.next == null){
                break;
            }
            if (item.next.no == newDoubleEdgedSword2.no){   //找到了需要修改的节点，将标识logo
                logo = true;
                break;
            }
            item = item.next;
        }

        if (logo == false){
            System.out.println("链表中未找到排行为： " + newDoubleEdgedSword2.no + " 的剑");
        }else {
            item.next.name = newDoubleEdgedSword2.name;
            item.next.sName = newDoubleEdgedSword2.sName;
        }
    }


    /**
     * 删除链表中的节点
     */
    public void deleteLinkedList(int no){
        //判断链表是否为null
        if (head.next == null){
            System.out.println("链表为空~~~");
        }
        //辅助节点(item,需要删除的节点)
        DoubleEdgedSword2 item = head.next;
        //
        while (true){
            if (item == null){   //以及已经到最后一个节点
                System.out.println("链表中未找到~~~");
                break;
            }
            if (item.no == no){   //找到了需要删除的节点
                item.pre.next = item.next;
                if (item.next != null){   //需要删除的节点不是链表最后一个节点
                    item.next.pre = item.pre;
                }
                break;
            }
            item = item.next;
        }
    }


    /**
     * 显示链表(遍历)
     */
    public void getLinked(){
        //判断链表是否为null
        if (head.next == null){   //头结点的next为空，所以链表为空
            System.out.println("链表为空~~~");
            return;
        }
        //同样因为头结点不能动，所以我们需要定义一个辅助接点
        DoubleEdgedSword2 temp = head;
        //遍历链表
        while (true){
            if (temp.next == null){   //当temp节点到达最后一个节点，即遍历结束
                break;
            }
            System.out.println(temp.next);
            //将temp指向后移
            temp = temp.next;
        }
    }

}

/**
 * 宝剑类(双向链表形式添加数据)
 */
class DoubleEdgedSword2 {
    public int no;   //排名
    public String name;   //剑名
    public String sName;   //使用者姓名
    public DoubleEdgedSword2 next;   //指向下一个节点（下一把宝剑）
    public DoubleEdgedSword2 pre;   //指向上一个节点

    public DoubleEdgedSword2(int no, String name, String sName) {
        this.no = no;
        this.name = name;
        this.sName = sName;
    }

    //重写toString方法不必打印next
    @Override
    public String toString() {
        return "DoubleEdgedSword2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", sName='" + sName + '\'' +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191

    运行结果：

    DoubleEdgedSword2{no=1, name=‘渊虹’, sName=‘盖聂’}
    DoubleEdgedSword2{no=2, name=‘鲨齿’, sName=‘魏庄’}
    DoubleEdgedSword2{no=4, name=‘干将莫邪’, sName=‘傻胖’}
    DoubleEdgedSword2{no=11, name=‘巨擘’, sName=‘胜七’}
    =======================================
    DoubleEdgedSword2{no=1, name=‘渊虹’, sName=‘盖聂’}
    DoubleEdgedSword2{no=2, name=‘鲨齿’, sName=‘魏庄’}
    DoubleEdgedSword2{no=4, name=‘干将莫邪’, sName=‘傻胖’}
    DoubleEdgedSword2{no=11, name=‘巨阙’, sName=‘陈胜’}
    ===========================
    DoubleEdgedSword2{no=2, name=‘鲨齿’, sName=‘魏庄’}
    DoubleEdgedSword2{no=4, name=‘干将莫邪’, sName=‘傻胖’}
    DoubleEdgedSword2{no=11, name=‘巨阙’, sName=‘陈胜’}

    4、编写程序通过栈的方式将任意输入的字符串内容进行逆序输出。

    import java.util.Stack;
import java.util.Scanner;
public class Demo4 {
    public static void main(String[] args) {
        System.out.println("请输入一个字符串:");
        Scanner scan = new Scanner(System.in);
        String str = scan.next();
        Stack<Character> s = new Stack<>();
        char[] str1 = str.toCharArray();
        for (int i = 0; i < str1.length; i++) {
            s.push(str1[i]);
        }
        System.out.println("逆序输出为:");
        for (int i = 0; i < str1.length; i++) {
            System.out.print(s.pop() + " ");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    运行结果：

    请输入一个字符串:
    123456789
    逆序输出为:
    9 8 7 6 5 4 3 2 1

    看到最后，点个赞吧！
  • 相关阅读:
    有趣的数学 积分符号∫ (integration)简述
    java使用策略模式优化代码中的if-else if 判断。
    Spring Authorization Server授权服务器入门
    类似东郊到家预约家政保洁小程序搭建
    FPGA—可乐机拓展训练题（状态机）
    Vue2+Vue3基础入门到实战项目（七）——智慧商城项目
    第八章 时序检查(中)
    基于内存的分布式NoSQL数据库Redis(三)常用命令
    36.一文讲透JavaScript日期对象Date，时间戳、1970、date方法、date计算
    简单返回封装实体类(RespBean)
  • 原文地址：https://blog.csdn.net/CSDN_anhl/article/details/126449693