Java实验（超详细）

发布时间：2024年01月12日

实验一 Java编程基础

使用JDK和MyEclipse编译运行Java应用程序；适当添加注释信息，通过javadoc生成注释文档；通过命令行参数传递“Hello world”字符串，并输出，通过JDK和MyEclipse编译运行。记录操作过程。

public class Hello
{
    public static void main(String args[])
    {
        System.out.println("Hello!");
    }
}

使用JDK和MyEclipse编译Java Applet，并建立HTML文档运行该Applet.打包mypackage,并压缩生成".jar"文件。记录操作过程。

import java.awt.*;
import java.applet.Applet;
public class HelloApplet extends Applet
{
    public void paint(Graphics g)
    {
        g.setColor(Color.red);
        g.drawString("Hello!",20,20);
    }
}
 
<html>
<applet code="HelloApplet.class"  height=100  width=300>
</applet>
</html>

输出下列数字形式。
①n=4
0 0 0 0
0 1 1 1
0 1 2 2
0 1 2 3
② n=4
1
1 2 1
1 2 3 2 1
1 2 3 4 3 2 1

public class a {
            public static void main(String[] args) {
                int n = 4;
            int[][] nums = new int[n][n];
    
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                        if (i >= j) {
                            nums[i][j] = j;
                        } else {
                            nums[i][j] = i;
                        }
                    }
                }
    
                for (int i = 0; i < n; i++) {
                    for (int j = 0; j < n; j++) {
                        System.out.print(nums[i][j] + " ");
                    }
                    System.out.println();
                }
    }
    }

采用一维数组输出等腰三角形的杨辉三角。

import java.util.Scanner;
public class Yang_Hui_Triangle {
    public static void main(String[] args) {
        Scanner triangle = new Scanner(System.in);
        System.out.println("请输入杨辉三角的层数");
        int i = 0;
        int j = 0;
        int n = 0;
        int k = 0;
        n = triangle.nextInt();
        int arr[] = new int[2000];
        k = 0;
        while (n-- != 0) {
            arr[k++] = 1;
            for (i = k - 2; i >= 1; i--)
                arr[i] += arr[i - 1];
            for (i = 0; i < n; i++)
                System.out.print(" ");
            for (i = 0; i < k; i++) {
                System.out.print(" ");
                System.out.print(arr[i]);
            }
            System.out.print("\n");
 
        }
    }
}

求二维数组的鞍点,即该位置上的元素在该行上最大，在列上最小。也可能无鞍点。

import java.util.Scanner;
 
public class Two_dimensional_array {
    public static void main(String[] args) {
        int arr[][] = new int[1000][1000];
        int i = 0;
        int j = 0;
        int i_max = 0;
        int j_max = 0;
        int pos = 0;
        int flag = 0;
        Scanner array = new Scanner(System.in);
        System.out.println("请输入二维数组中的行和列");
        i_max = array.nextInt();
        j_max = array.nextInt();
        for (i = 0; i < i_max; i++)
        {
            for(j = 0; j < j_max; j++)
            {
                arr[i][j] = array.nextInt();
            }
        }
        for (i = 0; i < i_max; ++i)
        {
 
            int max = arr[i][0];
            for (j = 1; j < j_max; ++j)
            {
                if (arr[i][j] > max)
                {
                    max = arr[i][j];
                    pos = j;
                }
            }
 
            for (j = 0; j < j_max; ++j)
            {
                if (arr[j][pos]<max)
                {
                    break;
                }
            }
 
            if (j == j_max)
            {
                System.out.println("该鞍点为："+arr[i][pos]);
                flag = 1;
                break;
            }
        }
        if (0 == flag)
        {
            System.out.println("没有鞍点");
        }
 
    }
}

判断回文字符串
回文是一种“从前向后读”和“从后向前读”都相同的字符串。如“rotor”是一个回文字符串。
程序中使用了两种算法来判断回文字符串：
算法一：分别从前向后和从后向前依次获得原串str的一个字符ch1、ch2，比较ch1和ch2，如果不相等，则str肯定不是回文串，yes=false，立即退出循环:否则继续比较，直到字符全部比较完，yes的值仍为true，才能肯定str是回文串。
算法二：将原串str反转成temp串，再比较两串，如果相等则是因文字符串。

import java.util.Scanner;
public class Palindrome_string {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Enter a string: ");
        String str = input.nextLine();
 
