JAVA作业七

最新推荐文章于 2024-04-16 16:46:16 发布

_KEVEON

最新推荐文章于 2024-04-16 16:46:16 发布

阅读量1.5k

点赞数 2

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/super_iron_man/article/details/111460869

版权

JAVA 专栏收录该内容

14 篇文章 11 订阅

订阅专栏

7-1 学生列表 (20分)

编写学生类，包含学号no、姓名name、成绩score，提供必要的构造函数、toString函数和equals/hashcode函数，其中，toString函数的格式为“no:xxx name:xxx score:xxx”,no参与equals和hashcode的计算在main函数中构造一个学生列表对象（List），用于存放多个学生对象从命令行输入多个学生对象，存入列表中从命令行中读入在列表对象上的操作，具体操作包含： add 添加一个学生(包含学号和学生姓名） delete 删除一个学生（包含学号） set 修改一个学生信息(只修改某学号学生的成绩）完成操作后按列表顺序输出集合中的学生

输入格式:
学生个数学生对象数据操作数操作内容

输出格式:
列表顺序输出集合中的学生

输入样例:
在这里给出一组输入。例如：

4
1 wong 90
2 liu 80
3 chen 70
4 fang 60
3
add 5 duan 80
delete 3
set 4 70

输出样例:
在这里给出相应的输出。例如：

no:1 name:wong score:90
no:2 name:liu score:80
no:4 name:fang score:70
no:5 name:duan score:80

重写equals方法后，一般都要继续重写hascode方法

Java中hashCode的作用

import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n=scan.nextInt();
        List<Student> list=new LinkedList<Student>();

        for(int i=0;i<n;i++){
            int no = scan.nextInt();
            String name = scan.next();
            int score=scan.nextInt();
            Student s=new Student(no,name,score);
            list.add(s);
        }

        int op=scan.nextInt();

        for (int i = 0; i < op ; i++) {
            String oper=scan.next();
            if(oper.equals("add")){
                Student s1=new Student(scan.nextInt(),scan.next(),scan.nextInt());
                list.add(s1);
            }
            else if(oper.equals("delete")){//根据学号删除，foreach循环
                int k=scan.nextInt();
//                 for(Student j:list) {
//                         if(j.getNo()==k) {
//                             list.remove(j);break;
//                         }
//                 }   //抛出ConcurrentModificationException异常
                    //原因：在这个方法中，删除元素实际上调用的就是list.remove()方法，但是它多了一个操作（调用list.remove()方法导致modCount和expectedModCount的值不一致。）
                    //改正：1.删除后立马跳出循环停止遍历
                    //2.在迭代器中如果要删除元素，调用It类的remove方法。
                 Iterator<Student> It=list.iterator();
                while(It.hasNext()){
                    if(It.next().getNo()==k)
                        It.remove();
                }
            }
            else if(oper.equals("set")){//根据学号修改
                int k1=scan.nextInt();
                int nscore=scan.nextInt();
                for(Student u:list){
                        if(u.getNo()==k1) {
                            //list.set(,new Student(u.getNo(),u.getName(),nscore));//	set(int index, E element)
                            //用指定的元素（可选操作）替换此列表中指定位置的元素。
                            //用于此位序无法确定
                            u.setScore(nscore);
                            break;
                        }
                }
            }
        }
        Iterator<Student> It=list.iterator();
        while(It.hasNext())
            System.out.println(It.next());

        scan.close();
    }
}

/*你的代码被嵌在这里*/


class Student implements Comparable<Student>{
    private int no;
    private String name;
    private int score;

    public Student(int no, String name,int score) {
        this.no = no;
        this.name = name;
        this.score=score;
    }


    public int getNo() {
        return no;
    }


    public void setNo(int no) {
        this.no = no;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public String toString()
    {
        return "no:"+getNo()+" name:"+getName()+" score:"+getScore();
    }

    //no参与equals和hashcode的计算
    @Override
    public int hashCode() {//计算object的哈希码
        final int prime = 31;
        int result = 1;
        result = prime * result + no;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())//getClass() 返回此 Object的运行时类
            return false;
        Student stu = (Student) obj;
        if (no != stu.no)
            return false;
        return true;
    }

    @Override
    public int compareTo(Student o) {
        return this.getName().compareTo(o.getName());
    }
}

7-2 学生Map (20分)

