JAVA编程题求全部代码

Question

hw1：
一维数组的排序、打印、max、min、和平均值
1）要处理的数组作为各函数的形参
2）max,min,ave可以||不用 作为成员变量，使用getteres、setters
3）排序，使用冒泡算法

hw2：
利用标准输入流对象获取一元二次方程的三个系数并求解

hw3.对象数组及其应用，
a）编写一个表示学生（学号、年龄、体重、姓名）的java类并声明该对象n个学生对象数组
b）格式化打印数组（格式化，printf）
c）对象数组按年龄、体重升序排序
d）计算平均、最大、最小年龄、体重
e）使用scanner输入每个学生信息
f）具有系统菜单

hw4:
1)用Scanner输入数据到学生数组里面
2)使用数据输出流，把学生对象数组每一个对象的数据写入到一个文件里
3)打开文件，读取数据，并格式化显示

HW5：
一、利用对象数组、对象序列化、输入输出流设计并编写一个Java应用程序，具备以下功
能：1）打印系统列表（学号，姓名，年龄，体重）；2）增加一位新成员；3）查找最小
年龄的学生并输出其信息；4）按年龄从小到大排序系统数据；5）离开系统；6）保存
系统数据到文件中；7）从文件中加载旧数据。
二、简要叙述设计思想和技术路线（不少于500字）
三、文字叙说各个功能模块的“算法”、技术难点并附上代码
四、谈谈这个系统升级的设想及其有关Java的要素
五、系统测试截图
六、附录全部代码

Answer 1

class HW1 {
    public static void main(String[] args) {
        double[] test = new double[]{5.2, 1.0, 6.7, 3.4, 100.5, 55.5};
        BoundryValues boundryValues = getBoundryValues(test);
        System.out.println("Min Value = " + boundryValues.getMin());
        System.out.println("Max Value = " + boundryValues.getMax());
        System.out.println("Ave Value = " + boundryValues.getAve());
    }
    
    private static class BoundryValues {
        private double max;
        private double min;
        private double ave;
        
        public BoundryValues(){}
        
        public BoundryValues(double max, double min, double ave) {
            this.max = max;
            this.min = min;
            this.ave = ave;
        }
        
        public void setMax(double max) {
            this.max = max;
        }
        
        public double getMax() {
            return max;
        }
        
        public void setMin(double min) {
            this.min = min;
        }
        
        public double getMin() {
            return min;
        }
        
        public void setAve(double ave) {
            this.ave = ave;
        }
        
        public double getAve() {
            return ave;
        }
    }
    
    public static BoundryValues getBoundryValues(double[] doubles) {
        BoundryValues boundryValues = new BoundryValues();
        double[] results = sort(doubles);
        double total = 0.0;
        for (int i = 0; i < results.length; i ++) {
            total += results[i];
        }
        boundryValues.setMin(results[0]);
        boundryValues.setMax(results[results.length - 1]);
        boundryValues.setAve(total/results.length);
        return boundryValues;
    }
    
    public static double[] sort(double[] doubles) {
        for (int i = 0; i < doubles.length; i ++) {
            for (int j = 0; j < doubles.length - i - 1; j ++) {
                if (doubles[j] > doubles[j + 1]) {
                    double temp = doubles[j];
                    doubles[j] = doubles[j + 1];
                    doubles[j + 1] = temp;
                }
            }
        }
        return doubles;
    }
}

import java.util.*;

class HW2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double a, b, c;
        System.out.println("Enter a, b, c:");
        a = scanner.nextDouble();
        b = scanner.nextDouble();
        c = scanner.nextDouble();
        Set<Double> sets = calculate(a, b, c);
        for (Double d : sets) {
            System.out.println("Values are: " + d + "\n");
        }
    }
    
    public static Set<Double> calculate(double a, double b, double c) {
        Set<Double> sets = new HashSet<Double>();
        if (Math.pow(b, 2.0) - 4 * a * c < 0) {
            System.err.println("No value");
        } else {
            sets.add((- b + Math.sqrt(Math.pow(b, 2.0) - 4 * a * c)) / 2.0 * a);
            sets.add((- b - Math.sqrt(Math.pow(b, 2.0) - 4 * a * c)) / 2.0 * a);
        }
        return sets;
    }
}

下午接着写