Java 类集习题

左手的ㄟ右手 2024-04-08 10:34 92阅读 0赞

> 活动地址：[CSDN21天学习挑战赛][CSDN21]  
> 
> 
> #### 题目目录 ####
> 
>  *  1、编写学生类
>  *  2、完成一个学生管理程序
>  *  3、编写一个双向链表。
>  *  4、编写程序通过栈的方式将任意输入的字符串内容进行逆序输出。

## 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]);
            }
        }
    }

运行结果：

> 比较之前：  
> 学号：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);
            }
        }
    }

> 全部的学生信息为：  
> 学号：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 + '\'' +
                    '}';
        }
    }

运行结果：

> 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() + " ");
            }
        }
    }

运行结果：

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

--------------------

看到最后，点个赞吧！

[CSDN21]: https://marketing.csdn.net/p/bdabfb52c5d56532133df2adc1a728fd