编写学生类，包含学号no、姓名name、成绩score，提供必要的构造函数、toString函数和equals/hashcode函数，其中，toString函数的格式为“no:xxx name:xxx score:xxx”,no参与equals和hashcode的计算在main函数中构造一个Map容器存放学生对象从命令行输入多个学生对象，存入Map中，其中key为学号，value为学生对象。从命令行中读入在学生集合上的操作，具体操作包含： add 添加一个学生(包含学号和学生姓名） delete 删除一个学生（包含学号） set 修改一个学生信息(只修改某学号学生的成绩）完成操作后按学生的学号从小到大的顺序输出所有学生的信息输出时按照学生的学号顺序输出

输入格式:
学生个数学生对象数据操作数操作内容

输出格式:
按照学号顺序输出集合中的学生

输入样例:
在这里给出一组输入。例如：

4
1 wong 90
2 liu 80
3 chen 70
4 fang 60
3
add 5 duan 80
delete 3
set 4 70

输出样例:
在这里给出相应的输出。例如：

no:1 name:wong score:90
no:2 name:liu score:80
no:4 name:fang score:70
no:5 name:duan score:80

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int n=scan.nextInt();
        Map<Integer,Student> map=new HashMap<>();

        //从命令行输入多个学生对象，存入Map中
        for (int i = 0; i < n ; i++) {
            int no=scan.nextInt();
            String name=scan.next();
            int score=scan.nextInt();
            Student s=new Student(no,name,score);
            map.put(no,s);
        }

        int op=scan.nextInt();

        while(op>0){

            String operation =scan.next();
            if(operation.equals("add")) {
                int no1=scan.nextInt();
                String name1=scan.next();
                int score1=scan.nextInt();
                Student s1 =new Student(no1,name1,score1);
                map.put(no1,s1);
            }

            else if(operation.equals("delete")){
                int no2=scan.nextInt();
                map.remove(no2);
            }
            else if(operation.equals("set")){
                int no3=scan.nextInt();
                int score3=scan.nextInt();
                Student s2=map.get(no3);
                s2.setScore(score3);
                map.replace(no3,s2);
            }
            op--;
        }
        //Map遍历：1.Set keySet( )获取所有Key的集合
        //2.Collection valueSet( ) 获取所有Value的集合
        //3.Set entrySet( ) 获取所有key-value对的集合
        //再用相应的Iterator或者for循环遍历

        //第一种，使用Iterator遍历
        /*Iterator<Map.Entry<Integer,Student>> it=map.entrySet().iterator();
            while(it.hasNext())
                System.out.println(it.next().getValue());*/

        //第二种，使用foreach遍历
        for(Map.Entry<Integer,Student> i:map.entrySet()){
            //System.out.println(i.getKey());
            System.out.println(i.getValue());
        }

        //第三种，在foreach中遍历value

        /*for(Student j:map.values()){
            System.out.println(j);
        }*/

        //第四种，通过键找值遍历（效率低）
        /*for(int k:map.keySet()){
            System.out.println(map.get(k));
        }*/
        scan.close();
    }
}
class Student implements Comparable<Student>{
    private int no;
    private String name;
    private int score;

    public Student(int no, String name,int score) {
        this.no = no;
        this.name = name;
        this.score=score;
    }


    public int getNo() {
        return no;
    }


    public void setNo(int no) {
        this.no = no;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public String toString()
    {
        return "no:"+getNo()+" name:"+getName()+" score:"+getScore();
    }

    //no参与equals和hashcode的计算
    @Override
    public int hashCode() {//计算object的哈希码
        final int prime = 31;
        int result = 1;
        result = prime * result + no;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())//getClass() 返回此 Object的运行时类
            return false;
        Student stu = (Student) obj;
        if (no != stu.no)
            return false;
        return true;
    }

    @Override
    public int compareTo(Student o) {
        return this.getName().compareTo(o.getName());
    }
}

7-3 jmu-Java-05集合-01-ArrayListIntegerStack (20分)

定义IntegerStack接口，该接口描述了一个存放Integer的栈的常见方法：

public Integer push(Integer item); //如item为null，则不入栈直接返回null。否则直接入栈，然后返回item。
public Integer pop();              //出栈，如栈为空，则返回null。
public Integer peek();             //获得栈顶元素，如栈顶为空，则返回null。注意：不要出栈
public boolean empty();           //如过栈为空返回true
public int size();                //返回栈中元素数量

定义IntegerStack的实现类ArrayListIntegerStack，内部使用ArrayList存储。该类中包含：

构造函数：
在无参构造函数中新建ArrayList或者LinkedList，作为栈的内部存储。
思考：查询JDK文档，尝试说明本题到底使用哪个List实现类最好。

方法:
public String toString() //用于输出List中的内容,可直接调用List的toString()方法。可用System.out.println(list)进行输出。

提示：

