Java程序设计：选实验6 输入输出应用

(1) 编写一个程序，如果文件Exercisel_01.txt 不存在，就创建一个名为Exercisel_01.txt 的文件。向这个文件追加新数据。使用文本I/O将20个随机生成的整数写入这个文件。文件中的整数用空格分隔。

package 选实验6;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;

public class task1 {
	public static void main(String[] args)
	{
		String fileName = "Exercise_01.txt";
		
		//检查文件是否存在，如果不存在则创建
		File file = new File(fileName);
		try {
			if(!file.exists()) {
				file.createNewFile();
				System.out.println(fileName+"已创建。");
			}
			//写入20个随机数字
			BufferedWriter writer = new BufferedWriter(new FileWriter(fileName,true));
			Random random = new Random();
			for(int i=0;i<20;i++)
			{
				int num = random.nextInt();
				//每个整数之间用空格隔开
				writer.write(Integer.toString(num)+" ");
			}
			//关闭BufferWriter,确保资源被释放
			writer.newLine();
			writer.close();
			System.out.println(fileName+"已被写入数据。");
			
			//打开文件并读取内容和打印内容
			BufferedReader reader = new BufferedReader(new FileReader(file));
			String lineString;
			System.out.println(fileName+"里面的内容为：");
			while((lineString = reader.readLine())!=null) 
			{
				System.out.println(lineString);
			}
			reader.close();
			
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		//删除文件，以便能够多次运行
		if (file.delete()) {
            System.out.println(fileName+"已删除。" );
        } else {
            System.out.println(fileName+"无法删除");
        }
	}
}

(2) 编写一个程序，如果文件Exercisel_02.dat 不存在，就创建一个名为Exercisel_02.dat 的文件。向这个文件追加新数据。使用二进制I/O 将20个随机生成的整数写入这个文件中。利用二进制I/O读取这个文件中的内容并显示。

package 选实验6;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Random;

public class task2 {
	public static void main(String[] args) {
		String fileName = "Exercisel_02.dat";
		
		//检查文件是否存在，如果不存在则创建
		File file = new File(fileName);
		try {
			if(!file.exists())
			{
				file.createNewFile();
				System.out.println(fileName+"已创建。");
			}
			//写入20个随机数字
			DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream(fileName,true));
			Random random = new Random();
			for(int i=0;i<20;i++)
			{
				int num = random.nextInt();
				//每个整数之间用空格隔开
				dataOutputStream.writeInt(num);
			}
			//关闭DataOutputStream,确保资源被释放
			dataOutputStream.close();
			System.out.println(fileName+"已被写入数据。");
			
			//打开文件并读取内容和打印内容
			DataInputStream dataInputStream = new DataInputStream(new FileInputStream(fileName));
			System.out.println(fileName+"里面的内容为：");
			while(dataInputStream.available()>0)
			{
				int num = dataInputStream.readInt();
				System.out.print(num+" ");
			}
			System.out.println();
			dataInputStream.close();
		}
		catch (IOException e) {
			e.printStackTrace();
		}
		//删除文件，以便能够多次运行
		if (file.delete()) {
            System.out.println(fileName+"已删除。" );
        } else {
            System.out.println(fileName+"无法删除");
        }
	}
}

(3) 对一个学生成绩单进行读写操作。请直接下载blackboard上提供的data.txt文件作为数据源。具体要求如下：

1. 新建一个可序列化的Student类，其中包括四个成员变量：int型学号、String类型学生名字、String类型学生所在学院、int型成绩（参考data.txt文件）。重写toString方法用于打印Student对象。
2. 使用BufferedReader从data.txt文件中读取数据，并存放到一个集合对象中，要求按照学生名字的字母顺序升序排列。
3. 创建一个本地文件output.txt，将集合中的数据序列化到此文件中。（10分）

将output.txt中的数据反序列化，按照降序输出所有成绩在92分以上的学生信息；如果学生成绩相同，则按照学生名字的字母顺序降序输出。

package 选实验6;

import java.io.*;
import java.util.*;

// 新建一个可序列化的Student类
// 实现Serializable 接口，用于可序列化类
// 实现Comparable接口，用于排序
class Student implements Serializable,Comparable{
	// 保证在对象序列化和反序列化过程中确保版本一致性
	private static final long serialVersionUID = 1L;
	private int studentId;
    private String studentName;
    private String college;
    private int grade;
    
    // 构造方法，用于创建Student对象
    public Student(int studentId, String studentName, String college, int grade) {
        this.studentId = studentId;
        this.studentName = studentName;
        this.college = college;
        this.grade = grade;
    }
    