        if (isPalindrome(str)) {
            System.out.println(str + " is a palindrome.");
        } else {
            System.out.println(str + " is not a palindrome.");
        }
    }
 
    public static boolean isPalindrome(String str) {
        int i = 0;
        int j = str.length() - 1;
 
        while (i < j) {
            if (str.charAt(i) != str.charAt(j)) {
                return false;
            }
            i++;
            j--;
        }
        return true;
    }
    
    
}

实验二面向对象编程

设计复数类，成员变量包括实部和虚部，成员方法包括实现复数加法、减法、比较、字符串描述、比较是否相等等操作。

public class ComplexNumber {
        double real;
        double imaginary;
    
        public ComplexNumber(double real, double imaginary) {
            this.real = real;
            this.imaginary = imaginary;
        }
    
        public ComplexNumber add(ComplexNumber n) {
            double newReal = this.real + n.real;
            double newImaginary = this.imaginary + n.imaginary;
            return new ComplexNumber(newReal, newImaginary);
        }
    
        public ComplexNumber subtract(ComplexNumber n) {
            double newReal = this.real - n.real;
            double newImaginary = this.imaginary - n.imaginary;
            return new ComplexNumber(newReal, newImaginary);
        }
    
        public boolean equals(ComplexNumber n) {
            return (this.real == n.real && this.imaginary == n.imaginary);
        }
    
    
    
    
}

设计Teacher类，继承Person类。

public class Person {
     String name;
     int age;
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
        public static void main(String[] args) {
            Teacher teacher = new Teacher("wzr",20, "jit","professor");
            System.out.println("Teacher's name: " + teacher.getName());
            System.out.println("Teacher's age: " + teacher.getAge());
            System.out.println("Teacher's workfor: " + teacher.getworkfor());
            System.out.println("Teacher's title: " + teacher.gettitle());
        }
    
}
 
class Teacher extends Person {
 
    private String workfor;
    private String title;
 
    public Teacher(String name, int age, String workfor, String title) {
        super(name, age);
        this.workfor = workfor;
        this.title = title;
    }
 
    public String getworkfor() {
        return workfor;
    }
 
    public void setworkfor(String workfor) {
        this.workfor = workfor;
    }
 
    public String gettitle() {
        return title;
    }
 
    public void settitle(String title) {
        this.title = title;
    }
 
  
}

将Person类的成员变量改为出生日期，再设计age()方法求年龄。

public class Person2 {
    String Name;
    char Sex;
    int BirthYear;
    public Person2()
    {
        this.Name=null;
        this.Sex='M';
        this.BirthYear=0;
    }
    public Person2(String Name,char Sex,int BirthYear)
    {
        this.Name=Name;
        this.Sex=Sex;
        this.BirthYear=BirthYear;
    }
    public void age(int BirthYear)
    {
        System.out.println("age is:"+(2023 - BirthYear));
    }
    public void Information()
    {
        System.out.println("Personal Information:");
        System.out.println(Name+"\t"+Sex+"\t");
    }
 
    public static void main(String args[])
    {
        
        Teacher2 T1= new Teacher2();
        T1.Name="ZhangSan";
        T1.Sex='F';
        T1.WorkFor="JIT";
        T1.Title="professor";
        T1.EngagedIn="JAVA";
        T1.BirthYear = 2003;
        T1.Information();
        T1.age(2003);
        
    }
}
class Teacher2 extends Person2{
    String WorkFor;      
    String Title;       
    String EngagedIn;   
    public Teacher2()
    {
        this.WorkFor=null;
        this.Title=null;
        this.EngagedIn=null;
    }
    public Teacher2(String Name,char Sex,int BirthYear,String WorkFor,String Title,String EngagedIn)
    {
        super(Name,Sex,BirthYear);
        this.WorkFor=WorkFor;
        this.Title=Title;
        this.EngagedIn=EngagedIn;
    }
    
    public void age(int BirthYear)
    {
        super.age(BirthYear);
 
    }
    
    public void Information()
    {
        super.Information();
        System.out.println("Work for:"+WorkFor);
        System.out.println("Profession:"+EngagedIn+"\nTitle:"+Title);
        
    }
}

设计圆柱体类和圆椎体类，继承圆类Circle并实现Volume接口，计算表面积和体积。

interface Volume {
    double getVolume();
}
 
class Circle {
    protected double radius;
 