不建议使用top指针。最好直接复用List实现类中已有的方法。
pop时应将相应的元素从列表中移除。
main方法说明
建立ArrayIntegerStack对象
输入m个值，均入栈。每次入栈均打印入栈返回结果。
输出：栈顶元素，输出是否为空，然后输出size.
输出栈中所有元素（调用其toString()方法）
输入x，然后出栈x次，每次均打印出栈的对象。
输出:栈顶元素，输出是否为空，输出size。注意：这里的输出栈顶元素，仅输出、不出栈。
输出栈中所有元素（调用其toString()方法）。注意：返回null，也要输出。
思考：
如果使用LinkedList来实现IntegerStack，怎么实现？测试代码需要进行什么修改？

输入样例

5
1 3 5 7 -1
2

输出样例

1
3
5
7
-1
-1,false,5
[1, 3, 5, 7, -1]
-1
7
5,false,3
[1, 3, 5]

ArrayList实现

import java.util.*;
//定义IntegerStack接口，该接口描述了一个存放Integer的栈的常见方法：
interface IntegerStack{
    public Integer push(Integer item); //如item为null，则不入栈直接返回null。否则直接入栈，然后返回item。
    public Integer pop();              //出栈，如栈为空，则返回null。
    public Integer peek();             //获得栈顶元素，如栈顶为空，则返回null。注意：不要出栈
    public boolean empty();           //如过栈为空返回true
    public int size();                //返回栈中元素数量
}

public class Main {
    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);

        //建立ArrayIntegerStack对象
        ArrayListIntegerStack list=new ArrayListIntegerStack();
        //输入m个值，均入栈。每次入栈均打印入栈返回结果。
        int m=cin.nextInt();
        for (int i = 0; i < m ; i++) {
            int e= list.push(cin.nextInt());;
            System.out.println(e);
        }
        //输出： 栈顶元素，输出是否为空，然后输出size.
        System.out.println(list.peek()+","+list.empty()+","+list.size());
        //输出栈中所有元素（调用其toString()方法）
        System.out.println(list);
        //输入x，然后出栈x次，每次均打印出栈的对象。
        int x=cin.nextInt();
        for (int i = 0; i < x ; i++) {
            //int b=list.pop();
            System.out.println(list.pop());//测试点2在这。。。
        }
        //输出:栈顶元素，输出是否为空，输出size。注意：这里的输出栈顶元素，仅输出、不出栈。
        System.out.println(list.peek()+","+list.empty()+","+list.size());
        //输出栈中所有元素（调用其toString()方法）。注意：返回null，也要输出。
        System.out.println(list);
        cin.close();
    }
}

class ArrayListIntegerStack implements IntegerStack{
    private List<Integer> list;
    //定义IntegerStack的实现类ArrayListIntegerStack，内部使用ArrayList存储。
    public ArrayListIntegerStack(){
        //List list=new ArrayList<Integer>();//error,list重定义
        list=new ArrayList<Integer>();//ListedList实现了Deque和List两个接口
        //可以是队列、栈、链表
        //ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
        //此处采用ArrayList实现堆栈，FILO
        //根据它们的优缺点，可以知道，ArrayList适用于频繁查询和获取数据；而LinkedList适合频繁地增加或删除数据的场景。
    }

    @Override
    public String toString(){
        //System.out.println(list);
        return list.toString();
    }

    public Integer push(Integer item)//如item为null，则不入栈直接返回null。否则直接入栈，然后返回item。
    {
        if(item==null) return null;
        list.add(item);
        return item;
    }
    public Integer pop()              //出栈，如栈为空，则返回null。
    {
            if(list.isEmpty()) return null;
            int a=list.get(list.size()-1);
            list.remove(list.size()-1);
            return a;
    }
    public Integer peek()             //获得栈顶元素，如栈顶为空，则返回null。注意：不要出栈
    {
            if(list.isEmpty())
                return null;
            else
            {
                return list.get(list.size()-1);
            }
    }
    public boolean empty()           //如过栈为空返回true
    {
            if(list.isEmpty()) return true;
            else return false;
    }
    public int size()                //返回栈中元素数量
    {
            return list.size();
    }
}

在这里插入图片描述

LinkedList 实现

import java.util.*;
//定义IntegerStack接口，该接口描述了一个存放Integer的栈的常见方法：
interface IntegerStack{
    public Integer push(Integer item); //如item为null，则不入栈直接返回null。否则直接入栈，然后返回item。
    public Integer pop();              //出栈，如栈为空，则返回null。
    public Integer peek();             //获得栈顶元素，如栈顶为空，则返回null。注意：不要出栈
    public boolean empty();           //如过栈为空返回true
    public int size();                //返回栈中元素数量
}

