常州工学院Java作业04

第1关：练习-Java输入输出之File类之获取文件信息

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 间编写程序代码，输出给定目录下的最大文件和最小文件名，具体要求如下：

• 接收给定字符串（如：/test）；
• 输出给定目录下的最大文件和最小文件名以及它们的文件大小(不考虑子目录)。

测试说明

平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。

例： 测试输入：

1. /test

预期输出：

1. 最大的文件是d1.txt，其大小是80字节
2. 最小的文件是d2.txt，其大小是15字节

   import java.io.*;
   import java.util.Arrays;
   import java.util.Scanner;
    
   public class FileTest {
       public static void main(String[] args) throws IOException {
           // 请在Begin-End间编写完整代码
           /********** Begin **********/
           // 接收给定字符串（目录）
           Scanner input = new Scanner(System.in);
           String str = input.next();
           // 遍历目录，输出最小文件和最大文件名以及它们的大小
           File file = new File(str);
           String Max = null;
           String Min = null;
           long max = 0;
           long min = 100;
           File[] list = file.listFiles();
           for (int i = 0;i < list.length;i ++){
               if (list[i].isFile() & list[i].length() > max & list[i].length() > 0){
                   Max = list[i].getName();
                   max = list[i].length();
               }
               if(list[i].isFile() & list[i].length() < min & list[i].length() > 0){
                   Min = list[i].getName();
                   min = list[i].length();
               }
           }
           System.out.println("最大的文件是" + Max + "，"+"其大小是" + max + "字节");
           System.out.println("最小的文件是" + Min + "，"+"其大小是" + min + "字节");
               /********** End **********/
       }           
   }

练习-Java输入输出之文件字节IO流之合并文件

任务描述

本关任务：把给定的多个文件合并成一个文件。

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 间编写程序代码，把给定的多个文件合并成一个文件。具体要求如下：

• 接收给定的一行字符串（如：/test，a.txt。其中逗号前为一个目录，该目录下存储着子文件，逗号后为目标文件，用于存储各子文件合并的内容；
• 把给定目录下的所有子文件的内容合并到目标文件中；
• 输出目标文件大小，示例：“最后目标文件的大小：X字节”；
• 给定子文件的命名规则：假如目标文件为 a.txt，则子文件为 a.txt-1、a.txt-2、…、a.txt-n。

注意：请按照子文件后缀数字按照从小到大依次合并到目标文件。

测试说明

平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。

例： 测试输入：

1. /test/，a.txt

预期输出（第一行为编程要求中要求输出的提示语句，后面为后台使用 cat 命令查看目标文件产生的结果）：

1. 最后目标文件的大小：31字节
2. 888hy67
3. ddsljcnjf746
4. howtodoit

注意：最后有一个空行。

import java.io.*;
import java.util.Scanner;
 
public class FileTest {
 
    public static void main(String[] args) throws IOException {
        
        Scanner scanner = new Scanner(System.in);     // 获取给定字符串
        String s = scanner.nextLine();
        
        // 请在Begin-End间编写完整代码
        /********** Begin **********/
        
        // 切割给定字符串，得到子文件目录和目标文件名
        String[] strs= s.split("，");
        // 循环读取子文件内容，写入到目标文件
        File f1=new File(strs[0]);
        File dest = new File(strs[0]+strs[1]);
 
        FileOutputStream fos = new FileOutputStream(dest,true);
 
        File[] files = f1.listFiles();
        for(File file:files){
        FileInputStream fis = new FileInputStream(file);
        int len=0;
        byte[] by = new byte[1024];
        while((len=fis.read(by))!=-1)
            fos.write(by,0,len);
        fis.close();
        }
        // 输出目标文件大小
        System.out.println("最后目标文件的大小："+dest.length()+"字节");
 
        fos.close();
        /********** End **********/
        BufferedReader re = new BufferedReader(new FileReader(strs[0]+strs[1]));
        String sss=null;
        while((sss=re.readLine())!=null)
        System.out.println(sss);
        re.close();
    }
}

 