    public Circle(double radius) {
        this.radius = radius;
    }
 
    public double getRadius() {
        return radius;
    }
 
    public double getArea() {
        return Math.PI * radius * radius;
    }
}
 
class Cylinder extends Circle implements Volume {
    protected double height;
 
    public Cylinder(double radius, double height) {
        super(radius);
        this.height = height;
    }
 
    public double getHeight() {
        return height;
    }
 
    public double getVolume() {
        return getArea() * height;
    }
 
    public double getSurfaceArea() {
        return 2 * Math.PI * radius * (radius + height);
    }
}
 
class Cone extends Circle implements Volume {
    protected double height;
 
    public Cone(double radius, double height) {
        super(radius);
        this.height = height;
    }
 
    public double getHeight() {
        return height;
    }
 
    public double getVolume() {
        return (1.0 / 3.0) * getArea() * height;
    }
 
    public double getSurfaceArea() {
        double slantHeight = Math.sqrt(radius * radius + height * height);
        return Math.PI * radius * (radius + slantHeight);
    }
}

设计三角形类，继承图形抽象类，计算三角形面积和周长。

public class Graph {
    int edge;
    public Graph(int edge)
    {
        this.edge = edge;
    }
    public int getedge()
    {
        return edge;
    }
    public void setedge(int edge)
    {
       this.edge = edge; 
    }
    public static void main(String[] args) {
        
    }
}
 
class Triangle extends Graph{
    int Bottom_edge_length;
     int height;
     public Triangle(int edge,int Bottom_edge_length,int height)
     {
        super(edge);
        this.Bottom_edge_length = Bottom_edge_length;
        this.height = height;
 
     }
 
}

定义机动车接口（Automobile）和非机动车接口（Nonautomobile）,分别包含表示其运动模式的抽象方法；编写总的“车”类（VehicleClass），其中描述车名、车轮数，以及机动车和非机动车变量，该类实现机动车和非机动车接口；编写继承“车”类的公共汽车类（BusClass）和自行车类(BicycleClass)。

interface Automobile {
    void drive();
}
 
interface Nonautomobile {
    void pedal();
}
 
class VehicleClass implements Automobile, Nonautomobile {
    protected String vehicleName;
    protected int wheelCount;
 
    public VehicleClass(String vehicleName, int wheelCount) {
        this.vehicleName = vehicleName;
        this.wheelCount = wheelCount;
    }
 
    public String getVehicleName() {
        return vehicleName;
    }
 
    public int getWheelCount() {
        return wheelCount;
    }
 
    public void drive() {
        System.out.println(vehicleName + " is being driven.");
    }
 
    public void pedal() {
        System.out.println(vehicleName + " is being pedaled.");
    }
}
 
class BusClass extends VehicleClass implements Automobile {
    private int passengerCount;
 
    public BusClass(String vehicleName, int wheelCount, int passengerCount) {
        super(vehicleName, wheelCount);
        this.passengerCount = passengerCount;
    }
 
    public int getPassengerCount() {
        return passengerCount;
    }
 
    public void drive() {
        System.out.println(vehicleName + " is a bus and is being driven.");
    }
}
 
class BicycleClass extends VehicleClass implements Nonautomobile {
    private int gearCount;
 
    public BicycleClass(String vehicleName, int wheelCount, int gearCount) {
        super(vehicleName, wheelCount);
        this.gearCount = gearCount;
    }
 
    public int getGearCount() {
        return gearCount;
    }
 
    public void pedal() {
        System.out.println(vehicleName + " is a bicycle and is being pedaled.");
    }
}

试编码实现简单的银行业务：处理简单帐户存取款、查询。编写银行帐户类BankAccount,包含数据成员：余额（balance）、利率(interest)；操作方法：查询余额、存款、取款、查询利率、设置利率。再编写主类UseAccount，包含main()方法，创建BankAccount类的对象，并完成相应操作。

class BankAccount {
    private double balance;
    private double interest;
 
    public BankAccount(double balance, double interest) {
        this.balance = balance;
        this.interest = interest;
    }
 
    public double getBalance() {
        return balance;
    }
 
    public void deposit(double amount) {
        balance += amount;
        System.out.println("成功存款：" + amount);
    }
 
    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
            System.out.println("成功取款：" + amount);
        } else {
            System.out.println("余额不足，取款失败");
        }
    }
 
    public double getInterest() {
        return interest;
    }
 
    public void setInterest(double interest) {
        this.interest = interest;
        System.out.println("成功设置利率：" + interest);
    }
}
 
