IO题目

8-1 写入日志文件 (0 分)

 

编写程序，要求：用户在键盘每输入一行文本，程序将这段文本显示在控制台中。当用户输入的一行文本是“exit”（不区分大小写）时，程序将用户所有输入的文本都写入到文件log.txt中，并退出。（要求：控制台输入通过流封装System.in获取，不要使用Scanner）

import java.io.*;

public class Main 
{
    public static void main(String[] args) 
    {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            bw = new BufferedWriter(new FileWriter(new File("log.txt")));
            String s;
            while(!(s = br.readLine()).equalsIgnoreCase("exit"))
            {
                System.out.print(s);
                bw.write(s);
                bw.newLine();
            }
        }catch(IOException e) {
            e.printStackTrace();
        }
        
        finally {
            try {
                if(br != null)
                {
                    br.close();
                }
                if(bw != null)
                {
                    bw.close();
                }
            }catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
}

8-2 文件和目录输出 (20 分)

 

查看File类的API文档，使用该类实现一个类FileList，它提供两个静态方法：1）readContentsInDirectory(String path)：能够将输入参数path所指定的本地磁盘路径下的所有目录和文件的名称打印出来；2）readContentsInDirectoryRecursive(String path)：能够将输入参数path所指定的本地磁盘路径下的所有目录（包含所有子孙目录）和文件的名称以层次化结构打印出来。程序的输出如下所示。

import java.io.*;
import java.util.*;
public class Main 
{
    public static void main(String[] args) 
    {
        Scanner s = new Scanner(System.in);
        String path = s.nextLine();
        File f = new File(path);
        int level = 0;
        FileList fl = new FileList();
        fl.readContentsInDirectory(f);
        System.out.println("------------------");
        fl.readContentsInDirectoryRecursive(f, level);
        s.close();
    }
}
class FileList
{
    public void readContentsInDirectory(File path)
    {
        if(!path.exists())
        {
            System.out.println("路径"+path.getPath()+"不存在");
            return ;
        }
        else
        {
            File[] f = path.listFiles();
            for(int i = 0 ; i < f.length ; i++)
            {
                if(f[i].isFile())
                {
                    System.out.println("[文件]"+f[i].getName());
                }
                else
                {
                    System.out.println("[目录]"+f[i].getName());
                }
            }
        }
    }
    public void readContentsInDirectoryRecursive(File path,int level)
    {
        if(!path.exists())
        {
            System.out.println("路径"+path.getPath()+"不存在");
            return ;
        }
        else
        {
            File[] f = path.listFiles();
            for(int i = 0 ; i < f.length ; i++)
            {
                for(int j = 0; j < level ; j++)
                {
                    System.out.print("-");
                }
                if(f[i].isFile())
                {
                    System.out.println("[文件]"+f[i].getName());
                }
                else
                {
                    System.out.println("[目录]"+f[i].getName());
                    readContentsInDirectoryRecursive(f[i],level+2);
                }
            }
        }
    }
}

 

8-3 菜单文件处理 (20 分)

 

假设某个餐馆平时使用：1）文本文件（orders.txt）记录顾客的点菜信息，每桌顾客的点菜记录占一行。每行顾客点菜信息的记录格式是“菜名：数量，菜名：数量，…菜名：数量”。例如：“烤鸭：1，土豆丝：2，烤鱼：1”。2）文本文件（dishes.txt）记录每种菜的具体价格，每种菜及其价格占一行，记录格式为“菜名：价格“。例如：“烤鸭：169”。编写一个程序，能够计算出orders.txt中所有顾客消费的总价格。（注意，请使用文本读写流，及缓冲流来处理文件）

import java.util.*;
import java.io.*;
public class Main
{
     public static void main(String[] args) 
     {
        Scanner s = new Scanner(System.in);
        BufferedReader br1 = null;
        BufferedReader br2 = null;
        List<Order> order = new ArrayList<>();
        Map<String , Dish> dish = new HashMap<>();
        try {
            File f1 = new File("order.txt");
            f1.createNewFile();
            File f2 = new File("dishes.txt");
            f2.createNewFile();
            br1 = new BufferedReader(new FileReader("order.txt"));
            br2 = new BufferedReader(new FileReader("dishes.txt"));
            String S1 ;
            while((S1 = br1.readLine()) != null)
            {
                String[] s1 = S1.split(",");
                for(int i = 0 ; i < s1.length ; i++)
                {
                    order.add(new Order(s1[0],Integer.parseInt(s1[1])));
                }
            }
            String S2;
            while((S2 = br2.readLine()) != null)
            {
                String[] s2 = S2.split(":");
                dish.put(s2[0], new Dish(s2[0],Double.parseDouble(s2[1])));
            }
            double sum = 0;
            for(int i = 0 ; i < order.size() ; i++)
            {
                sum += order.get(i).num * dish.get(i).price;
            }
            System.out.println(sum);
        }catch(Exception e) {
            e.printStackTrace();
        }
        finally {
            try {
                if(br1 != null)
                {
                    br1.close();
                }
                if(br2 != null)
                {
                    br2.close();
                }
            }catch(Exception e) {
                e.printStackTrace();
            }
        }
        s.close();
     }
}
class Order
{
    public String name;
    public int num;
    public Order(String name, int num) 
    {
        this.name = name;
        this.num = num;
    }
}
class Dish
{
    public String name;
    public double price;
    public Dish(String name, double price) 
    {
        this.name = name;
        this.price = price;
    }
}

8-4 成绩文件处理 (20 分)

 

设计学生类Student，属性：学号（整型）；姓名（字符串），选修课程（名称）及课程成绩（整型）。编写一个控制台程序，能够实现Student信息的保存、读取。具体要求：（1）提供Student信息的保存功能：通过控制台输入若干个学生的学号、姓名以及每个学生所修课程的课程名和成绩，将其信息保存到data.dat中；（2）数据读取显示：能够从data.dat文件中读取学生及其课程成绩并显示于控制台。（要求，学号和课程成绩按照整数形式（而非字符串形式）存储）

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

public class Test4 {
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String l = null;
        DataInputStream dis = null;
        DataOutputStream dos = null;
        try {
            dos = new DataOutputStream(new FileOutputStream("data.dat"));
            while(!(l=sc.nextLine()).equals("exit")) {
                String[] ss = l.split(" ");
                Student s = new Student(Integer.parseInt(ss[0])
                        ,ss[1],ss[2],Integer.parseInt(ss[3]));
                
                byte[] bs = s.getNameBytes();
                byte[] cs = s.getCourseBytes();
                
                dos.writeInt(s.no);
                dos.writeInt(bs.length);
                dos.write(bs);
                dos.writeInt(cs.length);
                dos.write(cs);
                dos.writeInt(s.score);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
            dos.close();
            }catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        try {
            File f = new File("data.dat");
            int size = (int) f.length();
            int records = size/(4+4+(96+240)/8);
            dis = new DataInputStream(new FileInputStream("data.dat"));
            
            while (true) {//for (int i=0;i<records;i++) {    
                int no = dis.readInt();
                int bsize = dis.readInt();
                byte[] bs = new byte[bsize];
                dis.read(bs);
                String name = new String(bs);
                int wsize = dis.readInt();
                byte[] ws = new byte[wsize];
                dis.read(ws);
                String course = new String(ws);
                int score = dis.readInt();
                System.out.println(no+" "+name+" "+course+" "+score);
            }
        } catch (EOFException e) {
            System.out.println("end of file");    
        } catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
            dis.close();
            }catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

class Student {
    int no;
    String name;
    String course;
    int score;
    