    // 重写toString方法，用于打印Student对象信息
    @Override
    public String toString() {
    	String res;
        res = "学生{" +
                "学号：" + studentId +
                "; 名字：" + studentName +  
                "; 学院：" + college + 
                "; 成绩：" + grade +
                '}';
        return res;
    }
    
    // 实现Comparable接口的compareTo方法，用于按学生名字升序排列
     @Override
     public int compareTo(Student one) {
        return this.studentName.compareTo(one.studentName);
     }
    
    // 用于（d）问题得到成绩
    public int getGrade() {
    	return grade;
    }
    
    // 用于（d）问题得到学生的姓名
    public String getStudentName() {
    	return studentName;
    }
}
// 主类task3
public class task3 {

	public static void main(String[] args) {
		// 数据文件名
		String fileName = "data.txt";
		
		// 从文件读取数据，并存到集合对象studentList中
		List students = readStudentToList(fileName);
		
		// 按学生名字升序排列
        Collections.sort(students);
        
        // 打印排序后的学生信息
        // for (Student student : students) {
        //    System.out.println(student);
        //}
        
        String fileName1 = "output.txt";
        //检查文件是否存在，如果不存在则创建
  		File file = new File(fileName1);
  		try {
  			if(!file.exists())
  			{
  				file.createNewFile();
  				System.out.println(fileName1+"已创建。");
  			}
  		}
  		catch (IOException e) {
  			e.printStackTrace();
  		}
  		
  		// 序列化数据到output.txt
  		serialize(students,fileName1);
  		
  		// 反序列化数据
  		List students1 = deserialize(fileName1);
  		
  		// 输出成绩在92分以上的学生
  		show92up(students1); 		
  		
  	    //删除文件，以便能够多次运行
		if (file.delete()) {
	          System.out.println(fileName1+"已删除。" );
	      } else {
	          System.out.println(fileName1+"无法删除");
	      }
	}
    
	// 从文件中读取数据，返回一个包含Student对象的List
	private static List readStudentToList(String fileName){
		// 用于返回List的临时变量
		List tempList = new ArrayList<>();
		
		try(BufferedReader reader = new BufferedReader(new FileReader(fileName))){
			String lineString;
			//逐行读取文件内容
			while((lineString = reader.readLine())!=null) {
				// 拆分获取每个学生的具体信息
				String[] strings = lineString.split(" ");
				// 获取后创建Student对象
				Student temp = new Student(Integer.parseInt(strings[0]),
						strings[1], strings[2], Integer.parseInt(strings[3]));
				// 将创建后的对象加入List中
				tempList.add(temp);
			}
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		// 返回包含Student对象的List
		return tempList;
	}
	
	// 序列化集合中的数据到output.txt中
	private static void serialize(List temp,String fn) {
		// 在这里是 ObjectOutputStream）会在代码块结束时自动关闭,不需要显式调用 close() 方法来释放资源
		try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(fn))){
			oos.writeObject(temp);
		}catch (IOException e) {
            e.printStackTrace();
        }
	}
	
	// 将output.txt中的数据反序列化
	private static Listdeserialize(String fn){
		// 用于返回包含Student的List
		List tempList = new ArrayList<>();		
		// 将反序列化后的对象转换为 List
		try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fn))) {
			Object object = ois.readObject();
			
			//判断 object 是否是 List 类型
			if(object instanceof List) {
				//将 object 强制转换为 List 类型，可以逐个遍历其中的元素
				List unkown = (List) object;			
				// 遍历List中是否为Student类
				for(Object i : unkown) {
					// 如果是就加入List（强制转换以保证一定为Student类）
					if(i instanceof Student) {
						tempList.add((Student)i);
					}else {
						System.err.println("列表里有不是学生的元素！");
					}
				}
			}else {
				System.err.println("这不是我们想要的列表！");
			}
		}catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        // 返回包含学生的List
		return tempList;
	}
	
	// 按照规定输出成绩在92分以上的学生信息
	private static void show92up(Listtemp){
		temp.stream()// 将集合转换为流
		// 过滤操作，保留成绩大于92的学生
		.filter(t->t.getGrade()>92)
		// 排序操作，首先按照学生成绩降序排序，然后按照学生名字的字母顺序升序排序
        // 使用 Comparator.comparing 方法，通过方法引用指定按照哪个属性进行比较
		.sorted(Comparator.comparing(Student::getGrade).reversed().
				thenComparing(Student::getStudentName))
		// 遍历操作，将每个学生信息打印到控制台
		.forEach(System.out::println);
	}
}