大数据预科班作业13

绝地灬酷狼 2022-06-08 14:13 817阅读 0赞

# 大数据预科班作业13 #

### 1. （File 类）以下关于 File 类说法正确的是： ###

#  #

A． 一个 File 对象代表了操作系统中的一个文件或者文件夹
    B． 可以使用 File 对象创建和删除一个文件
    C． 可以使用 File 对象创建和删除一个文件夹
    D． 当一个 File 对象被垃圾回收时，系统上对应的文件或文件夹也被删除

#  #

ABC

### 2. （File 类）有如下代码： ###

#  #

public class TestFile{ 
    public static void main(String args[]){ 
    File file = new File(“chp13/corejava.txt”); 
    } 
    } 
    请选择一个正确答案：
    A. corejava.txt 文件在系统中被创建
    B. 在 windows 系统上运行出错，因为路径分隔符不正确
    C. corejava.txt 文件在系统中没有被创建
    D. 如果 corejava.txt 文件已存在，则抛出一个异常

#  #

C--只有路径，还没被正真创建

### 3. （File 类）将下列代码补充完整 ###

#  #

class TestMyFile{ 
    public static void main(String args[]) throws Exception{ 
    File file; 
    //创建一个 File 对象表示当前目录下的“hello.txt”文件
    //判断该文件是否存在
    //如果该文件存在，则输出该文件的完整路径
    } 
    }

#  #

package com.peng.demo;
    
    import java.io.File;
    
    public class TestMyFile {
        public static void main(String args[]) throws Exception {
            File file;
            // 创建一个 File 对象表示当前目录下的“hello.txt”文件
            file = new File("hello.txt");
            // 判断该文件是否存在
            // 如果该文件存在，则输出该文件的完整路径
            if (file.exists()) {
                System.out.println(file.getAbsolutePath());
            }
        }
    }

### 4. （流的分类） ###

#  #

对于 FileInputStream 来说，从方向上来分，它是_________
    流，从数据单位上分，它是__________流，从功能上分，它是____________流。

#  #

1. 输入流
    2. 字节流
    3. 文件流

### 5. （字节流, FileInputStream） ###

#  #

FileInputStream 有三个重载的 read 方法，
    其中 1) 无参的 read 方法返回值为___类型，表示_________________ 2) int 
    read(byte[] bs)方法返回值表示______________，参数表示________________ 
    3) int read(byte[] bs, int offset, int len) 方 法 返 回 值 表 示
    _______________，参数分别表示___________________________。

#  #

1. int  
    2. 下一个数据字节；如果已到达文件末尾，则返回 -1。 
    3. 读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。
    4. b - 存储读取数据的缓冲区。 
    5. 读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。
    6. b - 存储读取数据的缓冲区。off - 目标数组 b 中的起始偏移量。len - 读取的最大字节数。

### 6. （FileInputStream）下面关于 FileInputStream 类型说法正确的是： ###

#  #

A． 创建 FileInputStream 对象是为了读取硬盘上的文件
    B． 创建 FileInputStream 对象时，如果硬盘上对应的文件不存在，则抛出
    一个异常
    C． 利用 FileInputStream 对象可以创建文件
    D． FileInputStream 对象读取文件时，只能读取文本文件。

#  #

A
    B--FileNotFoundException

### 7. （FileOutputStream）填空： ###

#  #

创建 FileOutputStream 对象时，如果对应的文件在硬盘上不存在，则会
    ___________；如果对应的文件在硬盘上已经存在，则_______________；
    如果使用 FileOutputStream(String path, boolean append) 这个构造方法创
    建 FileOutputStream 对 象 ， 并 给 定 第 二 个 参 数 为 true ， 则 效 果 为
    __________________。 创建 FileOutputStream 时_______（会|不会）产生异
    常。

#  #

1. 创建文件
    2. 创建新的文件并覆盖
    3. 在后面追加数据
    4. 会（FileNotFoundException）

### 8. 代码改错 ###

#  #

class TestFileInputStream{ 
    public static void main(String args[]){ 
    FileInputStream fin = new FileInputStream(“test.txt”); 
    try{ 
    System.out.println( fin.read() ); 
    fin.close(); 
    }catch(Exception e){} 
    } 
    }

#  #