public class UseAccount {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000.0, 0.05);
 
        double balance = account.getBalance();
        System.out.println("当前余额：" + balance);
 
        account.deposit(500.0);
 
        balance = account.getBalance();
        System.out.println("当前余额：" + balance);
 
        account.withdraw(200.0);
 
        balance = account.getBalance();
        System.out.println("当前余额：" + balance);
 
        double interest = account.getInterest();
        System.out.println("当前利率：" + interest);
 
        account.setInterest(0.1);
 
        interest = account.getInterest();
        System.out.println("当前利率：" + interest);
    }
}

键盘输入两个int数字，并且求出和值。

mport java.util.Scanner;
 
public class ScannerSum{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int result = a + b;
        System.out.println("结果是："+result);
    }
}

模拟用户登录。定义用户类，属性为用户名和密码；录入用户和密码，对比用户信息，匹配成功登录成功，否则登录失败。登录失败时，当用户名错误，提示没有该用户。登录失败时，当密码错误时，提示密码有误。

mport java.util.Scanner;
 
public class User {
    private String username;
    private String pwd;
 
    public User(String username, String pwd) {
        this.username = username;
        this.pwd = pwd;
    }
 
    public String getUsername() {
        return username;
    }
 
    public void setUsername(String username) {
        this.username = username;
    }
 