学习-Java输入输出之对象IO流之序列化一个对象

任务描述

本关任务：序列化给定 Student 对象到给定文件中，再通过反序列化把其转化为一个对象。

相关知识

之前我们学习了 InputStream（字节输入流）和 OutputStream (字节输出流)，下面我们来了解一下它们的子类—ObjectInputStream (对象输入流)和 ObjectOutputStream（对象输出流）。

为什么要有对象流

有的时候，我们可能需要将内存中的对象持久化到硬盘上（序列化），或者将硬盘中的对象信息读到内存中（反序列化），这个时候我们需要使用对象流。

序列化和反序列化

序列化： 是对象转换成一个字节序列的过程，是一个写操作。 反序列化：一个字节序列转换成对象的过程 ，是一个读操作。 序列化和反序列化中对象所对应的类，必须是实现 Serializable 接口。

ObjectOutputStream（对象输出流）

ObjectOutputStream 是 OutputStream 的子类，也叫做序列化流。该流把对象转成字节数据输出到文件中保存，可实现对象的持久存储。

ObjectOutputStream 的构造方法

构造方法	说明
ObjectOutputStream(OutputStream out)	使用底层输出流创建 ObjectOutputStream 对象

构造方法示例：

1.  public static void main(String[] args) throws IOException {
2.         // 通过文件字节输出流创建对象输出流
3.         ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("C:\\Users\\yy\\Desktop\\d.txt"));
4.     }

ObjectOutputStream 的常用方法

下表是它的常用方法：

方法	说明
write(byte[] w，int off，int len)	把字节数组中偏移量从 off 开始的 len 个字节写入此输出流
write(byte [] b)	将字节数组写入此输出流
writeBooolean()、writeByte()、writeShort()、writeInt()	将指定的基本数据类型以字节的方式写入到输出流
flush()	刷新此输出流并强制写出所有缓冲的输出字节
writeUTF(String s)	将字符串格式化顺序写入底层的输出流
writeObject(Object obj)	特有的方法，将指定的对象写入 ObjectOutputStream 流

通过 writeObject 方法将 Hero 对象写入文件示例：

Hero 类：

1. import java.io.Serializable;
2.  public class Hero implements Serializable {     // 实现Serializable接口
4.     private static final long serialVersionUID = 1L;     //表示这个类当前的版本
5.     public String name;
6.     public float hp;
8. }

Test类：

1. public class Test {
2. public static void main(String[] args) throws IOException {
3.         //创建一个Hero对象
4.         Hero h = new Hero();
5.         // 设置属性
6.         h.name = "garen";
7.         h.hp = 616;
8.         // 准备一个文件用于保存该对象
9.         File f =new File("C:\\Users\\yy\\Desktop\\d.txt");
10.         try(
11.         // 将Hero对象写入文件
12.         ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(f));){
13.             objectOutputStream.writeObject(h);
14.         }
15.     }
16.     }

执行结果：将对象写入了 d.txt 文件。

注意：Hero 类必须实现 Serializable 接口。

ObjectInputStream（对象输入流）

ObjectInputStream 是 InputStream 的子类，也叫做反序列流。该流将之前使用 ObjectOutputStream 序列化的原始数据恢复为对象，以流的方式读取对象。 ######ObjectInputStream 的构造方法

下表中是它的构造方法：

构造方法	说明
ObjectInputStream(InputStream in)	使用底层输入流创建 ObjectInputStream 对象

构造方法使用示例：

1. public static void main(String[] args) throws IOException {
2.         // 通过文件字节输入流创建对象输入流对象
3.         ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("C:\\Users\\yy\\Desktop\\d.txt"));
4.     }

ObjectInputStream 的常用方法

下表是它的常用方法：