/*简单改错--抛出异常*/
    package com.peng.demo;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    
    class TestFileInputStream {
        public static void main(String args[]) throws FileNotFoundException {
            FileInputStream fin = new FileInputStream("test.txt");
            try {
                System.out.println(fin.read());
                fin.close();
            } catch (Exception e) {
            }
        }
    }
    
    /*详细改错--捕获异常*/
    package com.peng.demo;
    
    import java.io.FileInputStream;
    
    class TestFileInputStream {
        public static void main(String args[]) {
            FileInputStream fin = null;
            try {
                fin = new FileInputStream("test.txt");
                System.out.println(fin.read());
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (null != fin) {
                    try {
                        fin.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        fin = null;
                    }
                }
            }
        }
    }

### 9. （ FileInputStream 和 FileOutputStream ） ###

#  #

利 用 FileInputStream 和
    FileOutputStream，完成下面的要求：
    1） 用 FileOutputStream 在当前目录下创建一个文件“test.txt”，并向文件
    输出“Hello World”，如果文件已存在，则在原有文件内容后面追加。
    2）用 FileInputStream 读入 test.txt 文件，并在控制台上打印出 test.txt 中
    的内容。
    3） 要求用 try-catch-finally 处理异常，并且关闭流应放在 finally 块中。

#  #

package com.peng.demo;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    class TestFileInputStream {
        public static void main(String args[]) {
            FileOutputStream fo = null;
            FileInputStream fin = null;
            try {
                fo = new FileOutputStream("test.txt", true);
                fo.write("hello world".getBytes());
                fo.flush();
                fin = new FileInputStream("test.txt");
                int len = -1;
                byte[] data = new byte[10];
                while ((len = fin.read(data)) != -1) {
                    System.out.println(new String(data, 0, len));
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (null != fo) {
                    try {
                        fo.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        fo = null;
                    }
                }
            }
        }
    }

### 10. （Data 流）利用 Data 流，完成下面操作： ###

#  #

1） 判断当前目录下是否存在一个“test.dat”的文件，如果该文件不存在，
    则往该文件中写入一个 long 类型的数值：10000L 
    2） 如果该文件存在，则从该文件中读出数值，并把该数值加 1 之后，再存
    回文件中。

#  #

import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    public class data {
     public static void main(String[] args) {
      try {
       File file=new File("test.dat");
       if(!file.exists()){
        DataOutputStream out=new DataOutputStream(new
    FileOutputStream("test.dat"));
        out.writeLong(10000);
        out.close();
       }
       else {
        DataInputStream in=new DataInputStream(new
    FileInputStream("test.dat"));
        Long ll=in.readLong();
        ll=ll+1;
        DataOutputStream out=new DataOutputStream(new
    FileOutputStream("test.dat"));
        out.writeLong(ll);
        System.out.println(ll);
        out.close();
        in.close();
       }
      } catch (Exception e) {
       e.printStackTrace();
       // TODO: handle exception
      }
     }
    }

### 11. （字符流、桥转换）要想从某个文件中获得一个字符输出流，则至少有以下三种方式 ###

#  #

A. 利用 FileWriter 类
    B. 利用 PrintWriter 类
    C. 利用 FileOutputStream 类，并通过 OutputStreamWriter 类获得 Writer 
    请简述这三种方式获得 Writer 的区别。

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>FileWriter</td> 
   <td>用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。</td> 
  </tr> 
  <tr> 
   <td>PrintWriter</td> 
   <td>向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream 中的所有 print 方法。它不包含用于写入原始字节的方法，对于这些字节，程序应该使用未编码的字节流进行写入。与 PrintStream 类不同，如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作，而不是每当正好输出换行符时才完成。这些方法使用平台自有的行分隔符概念，而不是换行符。此类中的方法不会抛出 I/O 异常，尽管其某些构造方法可能抛出异常。客户端可能会查询调用 checkError() 是否出现错误。</td> 
  </tr> 
  <tr> 
   <td>FileOutputStream+FileOutputStreamWriter</td> 
   <td>文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。文件是否可用或能否可以被创建取决于基础平台。特别是某些平台一次只允许一个 FileOutputStream（或其他文件写入对象）打开文件进行写入。在这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。FileOutputStream 用于写入诸如图像数据之类的原始字节的流。要写入字符流，请考虑使用 FileWriter。</td> 
  </tr> 
  <tr> 
   <td>&nbsp;</td> 
   <td>&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

FileWriter可以直接读取文件,可以直接写入字符串
    PrintWrite加一个TRUE可以自动刷新缓冲区
    FileOutStream活动的是字节

### 12. （字节流、字符流）以下几种文件格式，应当使用字节流还是字符流？ ###

#  #

1) .java 源文件
    2) .class 字节码文件
    3) .html 网页文件
    4) .jpg 图像文件
    5) .mp3 音乐文件
    6) 配置文件.bash_profile 
    7) .jar 文件