    public byte[] getNameBytes() {
        byte[] src = name.getBytes();
        return src;
    }
    
    public byte[] getCourseBytes(){
        byte[] src = course.getBytes();
        return src;
    }
    
    public Student(int no, String name, String course, int score) {
        super();
        this.no = no;
        this.name = name;
        this.course = course;
        this.score = score;
    }
    
}

8-5 图书馆持久化 (20 分)

 

构造图书类，包含名称（字符串）、作者（字符串）、出版社（字符串）、版本号（整数）、价格（浮点数），构造图书馆类，其中包含若干图书，用容器存储图书对象，然后定义方法void addBook(Book b)添加图书对象，定义方法void persist()，将所有图书存至本地文件books.dat里，定义方法Book[] restore() 从文件books,dat中读取所有图书，并返回图书列表数组。 main函数中构造图书馆类对象，向其中添加3个图书对象，测试其persist和restore方法。（注意，请使用对象序列化方法实现）

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class Test5 {
    /*构造图书类，包含名称（字符串）、作者（字符串）、出版社（字符串）、版本号（整数）、价格（浮点数），
     * 构造图书馆类，其中包含若干图书，用容器存储图书对象，
     * 然后定义方法void addBook(Book b)添加图书对象，
     * 定义方法void persist()，将所有图书存至本地文件books.dat里，
     * 定义方法Book[] restore() 从文件books,dat中读取所有图书，并返回图书列表数组。
     *  main函数中构造图书馆类对象，向其中添加3个图书对象，测试其persist和restore方法。
     * （注意，请使用对象序列化方法实现）
     */
    
    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        Book[] bs = {
                new Book ("Java","张峰", "清华大学出版社",2, 23.5),
                new Book ("C++","刘冰", "清华大学出版社",2, 18),
                new Book ("C","王莉", "清华大学出版社",2, 35)
        };
        Library l = new Library();
        for (Book b : bs) {
            l.addBook(b);
        }
        l.persist();
        Book[] bs2 = l.restore();
        for (Book b : bs) {
            System.out.println(b);
        }
    }

}

class Book implements Serializable{
    String name;
    String author;
    String press;
    int edition;
    double price;
    
