zoukankan      html  css  js  c++  java
  • Java IO流题库

    一、    填空题

    1. Java IO流可以分为   节点流   和处理流两大类,其中前者处于IO操作的第一线,所有操作必须通过他们进行。
    2. 输入流的唯一目的是提供通往数据的通道,程序可以通过这个通道读取数据, read

    方法给程序提供了一个从输入流中读取数据的基本方法。

    1. read方法从输入流中顺序读取源中的单个字节数据,该方法返回字节值(0-255之间的一个整数),如果到达源的末尾,该方法返回  -1   
    2. Java系统的标准输入对象是System.in,标准输出对象有两个,分别是标准输出System.out和标准错误输出____System.err__。
    3. Java IO体系中,___ ObjectInputStream __是字节输入流,不仅提供了存取所有Java基础类型数据(如:int,double 等)和String的方法,也提供了提供存取对象的方法。
    4. Java IO体系中,____ DataOutputStream __是字节输出流,提供了可以存取所有Java基础类型数据(如:int,double 等)和String的方法,但没有提供存取对象的方法。
    5. ___序列化__是指将Java对象转换成字节序列,从而可以保存到磁盘上,也可以在网络上传输,使得不同的计算机可以共享对象。

     

    二、    选择题

     

    1.

    使用Java IO流实现对文本文件的读写过程中,需要处理下列(  B  )异常。(选择一项)

     

     

     

     

    A

    ClassNotFoundException

     

    B.

    IOException

     

    C.

    SQLException

     

    D.

    RemoteException

     

    2.

    JavaIO操作中,(  D  )方法可以用来刷新流的缓冲。(选择两项)

     

     

     

     

    A

    void release()

     

    B.

    void close()

     

    C.

    void remove()

     

    D.

    void flush()

     

    3.

    Java中,下列关于读写文件的描述错误的是(  B  )。(选择一项)

     

     

     

     

    A

    Reader类的read()方法用来从源中读取一个字符的数据

     

    B.

    Reader类的read(int n )方法用来从源中读取一个字符的数据

     

    C.

    Writer类的write(int n)方法用来向输出流写入单个字符

     

    D.

    Writer类的write(String str)方法用来向输出流写入一个字符串

     

     

     

    4.

    阅读下列文件定入的Java代码,共有(  C  )处错误。(选择一项)

     

    import java.io.*;

    public class TestIO {

             public static void main(String []args){

                       String str ="文件写入练习";

                       FileWriter fw = null;        //1

                       try{

                                fw = new FileWriter("c:mytext.txt");  //2

                                fw.writerToEnd(str);   //3

                       }catch(IOException e){   //4

                                e.printStackTrace();

                       }finally{

                                //此处省略关闭流

                       }

             }

    }

     

     

     

     

    A

    0

     

    B.

    1

     

    C.

    2

     

    D.

    3

     

    5.

    分析如下Java代码,有标注的四行代码中,有错误的是第( D )处。(选择一项)

     

    import java.io.FileWriter;

    import java.io.IOException;

    public class Test {

             public static void main(String[ ] args) {

                       String str = "Hello World";

                       FileWriter fw = null;

                       try {

                                fw = new FileWriter("c:\hello.txt"); // 1

                                fw.write(str);                     // 2

                       } catch (IOException e) {

                                e.printStackTrace();               // 3

                       } finally {

                                fw.close();                        // 4

                       }

             }

    }

     

     

     

     

    A

    1

     

    B.

    2

     

    C.

    3

     

    D.

    4

     

    6.

    以下选项中关于如下代码的说法正确的是(  AD  。(选择二项)

     

    public class TestBuffered {

             public static void main(String[] args) throws IOException {

                       BufferedReader br =

                                new BufferedReader(new FileReader("d:/bjsxt1.txt"));

                       BufferedWriter bw =

                                new BufferedWriter(new FileWriter("d:/bjsxt2.txt"));

                       String str = br.readLine();

                       while(str !=null){

                                bw.write(str);

                                bw.newLine();

                                str = br.readLine();

                       }

                       br.close();

                       bw.close();     

             }

    }

     

     

     

     

    A.

    该类使用字符流实现了文件复制,将d:/bjsxt1.txt复制为d:/bjsxt2.txt

     

    B.

    FileReader和FileWriter是处理流,直接从文件读写数据

     

    C.

    BufferedReader和BufferedWriter是节点流,提供缓冲区功能,提高读写效率

     

    D.

    readLine()可以读取一行数据,返回值是字符串类型,简化了操作

     

    7.

    InputStreamReader是转换流,可以将字节流转换成字符流,是字符流与字节流之间的桥梁。它的实现使用的设计模式是(  C  。(选择一项)

     

     

     

     

    A.

    工厂模式

     

    B.

    装饰模式

     

    C.

    适配器模式

     

    D.

    代理模式

     

    三、    判断题

    1. 假设文件”a.txt”的长度为100字节,那么当正常运行语句”OutputStream f=new FileOutputStream(new File(“a.txt”));”之后,文件”a.txt”的长度变为0字节。(  T  )
    2. ByteArrayInutStream和ByteArrayOutputStream对内存中的字节数组进行读写操作,属于字节流,属于处理流而不是节点流。 (  F  )
    3. 实现Serializable接口的可以被序列化和反序列化。该接口中没有定义抽象方法,也没有定义常量。(  T  )
    4. 序列化是指将字节序列转换成Java对象,只有实现了Serializable接口的类的对象才可以被序列化。(  F  )

     

     

    四、    简答题

    1. 输入流和输出流的联系和区别,字符流和字节流的联系和区别

     

    1. 列举常用的字节输入流和字节输出流并说明其特点,至少5对。

     

    1. 说明缓冲流的优点和原理

     

    1. 序列化的定义、实现和注意事项

     

    五、    编码题

    1.实现字符串和字节数组之间的相互转换。必如将字符串“北京尚学堂bjsxt”转换为字节数组,并将字节数组再转换回字符串。

     1 public class TestConvert
     2 {
     3     public static void main(String[] args) throws IOException
     4     {
     5         //准备一个字符串
     6         String contents = " 近日,北京尚学堂科技有限公司正式成为央视网广告合作伙伴";
     7         System.out.println(contents);
     8         //String---byte []
     9         byte[] buf = contents.getBytes();
    10         //byte[]----String
    11         String contents2 = new String(buf, 0, buf.length);
    12         System.out.println(contents2);
    13     }
    14

    2.实现字节数组和任何基本类型和引用类型执行的相互转换

    提示:使用ByteArrayInutStream和ByteArrayOutputStream。

     

     1 public class TestByteArrayStream
     2 {
     3     public static void main(String[] args) throws IOException,
     4             ClassNotFoundException
     5     {
     6         int num = 50;
     7         boolean flag = true;
     8         User user = new User("bjsxt", "bjsxt");
     9         //使用数据包把数据封装起来
    10         //各种数据类型----->byte[]  ByteArrayOutputStream          
    11         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    12         ObjectOutputStream oos = new ObjectOutputStream(baos);//包装流
    13         oos.writeInt(num);
    14         oos.writeBoolean(flag);
    15         oos.writeObject(user);
    16         byte[] buf = baos.toByteArray();
    17         baos.close();
    18         //byte[]----------->各种数据类型
    19         ByteArrayInputStream bais = new ByteArrayInputStream(buf);
    20         ObjectInputStream ois = new ObjectInputStream(bais);
    21         int num2 = ois.readInt();
    22         boolean flag2 = ois.readBoolean();
    23         User user2 = (User) ois.readObject();
    24         System.out.println(num2);
    25         System.out.println(flag2);
    26         System.out.println(user2);
    27         bais.close();
    28     }
    29 }

    3.分别使用文件流和缓冲流复制一个长度大于100MB的视频文件,并观察效率的差异。

     

     1 public class TestCopy4
     2 {
     3     public static void main(String[] args) throws IOException
     4     {
     5         //创建输入流和输出流
     6         InputStream fis = new FileInputStream(new File("d:/1.mp4"));
     7         OutputStream fos = new FileOutputStream("d:/2.mp4");
     8         //使用输入流和输出流复制文件
     9         byte[] buf = new byte[10];
    10         int len = fis.read(buf);
    11         while (len != -1)
    12         {
    13             //
    14             fos.write(buf, 0, len);
    15             //
    16             len = fis.read(buf);
    17             //System.out.println(len);
    18         }
    19         //关闭输入流和输出流
    20         fis.close();
    21         fos.close();
    22     }
    23 }
    24 public class TestCopy
    25 {
    26     public static void main(String[] args) throws IOException
    27     {
    28         //创建输入流和输出流
    29         InputStream fis = new FileInputStream(new File("d:/1.mp4"));
    30         OutputStream fos = new FileOutputStream("d:/2.mp4");
    31         BufferedInputStream bis = new BufferedInputStream(fis);
    32         BufferedOutputStream bos = new BufferedOutputStream(fos);
    33         //使用输入流和输出流复制文件
    34         byte[] buf = new byte[10];
    35         int len = bis.read(buf);
    36         while (len != -1)
    37         {
    38             //
    39             bos.write(buf, 0, len);
    40             //
    41             len = bis.read(buf);
    42         }
    43         //关闭输入流和输出流
    44         bis.close();
    45         bos.close();
    46     }
    47 }

    4.复制文件夹d:/sxtjava下面所有文件和子文件夹内容到d:/sxtjava2。

    提示:涉及单个文件复制、目录的创建、递归的使用

     

      1 public class CopyDir
      2 {
      3     /**
      4      *
      5      * 复制单个文件
      6      *
      7      * @param sourceFile 源文件
      8      *
      9      * @param targetFile 目标文件
     10      *
     11      * @throws IOException
     12      *
     13      */
     14     public static void copyFile(File sourceFile, File targetFile) throws IOException
     15     {
     16         BufferedInputStream inBuff = null;
     17         BufferedOutputStream outBuff = null;
     18         try
     19         {
     20             // 新建文件输入流
     21             inBuff = new BufferedInputStream(new FileInputStream(sourceFile));
     22             // 新建文件输出流
     23             outBuff = new BufferedOutputStream(new FileOutputStream(targetFile));
     24             // 缓冲数组
     25             byte[] b = new byte[1024 * 5];
     26             int len;
     27             while ((len = inBuff.read(b)) != -1)
     28             {
     29                 outBuff.write(b, 0, len);
     30             }
     31             // 刷新此缓冲的输出流
     32             outBuff.flush();
     33         } finally
     34         {
     35             // 关闭流
     36             if (inBuff != null)
     37             {
     38                 inBuff.close();
     39             }
     40             if (outBuff != null)
     41             {
     42                 outBuff.close();
     43             }
     44         }
     45     }
     46     /**
     47      *
     48      * 复制目录
     49      *
     50      * @param sourceDir 源目录
     51      *
     52      * @param targetDir 目标目录
     53      *
     54      * @throws IOException
     55      *
     56      */
     57     public static void copyDirectiory(String sourceDir, String targetDir)
     58             throws IOException
     59     {
     60         // 检查源目录
     61         File fSourceDir = new File(sourceDir);
     62         if (!fSourceDir.exists() || !fSourceDir.isDirectory())
     63         {
     64             System.out.println("源目录不存在");
     65             return;
     66         }
     67         //检查目标目录,如不存在则创建
     68         File fTargetDir = new File(targetDir);
     69         if (!fTargetDir.exists())
     70         {
     71             fTargetDir.mkdirs();
     72         }
     73         // 遍历源目录下的文件或目录
     74         File[] file = fSourceDir.listFiles();
     75         for (int i = 0; i < file.length; i++)
     76         {
     77             if (file[i].isFile())
     78             {
     79                 // 源文件
     80                 File sourceFile = file[i];
     81                 // 目标文件
     82                 File targetFile = new File(fTargetDir, file[i].getName());
     83                 copyFile(sourceFile, targetFile);
     84             }
     85             //递归复制子目录
     86             if (file[i].isDirectory())
     87             {
     88                 // 准备复制的源文件夹
     89                 String subSourceDir = sourceDir + File.separator + file[i].getName();
     90                 // 准备复制的目标文件夹
     91                 String subTargetDir = targetDir + File.separator + file[i].getName();
     92                 // 复制子目录
     93                 copyDirectiory(subSourceDir, subTargetDir);
     94             }
     95         }
     96     }
     97     public static void main(String[] args) throws IOException
     98     {
     99         copyDirectiory("d:/sxtjava", "d:/sxtjava2");
    100     }
    101 }

    可选题

    1.使用IO包中的类读取D盘上exam.txt文本文件的内容,每次读取一行内容,将每行作为一个输入放入ArrayList的泛型集合中并将集合中的内容使用加强for进行输出显示。

     

     1 public class Test
     2 {
     3     public static void main(String[] args) throws IOException
     4     {
     5         String path = "D:\exam.txt";
     6         outputMethod(path);
     7     }
     8     public static void outputMethod(String path) throws IOException
     9     {
    10         List<String> list = new ArrayList<String>(); // 创建集合对象
    11         // 创建缓冲区对象
    12         BufferedReader br = new BufferedReader(new FileReader(path));
    13         String line = br.readLine(); // 读取数据每次读一行
    14         while (line != null)
    15         {
    16             list.add(line);
    17             line = br.readLine();
    18         }
    19         br.close();              //关闭
    20         for (String s : list)
    21         {
    22             System.out.println(s);
    23         }
    24     }
    25 }

    2.假设从入学开始所有书写的Java类代码都在d:/sxtjava文件夹下,包括多级子文件夹。使用IO流获取从入学开始,到目前为止已经写了多少行Java代码。

    提示:

    其实就是获取d:/sxtjava文件夹及其子文件夹下的所有.java文件,使用readLine()读取其中每一行,每读取一行,行数加1。所有的文件读取完毕,得到总共已经写的Java代码行数。需要结合递归实现。

     

     1 public class TestCountDir
     2 {
     3     private int count;
     4     /**
     5      *
     6      * 统计一个java文件的行数
     7      *
     8      */
     9     private void countLine(File sourceFile) throws IOException
    10     {
    11         BufferedReader br = null;
    12         try
    13         {
    14             // 新建文件输入流
    15             br = new BufferedReader(new FileReader(sourceFile));
    16             while (br.readLine() != null)
    17             {
    18                 count++;
    19                 //System.out.println(count);
    20             }
    21         } finally
    22         {
    23             br.close();
    24         }
    25     }
    26     /**
    27      *
    28      * 统计一个目录下所有Java文件的行数
    29      *
    30      */
    31     private void countDir(String sourceDir) throws IOException
    32     {
    33         // 检查源目录
    34         File fSourceDir = new File(sourceDir);
    35         if (!fSourceDir.exists() || !fSourceDir.isDirectory())
    36         {
    37             System.out.println("源目录不存在");
    38             return;
    39         }
    40         // 遍历目录下的文件或目录
    41         File[] file = fSourceDir.listFiles();
    42         for (int i = 0; i < file.length; i++)
    43         {
    44             if (file[i].isFile())
    45             {
    46                 if (file[i].getName().toLowerCase().endsWith(".java"))
    47                 {
    48                     // System.out.println(file[i].getName());
    49                     countLine(file[i]);
    50                 }
    51             }
    52             //递归统计代码行数
    53             if (file[i].isDirectory())
    54             {
    55                 // 准备统计的文件夹
    56                 String subSourceDir = sourceDir + File.separator + file[i].getName();
    57                 // 统计子目录
    58                 countDir(subSourceDir);
    59             }
    60         }
    61     }
    62     public static void main(String[] args) throws IOException
    63     {
    64         TestCountDir tcd = new TestCountDir();
    65         tcd.countDir("d:/sxtjava");
    66         System.out.println(tcd.count);
    67     }
    68 }

    3.由控制台按照固定格式输入学生信息,包括学号,姓名,年龄信息,当输入的内容为exit退出;将输入的学生信息分别封装到一个Student对象中,再将每个Student对象加入到一个集合中,要求集合中的元素按照年龄大小正序排序;最后遍历集合,将集合中学生信息写入到记事本,每个学生数据占单独一行。

     

     1 public class Student implements Comparable<Student>
     2 {
     3     private Integer num;
     4     private String name;
     5     private Integer age;
     6     //省略getter和setter方法
     7     //省略构造方法
     8     public int compareTo(Student stu)
     9     {
    10         return this.age - stu.age;
    11     }
    12     public String toString()
    13     {
    14         return "Student [age=" + age + ", name=" + name
    15                 + ", num=" + num + "]";
    16     }
    17 }
    18 public class Test
    19 {
    20     public static void main(String[] args)
    21     {
    22         Set<Student> stuSet = saveStudentInfo();
    23         outputInfo(stuSet);
    24     }
    25     private static Set<Student> saveStudentInfo()
    26     {
    27         Scanner input = new Scanner(System.in);
    28         // 保存学生信息的TreeSet集合对象
    29         Set<Student> stuSet = new TreeSet<Student>();
    30         while (true)
    31         {
    32             // 输入提示
    33             System.out.println("请输入学生信息:(学号#姓名#年龄)");
    34             String inputData = input.nextLine();
    35             // 判断是否退出 inputData.equals("exit")
    36             if ("exit".equals(inputData))
    37             {
    38                 break;
    39             }
    40             // 将用户输入的学生信息分割为String[]
    41             String[] info = inputData.split("#");
    42             // 将输入信息封装到Student对象中
    43             Student stu
    44                     = new Student(Integer.parseInt(info[0]), info[1],
    45                             Integer.parseInt(info[2]));
    46             // 将学生对象加入集合
    47             stuSet.add(stu);
    48         }
    49         return stuSet;
    50     }
    51     private static void outputInfo(Set<Student> stuSet)
    52     {
    53         File file = new File("e:/student.txt");
    54         // 创建文件输出流对象
    55         FileWriter fw = null;
    56         try
    57         {
    58             fw = new FileWriter(file);
    59             Iterator<Student> it = stuSet.iterator();
    60             while (it.hasNext())
    61             {
    62                 String info = it.next().toString();
    63                 // 将info字符串,写入记事本
    64                 fw.write(info);
    65                 // 完成换行功能
    66                 fw.write("
    ");
    67             }
    68         } catch (Exception e)
    69         {
    70             e.printStackTrace();
    71         } finally
    72         {
    73             try
    74             {
    75                 fw.close();
    76             } catch (IOException e)
    77             {
    78                 e.printStackTrace();
    79             }
    80         }
    81     }
    82 }

     

  • 相关阅读:
    深入理解javascript原型和闭包(5)——instanceof
    深入理解javascript原型和闭包(4)——隐式原型
    启动mongodb的方式
    继承的几种方式
    npm install express 安装失败
    npm insta --savell和npm install --save-dev的区别
    express笔记之一安装
    mongoVUE安装配置
    nodejs笔记之一简介
    nodejs配置之二NPM配置之gulp使用时出现的错误
  • 原文地址:https://www.cnblogs.com/guanghe/p/6063391.html
Copyright © 2011-2022 走看看