#  #

1. 字节流【2、4、5、7】
    2. 字符流【1、3、6】

### 13. （过滤流）连线题。把过滤流和相应的功能用线连起来。注意，左右两边不是一一对应的关系。 ###

#  #

ObjectInputStream 字节流
    ObjectOutputStream 字符流
    BufferInputStream 读八种基本类型
    BufferedOutputStream 写八种基本类型
    DataInputStream 读对象
    DataOutputStream 写对象
    PrintWriter 缓冲功能
    PrintStream 读入一行文本
    BufferedReader 写字符串并换行

#  #

ObjectInputStream(E)            A字节流
    ObjectOutputStream(F)          B字符流
    BufferInputStream(AG)          C读八种基本类型
    BufferedOutputStream(AG)         D写八种基本类型
    DataInputStream(AC)              E读对象
    DataOutputStream(AD)             F写对象
    PrintWriter(BJI)                  G缓冲功能
    PrintStream(A)                  H读入一行文本
    BufferedReader(BGH)               I写字符串并换行
    BufferedWriter(BGj)               J写字符串

### 14. （对象序列化） ###

#  #

为了让某对象能够被序列化，要求其实现________________________接口；
    为了让该对象某个属性不参与序列化，应当使用____________修饰符。

#  #

1. __Serializable____
    2. __transient______

### 15. （字符流、桥转换）完成下面功能：（字符流、桥转换）完成下面功能： ###

#  #

事先在当前目录下准备好一个 test.txt 的文本文件，要求该文本文件是使用
    GBK 编码的多行文本文件。如：
    test.txt 
    窗前明月光
    疑是地上霜
    举头望明月
    低头思故乡
    利用字节流+桥转换读入这个文本文件，然后按照行的顺序，以 UTF-8 的编码方
    式，写到 test2.txt 文件中，例：
    test2.txt 
    低头思故乡
    举头望明月
    疑是地上霜
    窗前明月光

#  #

### 16. 16. （Data 流）有以下代码 ###

#  #

public class Check{ 
    public static void main(String args[]) throws Exception{ 
    FileOutputStream fout = new FileOutputStream(“test.dat”); 
    DataOutputStream dout = new DataOutputStream(fout); 
    dout.writeInt(1); 
    dout.writeDouble(0.01); 
    dout.close(); 
    } 
    } 
    问：这个程序总共往文件中写入了多少字节？
    A. 2 
    B. 8 
    C. 12 
    D. 16 
    E. 字节数取决于具体平台

#  #