    public String getPwd() {
        return pwd;
    }
 
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
    public static void main(String[] args) {
        User[] users = new User[3];
        users[0] = new User("user1", "password1");
        users[1] = new User("user2", "password2");
        users[2] = new User("user3", "password3");
 
        Scanner scanner = new Scanner(System.in);
        System.out.print("Please enter your username: ");
        String username = scanner.nextLine();
        System.out.print("Please enter your password: ");
        String password = scanner.nextLine();
 
        boolean found = false;
        for (User user : users) {
            if (user.getUsername().equals(username)) {
                found = true;
                if (user.getPwd().equals(password)) {
                    System.out.println("Login successful!");
                    break;
                } else {
                    System.out.println("Password is incorrect!");
                    break;
                }
            }
        }
        if (!found) {
            System.out.println("User not found!");
        }
    }

把字符串“2023-03-22 16:40:30”转换为时间类型。

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class Time {
    public static void main(String[] args) {
        String dateTimeStr= "2023-03-22 16:40:30";
         DateTimeFormatter formatter02 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
         LocalDateTime localDateTime=LocalDateTime.parse(dateTimeStr,formatter02);
         System.out.println(localDateTime);
         String format = localDateTime.format(formatter02);
         System.out.println(format);
 
    }

生成一个随机100内小数，转换为保留两位小数的字符串，不考虑四舍五入的问题。

import java.text.DecimalFormat;
public class random_number {
        public static void main(String[] args) {
            double d = Math.random()*100;
            DecimalFormat df = new DecimalFormat("0.00");
            String str = df.format(d);
            System.out.println(str);
    
        }

计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？

public class Int {
        public static void main(String[] args) {
            int count = 0;
            double min = - 10.8;
            double max = 5.9;
            for (int i = (int)min; i < max; ++i) {
                if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
                    if (i % 1 == 0) {
                        count++;
                    }
                }
            }
            System.out.println("There are " + count + " integers the condition.");
        }

高精度计算1！+2！+3！+……+n! (n<50)

import java.math.BigInteger;
public class FactorialSum {
    public static BigInteger factorial(BigInteger n) {
        if (n.equals(BigInteger.ZERO) || n.equals(BigInteger.ONE)) {
            return BigInteger.ONE;
        } else {
            return n.multiply(factorial(n.subtract(BigInteger.ONE)));
        }
    }
 
    public static BigInteger calculateFactorialSum(int n) {
        BigInteger sum = BigInteger.ZERO;
        for (int i = 1; i <= n; i++) {
            sum = sum.add(factorial(BigInteger.valueOf(i)));
        }
        return sum;
    }
 
    public static void main(String[] args) {
        int n = 10; 
        BigInteger result = calculateFactorialSum(n);
        System.out.println("1! + 2! + 3! + ... + " + n + "! = " + result);
    }

编写一个信息录入程序，获取用户输入的姓名和年龄。如果用户输入的年龄不是正确的年龄数字（如0.5），则抛出异常并让用户重新输入；如果年龄正确，则打印用户输入的信息。

import java.util.Scanner;
public class InformationEntry {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
 
        String name;
        int age;
 
        try {
            System.out.print("请输入姓名：");
            name = scanner.nextLine();
 
            System.out.print("请输入年龄：");
            String ageInput = scanner.nextLine();
            age = Integer.parseInt(ageInput);
 
            if (age <= 0) {
                throw new IllegalArgumentException("年龄必须是一个正整数");
            }
 
            System.out.println("姓名：" + name);
            System.out.println("年龄：" + age);
        } catch (NumberFormatException e) {
            System.out.println("年龄输入有误，请输入一个整数年龄");
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }

实验三泛形与集合

定义一个继承结构：

属性：名字、年龄
行为：吃东西

波斯猫方法体打印：一只叫做XXX的，X岁的波斯猫，正在吃小饼干~
狸花猫方法体打印：一只叫做XXX的，X岁的狸花猫，正在吃鱼儿~
泰迪方法体打印：一只叫做XXX的，X岁的泰迪，正在吃骨头，边吃边蹭~
哈士奇方法体打印：一只叫做XXX的，X岁的哈士奇，正在吃骨头，边吃边拆家~
测试类中定义一个方法用于饲养动物
public static void keepPet(ArrayList<???> list) {
// 遍历集合，调用动物的eat方法
}
要求：
a、该方法能养所有品种的猫，但是不能养狗
b、该方法能养所有品种的狗，但是不能养猫
c、该方法能养所有的动物，但是不能传递其他类型

import java.util.ArrayList;
class Animal{
    protected String name;
    protected int age;
    public Animal(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
 
    public void eat() {
        System.out.println("一只叫做" + name + "的" + age + "岁的动物正在吃东西~");
    }
}
class Cat extends Animal{
    public Cat(String name, int age){
        super(name, age);
    }
 
}
class PersianCat  extends Animal{
    public PersianCat (String name, int age){
        super(name, age);
    }
    public void eat() {
        System.out.println("一只叫做" + name + "的" + age + "岁的波斯猫，正在吃小饼干~");
    }
 
}
 class TabbyCat  extends Animal{
    public TabbyCat (String name, int age){
        super(name, age);
    }
    public void eat() {
        System.out.println("一只叫做" + name + "的" + age + "岁的狸花猫，正在吃鱼儿~");
    }
}
class Dog extends Animal{
    public Dog(String name, int age){
        super(name, age);
    }
 
}
class Husky extends Dog {
    public Husky(String name, int age) {
        super(name, age);
    }
    public void eat() {
        System.out.println("一只叫做" + name + "的" + age + "岁的哈士奇，正在吃骨头，边吃边拆家~");
    }
}
class Teddy extends Dog {
    public Teddy(String name, int age) {
        super(name, age);
    }
    public void eat() {
        System.out.println("一只叫做" + name + "的" + age + "岁的泰迪，正在吃骨头，边吃边蹭~");
    }
}
public class AnimalTest {
    public static void keepPet(ArrayList<? extends Animal> list) {
        for (Animal animal : list) {
            animal.eat();
        }
    }
    public static void main(String[] args) {
        ArrayList<Animal> animalList = new ArrayList<>();
        animalList.add(new PersianCat("小白", 2));
        animalList.add(new TabbyCat("小黑", 3));
        animalList.add(new Husky("小花", 1));
        animalList.add(new Teddy("小黄", 2));
        
        keepPet(animalList);
    }
    
    
}

定义Employee类
（1）该类包含：private成员变量name，sal，birthday，其中birthday为MyDate类的对象；
（2）为每一个属性定义getter，setter方法；
（3）重写toString方法输出name，sal，birthday
（4）MyDate类包含：private成员变量year，month，year；并为每一个属性定义getter，setter方法；
（5）创建该类的3个对象，并把这些对象放入ArrayList集合中（ArrayList需使用泛型来定义），对集合中的元素进行排序，并遍历输；
排序方式：调用ArrayList的sort方法，传入Comparator对象[使用泛型]，先按照name排序，如果name相同，则按生日日期的先后排序。

import java.util.ArrayList;
import java.util.Comparator;
class MyDate {
    private int year;
    private int month;
    private int day;
 
    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
 
    public int getYear() {
        return year;
    }
 
    public int getMonth() {
        return month;
    }
 
    public int getDay() {
        return day;
    }
 
    public void setYear(int year) {
        this.year = year;
    }
 
    public void setMonth(int month) {
        this.month = month;
    }
 
    public void setDay(int day) {
        this.day = day;
    }
 
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}
 
public class Employee {
    private String name;
    private double sal;
    private MyDate birthday;
 
    public Employee(String name, double sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }
 
    public String getName() {
        return name;
    }
 
    public double getSal() {
        return sal;
    }
 
    public MyDate getBirthday() {
        return birthday;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setSal(double sal) {
        this.sal = sal;
    }
 
    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }
 
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", birthday=" + birthday +
                '}';
    }
    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(new Employee("p1", 10000, new MyDate(1990, 1, 1)));
        employees.add(new Employee("p2", 20000, new MyDate(1995, 2, 1)));
        employees.add(new Employee("p3", 15000, new MyDate(1990, 3, 1)));
 
        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee p1, Employee p2) {
                int nameCompare = p1.getName().compareTo(p2.getName());
                if (nameCompare != 0) {
                    return nameCompare;
                } 
                else {
                    MyDate d1 = p1.getBirthday();
                    MyDate d2 = p2.getBirthday();
                    if (d1.getYear() != d2.getYear()) {
                        return d1.getYear() - d2.getYear();
                    } 
                    else if (d1.getMonth() != d2.getMonth()) 
                    {
                        return d1.getMonth() - d2.getMonth();
                    } else {
                        return d1.getDay() - d2.getDay();
                    }
                }
            }
        });
 
        for (Employee employee : employees) {
            System.out.println(employee);
        }
    }
}

学者在进行数据统计的时候，为了避免极值的影响，通常会忽略掉最大值和最小值，然后对剩余元素进行统计，请编写程序完成去除极值的工作。
输入格式:
一行字符串，数字均为整数，之间使用空格分开（元素个数>=3）。
输出格式:
去除两端极值后的剩余元素，升序排列，之间使用空格分开
输入样例:
10 3 2 -1 5 3 4 3 0 3 2
输出样例:
0 2 2 3 3 3 3 4 5

import java.util.Arrays;
import java.util.Scanner;
public class RemoveExtremun{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        String[] strArray = input.split(" ");
        int[] intArray = new int[strArray.length];
        for (int i = 0; i < strArray.length; i++) {
            intArray[i] = Integer.parseInt(strArray[i]);
        }
        Arrays.sort(intArray);
        for (int i = 1; i < intArray.length - 1; i++) {
            System.out.print(intArray[i] + " ");
        }
    }

判断e盘下是否有mytemp文件夹，如果没有就创建该文件夹。在该目录下创建文件hello.txt 并写入内容 hello world！如果该文件已存在，提示文件已存在。

import java.io.File;
import java.io.IOException;
import java.io.FileWriter;
public class IsFile {
    public static void main(String[] args) {
        String directoryPath = "/Users/wzr/Desktop";
        String filePath = directoryPath + "/hello.txt";
        File directory = new File(directoryPath);
        if (!directory.exists()) {
            directory.mkdirs();
        }
        File file = new File(filePath);
        if (!file.exists()) {
            try {
                file.createNewFile();
                FileWriter writer = new FileWriter(file);
                writer.write("hello world!");
                writer.close();
                System.out.println("文件已创建并写入内容");
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            System.out.println("文件已存在");
        }
    }
    
}

使用文件字节输入/输出流，合并两个指定文件，合并后的数据要求是已排序的。

import java.io.*;
 
public class MergeAndSortFiles {
    public static void main(String[] args) {
        String file1Path = "file1.txt";  // 第一个文件的路径
        String file2Path = "file2.txt";  // 第二个文件的路径
        String mergedFilePath = "merged.txt";  // 合并后的文件路径
        mergeAndSortFiles(file1Path, file2Path, mergedFilePath);
    }
    public static void mergeAndSortFiles(String file1Path, String file2Path, String mergedFilePath) {
        try {
            FileInputStream file1Input = new FileInputStream(file1Path);
            FileInputStream file2Input = new FileInputStream(file2Path);
            FileOutputStream mergedOutput = new FileOutputStream(mergedFilePath);
            mergeFiles(file1Input, mergedOutput);
            mergeFiles(file2Input, mergedOutput);
            sortFile(mergedFilePath);
            System.out.println("文件合并并排序完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void mergeFiles(FileInputStream input, FileOutputStream output) throws IOException {
        int data;
        while ((data = input.read()) != -1) {
            output.write(data);
        }
        input.close();
    }
 
    public static void sortFile(String filePath) {
        try {
            FileInputStream fileInput = new FileInputStream(filePath);
            DataInputStream dataInput = new DataInputStream(fileInput);
 
            int fileSize = dataInput.available();
            byte[] data = new byte[fileSize];
            dataInput.readFully(data);
            dataInput.close();
            for (int i = 0; i < fileSize - 1; i++) {
                for (int j = 0; j < fileSize - i - 1; j++) {
                    if (data[j] > data[j + 1]) {
                        byte temp = data[j];
                        data[j] = data[j + 1];
                        data[j + 1] = temp;
                    }
                }
            }
            FileOutputStream fileOutput = new FileOutputStream(filePath);
            DataOutputStream dataOutput = new DataOutputStream(fileOutput);
            dataOutput.write(data);
            dataOutput.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用BufferedReader 读取一个文本文件，每行加上一个分号一并输出到屏幕上，并保存到另一个文件中。

import java.io.*;
public class AddSemicolonToFile {
    public static void main(String[] args) {
        String inputFilePath = "input.txt";  
        String outputFilePath = "output.txt";  
 
        addSemicolonToFile(inputFilePath, outputFilePath);
    }
 
    public static void addSemicolonToFile(String inputFilePath, String outputFilePath) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader(inputFilePath));
            FileWriter writer = new FileWriter(outputFilePath);
 
            String line;
            while ((line = reader.readLine()) != null) {
                String modifiedLine = line + ";";  
 
                System.out.println(modifiedLine);  
                writer.write(modifiedLine + "\n");  
            }
 
            reader.close();
            writer.close();
 
            System.out.println("处理完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

实验四图形用户界面

计算器设计

import javax.swing.*;
import java.awt.*;
 
public class Calculator extends JFrame {
    public Calculator() {
        JFrame JWindow = new JFrame("计算器");
        JWindow.setBackground(Color.BLACK);
        JWindow.setSize(350,310);
        JWindow.setLocationRelativeTo(null);
        JWindow.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        JWindow.setResizable(false); 
        Font font = new Font("宋体", Font.PLAIN, 20);
        JPanel Panel1 = new JPanel();
        JPanel Panel2 = new JPanel(new GridLayout(4,4,8,12));
        JTextArea JText = new JTextArea(1,16);
        JText.setFont(font);
        JText.setPreferredSize(new Dimension(300,30));
        JText.setEditable(false);
        Panel1.add(JText);
        String BtnStr[] = { "1","2","3","+",
                            "4","5","6","-",
                            "7","8","9","x",
                            ".","0","=","÷"};
        JButton Btn[] = new JButton[BtnStr.length];
        for(int i = 0 ; i < BtnStr.length ; i++ ){
            Btn[i]=new JButton(BtnStr[i]);
            Btn[i].setFont(font);
            Dimension dimension = new Dimension(70,42);
            Btn[i].setPreferredSize(dimension);
            Panel2.add(Btn[i]);
        }
        
        
        JWindow.add(Panel1,BorderLayout.NORTH);
        JWindow.add(Panel2,BorderLayout.CENTER);
        JWindow.setVisible(true);
    }
 
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
    }
}

整数进制转换
将一个十进制整数分别转换成二进制、八进制和十六进制整数。

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class NumberConverterGUI extends JFrame implements ActionListener {
    
    private JLabel decimalLabel, binaryLabel, octalLabel, hexadecimalLabel;
    private JTextField decimalField, binaryField, octalField, hexadecimalField;
    private JButton convertButton;
    
    public NumberConverterGUI() {
        decimalLabel = new JLabel("Decimal:");
        decimalField = new JTextField(10);
        binaryLabel = new JLabel("Binary:");
        binaryField = new JTextField(10);
        octalLabel = new JLabel("Octal:");
        octalField = new JTextField(10);
        hexadecimalLabel = new JLabel("Hexadecimal:");
        hexadecimalField = new JTextField(10);
        convertButton = new JButton("Convert");
        convertButton.addActionListener(this);
        
        JPanel panel = new JPanel(new GridLayout(5, 2, 10, 10));
        panel.add(decimalLabel);
        panel.add(decimalField);
        panel.add(binaryLabel);
        panel.add(binaryField);
        panel.add(octalLabel);
        panel.add(octalField);
        panel.add(hexadecimalLabel);
        panel.add(hexadecimalField);
        panel.add(new JLabel(""));
        panel.add(convertButton);
        setContentPane(panel);
        
        setTitle("Number Converter");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        pack();
        setLocationRelativeTo(null);
        setVisible(true);
    }
    
    public void actionPerformed(ActionEvent e) {
        int decimalNumber = Integer.parseInt(decimalField.getText());
        
        String binaryNumber = Integer.toBinaryString(decimalNumber);
        String octalNumber = Integer.toOctalString(decimalNumber);
        String hexadecimalNumber = Integer.toHexString(decimalNumber);
        
        binaryField.setText(binaryNumber);
        octalField.setText(octalNumber);
        hexadecimalField.setText(hexadecimalNumber);
    }
    
    public static void main(String[] args) {
        new NumberConverterGUI();
    }
}

模拟裁判评分。
设计如图所示图形界面，显示n个裁判的评分，根据制定规则计算出最后得分。要求：图形界面采用表格显示裁判评分，随裁判人数变化而变化；指定分数范围，若超出，则异常处理；得分规则有指定接口约定，由多个接口对象给出多种得分规则，如求平均数值，或去掉一个最高分和一个最低分后，再求平均值。

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
public class ScoreChartInterface extends JFrame implements ActionListener {
 
    private List<Double> scores;
    private JLabel scoreLabel, resultLabel;
    private JTextField scoreField;
    private JButton addButton, calculateButton;
 
    interface ScoringRule {
        double calculateScore(List<Double> scores);
    }
 
    class AverageScoringRule implements ScoringRule {
        @Override
        public double calculateScore(List<Double> scores) {
            double sum = 0;
            for (double score : scores) {
                sum += score;
            }
            return sum / scores.size();
        }
    }
 
    class TrimmedAverageScoringRule implements ScoringRule {
        @Override
        public double calculateScore(List<Double> scores) {
            if (scores.size() <= 2) {
                throw new IllegalArgumentException("At least 3 scores are required for trimmed average scoring.");
            }
 
            List<Double> sortedScores = new ArrayList<>(scores);
            Collections.sort(sortedScores);
 
            double sum = 0;
            for (int i = 1; i < sortedScores.size() - 1; i++) {
                sum += sortedScores.get(i);
            }
            return sum / (scores.size() - 2);
        }
    }
 
    public ScoreChartInterface() {
        scores = new ArrayList<>();
 
        scoreLabel = new JLabel("Score:");
        scoreField = new JTextField(10);
        addButton = new JButton("Add");
        addButton.addActionListener(this);
 
        resultLabel = new JLabel("Result: ");
 
        calculateButton = new JButton("Calculate");
        calculateButton.addActionListener(this);
 
        JPanel panel = new JPanel(new GridLayout(4, 1, 10, 10));
        panel.add(scoreLabel);
        panel.add(scoreField);
        panel.add(addButton);
        panel.add(resultLabel);
        panel.add(calculateButton);
        setContentPane(panel);
 
        setTitle("Score Chart");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        pack();
        setLocationRelativeTo(null);
        setVisible(true);
    }
 
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == addButton) {
            try {
                double score = Double.parseDouble(scoreField.getText());
                scores.add(score);
                scoreField.setText("");
            } catch (NumberFormatException ex) {
                JOptionPane.showMessageDialog(this, "Invalid score format!", "Error", JOptionPane.ERROR_MESSAGE);
            }
        } else if (e.getSource() == calculateButton) {
            if (scores.isEmpty()) {
                JOptionPane.showMessageDialog(this, "No scores available!", "Error", JOptionPane.ERROR_MESSAGE);
                return;
            }
 
            ScoringRule scoringRule = new AverageScoringRule(); 
            double finalScore = scoringRule.calculateScore(scores);
            resultLabel.setText("Result: " + finalScore);
        }
    }
 
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            new ScoreChartInterface();
        });
    }
}

文章来源:https://blog.csdn.net/weixin_69423932/article/details/135547690
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！

Java实验（超详细）

目录

实验一 Java编程基础

实验二 面向对象编程

实验三 泛形与集合

实验四 图形用户界面

实验二面向对象编程

实验三泛形与集合

实验四图形用户界面