public class Main3 {
    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);

        //建立ArrayIntegerStack对象
        ArrayListIntegerStack list=new ArrayListIntegerStack();
        //输入m个值，均入栈。每次入栈均打印入栈返回结果。
        int m=cin.nextInt();
        for (int i = 0; i < m ; i++) {
            int e= list.push(cin.nextInt());;
            System.out.println(e);
        }
        //输出： 栈顶元素，输出是否为空，然后输出size.
        System.out.println(list.peek()+","+list.empty()+","+list.size());
        //输出栈中所有元素（调用其toString()方法）
        System.out.println(list);
        //输入x，然后出栈x次，每次均打印出栈的对象。
        int x=cin.nextInt();
        for (int i = 0; i < x ; i++) {
            //int b=list.pop();
            System.out.println(list.pop());//测试点2放这个地方，这nm不恶心人吗，fuck！
        }
        //输出:栈顶元素，输出是否为空，输出size。注意：这里的输出栈顶元素，仅输出、不出栈。
        System.out.println(list.peek()+","+list.empty()+","+list.size());
        //输出栈中所有元素（调用其toString()方法）。注意：返回null，也要输出。
        System.out.println(list);
        cin.close();
    }
}

class ArrayListIntegerStack implements IntegerStack{
    private LinkedList<Integer> list;
    //定义IntegerStack的实现类ArrayListIntegerStack，内部使用ArrayList存储。
    public ArrayListIntegerStack(){
        //List list=new ArrayList<Integer>();//error,list重定义
        list=new LinkedList<Integer>();//LinkedList实现了Deque和List两个接口
        //可以是队列、栈、链表
        //ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
        //此处采用LinkedList实现堆栈
        //根据它们的优缺点，可以知道，ArrayList适用于频繁查询和获取数据；而LinkedList适合频繁地增加或删除数据的场景。
    }

    @Override
    public String toString(){
        //System.out.println(list);
        return list.toString();
    }

    public Integer push(Integer item)//如item为null，则不入栈直接返回null。否则直接入栈，然后返回item。
    {
        if(item==null) return null;
        list.offer(item);//add/addLast/offerLast/offer将元素插入双端队列尾端（栈顶）
        return item;
    }
    public Integer pop()              //出栈，如栈为空，则返回null。
    {
        if(list.isEmpty()) return null;
        int a=list.pollLast();//removeLast/pollLast 获取并删除双端队列的最后一个元素（栈顶元素）
        return a;
    }
    public Integer peek()             //获得栈顶元素，如栈顶为空，则返回null。注意：不要出栈
    {
        if(list.isEmpty())
            return null;
        else
        {
            return list.peekLast();//getLast/PeekLast获取但不删除双端队列的最后一个元素
        }
    }
    public boolean empty()           //如过栈为空返回true
    {
       return list.isEmpty();
    }
    public int size()                //返回栈中元素数量
    {
        return list.size();
    }
}

7-4 jmu-Java-06异常-01-常见异常 (20分)

自己编码以产生常见异常。

###main方法：

事先定义好一个大小为5的数组。

根据屏幕输入产生相应异常

提示：可以使用System.out.println(e)打印异常对象的信息，其中e为捕获到的异常对象。

**输入说明: **

arr 代表产生访问数组是产生的异常。然后输入下标，如果抛出ArrayIndexOutOfBoundsException异常则显示，如果不抛出异常则不显示。
null，产生NullPointerException
cast，尝试将String对象强制转化为Integer对象，产生ClassCastException。
num，然后输入字符，转化为Integer，如果抛出NumberFormatException异常则显示。
其他，结束程序。
输入样例：

arr 4
null
cast
num 8
arr 7
num a
other

输出样例：

java.lang.NullPointerException
java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
java.lang.ArrayIndexOutOfBoundsException: 7
java.lang.NumberFormatException: For input string: "a"

将题目描述逐句翻译即可

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int []a=new int[5];
        while ((true)){
            String s=input.next();

            if(s.equals("arr"))
            {
                try {
                    int b = input.nextInt();
                    int c=a[b];
                }catch (Exception e){
                    System.out.println(e);
                }
            }
            if(s.equals("null")){
                try{
                    String d=null;
                    int len=d.length();
                }catch (Exception e){
                    System.out.println(e);
                }
            }
            if(s.equals("cast")){
               try {
                   Object o = new String("1");
                   Integer i = (Integer) o;
               }catch (Exception e){
                   System.out.println(e);
               }
            }
            if(s.equals("num")){
                try{
                    String ss=input.next();
                    Integer in=Integer.parseInt(ss);
                }catch (Exception e){
                    System.out.println(e);
                }
            }
            if(s.equals("other")) break;
        }
        input.close();
    }
}