package com.peng.demo;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    
    public class test2 {
        public static void main(String[] args) {
            String str = null;
            int i = 0;
            String con[] = new String[4];
            try {
                BufferedReader rw = new BufferedReader(new InputStreamReader(
                        new FileInputStream("test.txt")));
                BufferedWriter out = new BufferedWriter(new OutputStreamWriter(
                        new FileOutputStream("test2.txt")));
                while ((str = rw.readLine()) != null) {
                    con[i] = str;
                    i++;
                }
                for (int j = con.length - 1; j >= 0; j--) {
                    String ss = new String(con[j].getBytes("UTF-8"));
                    out.write(con[j]);
                    out.newLine();
                }
                out.close();
                rw.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

### （对象序列化）\*（对象序列化） ###

#  #

在 PrintWriter 中，有一个方法 print(Object obj) 
    在 ObjectOutputStream 中，有一个方法 writeObject(Object obj) 
    请简述这两个方法的区别

#  #

1. PrintWriter按照平台的默认字符串编码将 String.valueOf(Object) 方法生成的字符串转换为字节，并完全以 write(int) 方法的方式写入这些字节。
    2. 将指定的对象写入 ObjectOutputStream。对象的类、类的签名，以及类及其所有超类型的非瞬态和非静态字段的值都将被写入。可以使用 writeObject 和 readObject 方法重写类的默认序列化。由此对象引用的对象是以可变迁的方式写入的，这样，可以通过 ObjectInputStream 重新构造这些对象的完全等价的图形。当 OutputStream 中出现问题或者遇到不应序列化的类时，将抛出异常。所有异常对于 OutputStream 而言都是致命的，使其处于不确定状态；并由调用者来忽略或恢复流的状态。

### 18. （对象序列化）写出下面代码运行结果（对象序列化）写出下面代码运行结果 ###

#  #

import java.io.*; 
    class Address implements Serializable{ 
    private String addressName; 
    private String zipCode; 
    //构造方法
    //set/get 方法
    public String toString(){ 
    return addressName + “ ” + zipCode; 
    } 
    } 
    class Student implements Serializable { 
    private String name; 
    private transient int age; 
    private Address addr; 
    //构造方法„
    //set/get 方法„
    public String toString(){ 
    return name + “ ” + age + “” + addr.toString(); 
    } 
    } 
    public class TestObjectStream{ 
    public static void main(String args[]) throws Exception{ 
    Address addr = new Address(“Beijing”, “100000”); 
    Student stu = new Student(“Tom”, 18, addr); 
    ObjectOutputStream oos = new ObjectOutputStream( 
    new FileOutputStream(“stu.dat”) ); 
    oos.writeObject(stu); 
    oos.close(); 
    ObjectInputStream oin = new ObjectInputStream( 
    new FileInputStream(“stu.dat”) ); 
    Student stu2 = (Student) oin.readObject(); 
    oin.close(); 
    System.out.println(stu2); 
    } 
    }

#  #

Tom 0 Beijing 100000

### 19. 19. （对象序列化）有以下代码： ###

#  #

import java.io.*; 
    class Address{ 
    private String addressName; 
    private String zipCode; 
    //构造方法„
    //get/set 方法„
    } 
    class Worker implements Serializable{ 
    private String name; 
    private int age; 
    private Address address; 
    //构造方法„
    //get/set 方法„
    } 
    public class TestSerializable { 
    public static void main(String args[]) throws Exception{ 
    Address addr = new Address("Beijing", "100000"); 
    Worker w = new Worker("Tom", 18, addr); 
    ObjectOutputStream oout = new ObjectOutputStream( 
    new FileOutputStream("fout.dat") ); 
    oout.writeObject(w); 
    oout.close(); 
    } 
    } 
    选择正确答案
    A. 该程序编译出错
    B. 编译正常，运行时异常
    C. 编译正常，运行时也正常。

#  #

### （字节流，BufferedReader）完成下面操作。\*（字节流，BufferedReader）完成下面操作。 ###

#  #

在当前目录下创建一个 worldcup.txt 的文本文件，其格式如下：
    2006/意大利
    2002/巴西
    „
    该文件采用“年份/世界杯冠军”的方式保存每一年世界杯冠军的信息。
    要求：读入该文件的基础上，让用户输入一个年份，输出该年的世界杯冠军。如
    果该年没有举办世界杯，则输出“没有举办世界杯”

#  #

package com.peng.demo;
    
    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.InputStreamReader;
    import java.util.HashMap;
    import java.util.Scanner;
    
    public class test5 {
        public static void main(String[] args) {
            try {
                HashMap<String, String> hs = new HashMap<String, String>();
                String str;
                String con[] = new String[2];
                BufferedReader in = new BufferedReader(new InputStreamReader(
                        new FileInputStream("worldcup.txt")));
                while ((str = in.readLine()) != null) {
                    con = str.split("/");
                    hs.put(con[0], con[1]);
                }
                String ss;
                int count = 0;
                Scanner s = new Scanner(System.in);
                System.out.println("请输入年份：");
                ss = s.next();
                for (String mm : hs.keySet()) {
                    if (mm.equals(ss)) {
                        count++;
                        System.out.println(mm + "年的世界杯冠军是：" + hs.get(mm));
                    }
                }
                if (count == 0)
                    System.out.println("该年没有举办世界杯！");
    
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    }

### 21. （Buffered 流，缓冲区）有下面代码（Buffered 流，缓冲区）有下面代码 ###

#  #

import java.io.*; 
    public class TestBufferedWriter{ 
    public static void main(String args[]) throws Exception{ 
    FileWriter fw = new FileWriter(“test.txt”); 
    BufferedWriter bw = new BufferedWriter(fw); 
    String str = “Hello World”; 
    bw.write(str); 
    /*1*/ 
    } 
    } 
    在/*1*/处放入什么代码，能够使得 test.txt 文件被正确写入？
    A. bw.close() 
    B. bw.flush(); 
    C. fw.close();

#  #

### 22. 22. （Data 流）在原有自动分配 id 的 Account 对象基础上，利用 Data 流，完成下面的要求： 要求每次启动程序时，id 的自动分配都能在上一次运行的基础上继续。例如， 假设有以下代码： ###

#  #

public class TestAccount{ 
    public static void main(String args[]){ 
    Account a1 = new Account(); 
    Account a2 = new Account(); 
    Account a3 = new Account(); 
    System.out.println(a1.getId() ); 
    System.out.println(a2.getId() ); 
    System.out.println(a3.getId() ); 
    } 
    } 
    编译之后，第一次运行
    java TestAccount 时，输出
    100001 
    100002 
    100003 
    第二次运行
    java TestAccount 时，输出
    100004 
    100005 
    100006

#  #

### （综合）\*\*（综合） ###

#  #

从命令行中读入一个文件名，判断该文件是否存在。如果该文件存在，则在原文
    件相同路径下创建一个文件名为“copy_原文件名”的新文件，该文件内容为原
    文 件 的 拷 贝 。 例 如 ： 读 入 /home/java/photo.jpg 则 创 建 一 个 文 件
    /home/java/copy_photo.jpg 新文件内容和原文件内容相同。

#  #

package com.peng.demo;
    
    import java.io.DataInputStream;
    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.TreeMap;
    
    public class test5 {
        @SuppressWarnings("rawtypes")
        public static void main(String[] args) {
            Long lon = 100000L;
            File file = new File("tt.dat");
            if (file.exists()) {
                try {
                    DataInputStream in = new DataInputStream(new FileInputStream(
                            "tt.dat"));
                    lon = in.readLong();
                    in.close();
                } catch (Exception e) {
                    e.printStackTrace();
                    // TODO: handle exception
                }
            }
            List list = new ArrayList();
            list.add(new Account(10.00, "1234"));
            list.add(new Account(15.00, "5678"));
            list.add(new Account(0, "1010"));
            TreeMap<Long, Account> acc = new TreeMap<Long, Account>();
            for (int i = 0; i < list.size(); i++) {
                acc.put((long) (lon + i), (Account) list.get(i));
            }
            int i = 0;
            for (Long mm : acc.keySet()) {
                Account ff = (Account) list.get(i);
                i++;
                ff.setId(mm);
            }
            for (Object ss : list) {
                System.out.println(((Account) ss).getId() + ":"
                        + ((Account) ss).getBalance());
            }
            try {
                DataOutputStream out = new DataOutputStream(new FileOutputStream(
                        "tt.dat"));
                out.writeLong((Long) (lon + list.size()));
                out.flush();
                out.close();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

### 24. （可选，综合）用两种方式保存对象。（可选，综合）用两种方式保存对象。 ###

#  #

有 Worker 对象，部分代码如下：
    class Worker{ 
    private String name; 
    private int age 
    private double salary; 
    //构造方法
    „
    //get/set 方法
    „
    //toString 方法
    „
    } 
    1） 完善 Worker 对象，并使其能使用对象序列化机制。
    2） 利用 ObjectOutputStream 存入两个 Worker 对象， 然后使用
    ObjectInputStream 读出这两个对象，并打印这两个对象的信息。
    3） 写一个方法 saveWorkerToFile(Worker w, File file)，该方法完成下面的
    功能：
    假设有一个 Worker 对象 w1，File 对象 f1 如下：
    Worker w1 = new Worker(“Tom”, 30, 5000); 
    File f1 = new File(“test.txt”); 
    则调用 saveWorkerToFile(w1, f1)，会在 test.txt 中增加一行：
    Tom/30/5000 
    4） 写一个方法 List<Worker> readWorkerFromFile(File file)，该方法读某
    个文件，从文件信息中创建一个 Worker 类型的 List。
    例如，假设文件内容如下：
    Tom/30/5000 
    Jim/25/3000 
    Terry/33/4500 
    则返回一个包含三个 Worker 对象的 List。

#  #