    public Book(String name, String author, String press, int edition, double price) {
        super();
        this.name = name;
        this.author = author;
        this.press = press;
        this.edition = edition;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book [name=" + name + ", author=" + author + ", press=" + press + ", edition=" + edition + ", price="
                + price + "]";
    }
}

class Library 
{
    List<Book> bs = new ArrayList<Book>();
    
    public void addBook(Book b) 
    {
        bs.add(b);
    }
    
    public void persist () 
    {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(
                    new FileOutputStream("books.dat"));
                // 将per对象写入输出流
            for(Book b :bs)
            oos.writeObject(b);
        }
        catch (IOException ex)
        {
            ex.printStackTrace();
        } finally {
            try {
                if (oos!=null)
                    oos.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    
    public Book[] restore() 
    {
        ObjectInputStream ois = null;
        bs = new ArrayList<Book>();
        try {
            ois = new ObjectInputStream(
                new FileInputStream("books.dat"));
            //从输入流中读取一个Java对象，并将其强制类型转换为Person类
            while (true) 
            {
                Book b = (Book)ois.readObject();
                bs.add(b);
            }
        }catch (EOFException e){
          System.out.println("end of file");    
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (ois!=null)
                    ois.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        Book[] ba = new Book[bs.size()]; 
        bs.toArray(ba);
        return ba;
    }
    
}

8-6 按行读文件 (20 分)

 

使用java的输入/输出流技术将一个文本文件的内容按行读出，每读出一行就顺序添加行号，并写入到另一个文件中。

import java.io.*;
public class Main
{
     public static void main(String[] args) 
     {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("in.txt"));
            bw = new BufferedWriter(new FileWriter("out.txt"));
            String s;
            for(int i = 0 ; (s = br.readLine())!=null ; i++)
            {
                bw.write(i+" , "+s);
                bw.newLine();
            }
        }catch(Exception e) {
            e.printStackTrace();
        }
        finally {
            try {
                if(br != null)
                {
                    br.close();
                }
                if(bw != null)
                {
                    bw.close();
                }
            }catch(Exception e) {
                e.printStackTrace();
            }
        }
     }
}

8-7 读写文件--程序设计 (20 分)

 

编写一个程序实现如下功能，文件fin.txt是无行结构（无换行符）的汉语文件，从fin中读取字符，写入文件fou.txt中，每40个字符一行（最后一行可能少于40个字） 请将程序代码贴到答案区内

import java.io.*;
public class Main
{
     public static void main(String[] args) 
     {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br = new BufferedReader(new FileReader("fin.txt"));
            bw = new BufferedWriter(new FileWriter("out.txt"));
            char[] c = new char[40];
            int len = 40;
            while((br.read(c, 0, len) )!= -1)
            {
                bw.write(c, 0, len);
                bw.newLine();
            }
        }catch(Exception e) {
            e.printStackTrace();
        }
        finally {
            try {
                if(br != null)
                {
                    br.close();
                }
                if(bw != null)
                {
                    bw.close();
                }
            }catch(Exception e) {
                e.printStackTrace();
            }
        }
     }
}