方法	说明
read(byte[] r, int off, int len)	从流中读入字节数据到缓冲区数组中指定位置，off 为数组偏移量，len 为写入长度。
read(byte [] b)	从流中读入字节数据到缓冲区数组中
readBooolean()、readByte()、readShort()、readInt()	从输入流中读取基本数据类型
readUTF()	按照格式化顺序读底层的输入流
readObject()	特有的方法，把对象读入 ObjectInputStream 流

readObject 方法使用示例：

1. public static void main(String[] args) throws   IOException, ClassNotFoundException {
2.         try (
3.                 // 通过文件字节输入流创建对象输入流对象
4.                 ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("C:\\Users\\yy\\Desktop\\d.txt"));) {
5.                 // 获取对象
6.             System.out.print(objectInputStream.readObject());
7.         }
8.     }

执行结果：

1. com.company.Hero@58372a00

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 间编写程序代码，序列化给定 Student 对象到给定文件中，再通过反序列化把其转化为一个对象，具体要求如下：

• 接收给定的一行字符串（如：/test/a.txt Bob 23，第一部分为给定文件路径，第二部分为 Student 对象姓名，第三部分为 Student 对象年龄）；
• 给 Student 对象属性赋值，并序列化到文件中；
• 通过反序列化把文件内容转化为一个对象，并输出所有属性值。

Student 类代码如下：

1. import java.io.Serializable;
2. public class Student implements Serializable {
3.     public String name;
4.     public int age;
5. }

测试说明

平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。

例： 测试输入：

1. /test/a.txt Bob 23

预期输出：

1. Bob
2. 23

   import java.io.*;
   import java.util.Arrays;
   import java.util.Scanner;
    
   public class FileTest {
    
       public static void main(String[] args) throws IOException, ClassNotFoundException {
           // 接收给定的数据
           Scanner scanner = new Scanner(System.in);
           String filedir = scanner.next();
           String name = scanner.next();
           int age = scanner.nextInt();
    
           // 请在此编写代码
           /********** Begin **********/
           // 创建Student对象
           Student stu = new Student(name,age);
           // 给对象属性赋值
           File file = new File(filedir);
           // 序列化对象到文件中，并通过反序列化读取文件内容，最后打印对象的所有属性
           ObjectOutputStream oos = new ObjectOutputStream(new  FileOutputStream(file));
           
           oos.writeObject(stu);
    
           ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
    
           System.out.print(ois.readObject());
           /********** End **********/
    
       }
   }
   

 

import java.io.Serializable;
 
public class Student implements Serializable {
    public String name;
    public int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String toString (){
       return this.name+"\n"+this.age;
    }
}

 

练习-Java输入输出之数组IO流之将给定整数转换为字符写入到给定文件中

任务描述

本关任务：将给定的整数转化为字符，并使用 ByteArrayOutputStream 将其写入到给定文件中（字符为 a 的除外）。

编程要求

仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 间编写程序代码，将给定的整数转化为字符，并写入到给定文件中（字符为 a 的除外），具体要求如下：

• 接收给定的一行字符串（如：/test/a.txt 96 97 98 99 %。字符串中 % 用于终止输入，整数为字节整数，剩下的为文件路径）；
• 将整数转化为字符，并使用 ByteArrayOutputStream 将其写入到给定文件中（字符为 a 的除外）。

测试说明

平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。

例： 测试输入：

1. /test/a.txt 97 98 99 %

预期输出：

1. bc

   import java.io.*;
   import java.util.Arrays;
   import java.util.Scanner;
   public class FileTest {
   
       public static void main(String[] args) throws IOException {
         try(ByteArrayOutputStream b=new ByteArrayOutputStream();){
           Scanner input =new Scanner(System.in);
           String next=input.next();
           while(!input.hasNext("%")){  //%时停止输入
               int i=input.nextInt();
               if((char)i!='a'){
                   b.write(i);  //将i写入字节数组输出流
               }
           }
           File file=new File(next);  //生成指定文件
           b.writeTo(new FileOutputStream(file)); //将输出流的内容写进file文件里
           }
       }
   }