7-5 jmu-Java-06异常-02-使用异常机制处理异常输入 (20分)

使用异常处理输入机制，让程序变得更健壮。

###main方法：

输入n，创建大小为n的int数组。
输入n个整数，放入数组。输入时，有可能输入的是非整型字符串，这时候需要输出异常信息，然后重新输入。
使用Arrays.toString输出数组中的内容。
输入样例：

输出样例：

java.lang.NumberFormatException: For input string: "a"
java.lang.NumberFormatException: For input string: "b"
[1, 2, 4, 5, 3]

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        int n=cin.nextInt();
        int []arr=new int[n];
        int count=0;
        while(n>0) {
            try{
                String s=cin.next();
                int em=Integer.parseInt(s);
                arr[count++]=em;//若输入类型错误，则此句不被执行
                n--;//若输入类型错误，则此句不被执行
                //NumberFormatException
                //数字格式化错误，
                // 如果你的参数字符串不是数字的话，
                // 经过Integer.valueOf(argument)就会抛出NumberFormatException异常。
                // 表示将字符串解析成int类型数字出现异常。
            }catch (Exception e){
                System.out.println(e);
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

7-6 测试抛出异常 (20分)

尝试构造类ArrayUtil，该类的方法int findMax（int[] arr, int begin, int end）能抛出IllegalArgumentException（表示参数错误）的方法。正常执行要求begin<=end

如果begin>=end，抛出异常(IllegalArgumentException)，异常信息为 “begin:x >= end:x”

如果begin<0，抛出异常(IllegalArgumentException)，异常信息为 “begin:x < 0”

如果end>arr.length，抛出异常(IllegalArgumentException)，异常信息为 “end:x > arr.length”

要求在findMax方法声明处声明此异常，在main函数里要捕获此异常，并输出异常类型（可用obj.getClass().getName()）和异常信息

输入格式:
输入n，表示int数组大小

输入n个整数，放入数组。

输入m，表示begin和end的对数

输入m对整数，代表begin与end，然后调用ArrayUtils.findMax方法。

输出格式:
异常信息

数组的最大值

输入样例:
在这里给出一组输入。例如：

输出样例:
在这里给出相应的输出。例如：

5
java.lang.IllegalArgumentException: begin:3 >= end:3
4
java.lang.IllegalArgumentException: begin:3 >= end:2
java.lang.IllegalArgumentException: begin:-1 < 0
java.lang.IllegalArgumentException: end:6 > arr.length

在构造函数中抛出异常

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        int n=cin.nextInt();
        int []arr=new int[n];
        for (int i = 0; i < n ; i++) {
            arr[i]=cin.nextInt();
        }
        int m=cin.nextInt();
        ArrayUtil arrayUtil=new ArrayUtil();
        for (int i = 0; i < m ; i++) {
            try {
                int begin=cin.nextInt();
                int end=cin.nextInt();
                arrayUtil.findMax(arr,begin,end);
            }catch (Exception e){
                System.out.println(e);
            }

        }

        cin.close();
    }
}
class ArrayUtil {
    private int max;
    public ArrayUtil(){
        max=0;
    }
    public void findMax(int arr[],int begin,int end){
        if(begin<end&&begin>=0&&end<=arr.length){
            max=0;
            for(int i=begin;i<end;i++){
                if(arr[i]>max){
                    max=arr[i];
                }
            }
            System.out.println(max);
        }
        else if(begin>=end){
            throw new IllegalArgumentException( "begin:"+begin+" >= end:"+end);
        }
        else if(begin<0){
            throw new IllegalArgumentException("begin:"+begin+" < 0");
        }
        else if(end>arr.length){
            throw new IllegalArgumentException("end:"+end+" > arr.length");
        }
        else{
            throw new IllegalArgumentException();
        }
    }
}

_KEVEON

关注

2
点赞
踩
8

收藏

觉得还不错? 一键收藏
1
评论
JAVA作业七

7-1 学生列表 (20分)编写学生类，包含学号no、姓名name、成绩score，提供必要的构造函数、toString函数和equals/hashcode函数，其中，toString函数的格式为“no:xxx name:xxx score:xxx”,no参与equals和hashcode的计算在main函数中构造一个学生列表对象（List），用于存放多个学生对象从命令行输入多个学生对象，存入列表中从命令行中读入在列表对象上的操作，具体操作包含： add 添加一个学生(包含学号和学生姓名） dele
复制链接

扫一扫