14 Java面试之 IO 流技术

一、IO 是什么意思? data source 是什么意思?
答:
IO:Input输入 Output输出;
data source:数据源

二、字节流和字符流有什么区别？输入流和输出流有什么区别？
答:
1、字符流和字节流是流的一种划分，按照处理流的数据单位进行的划分。两类都分为输入和输出操作;
2、在字节流中输出数据主要是使用 OutputStream 完成，输入使用的是 InputStream，在字符流中输出主要是使用 Writer 类完成，输入流主要使用 Reader 类完成。这四个都是抽象类。
3、字符流处理的单元为 2 个字节的 Unicode 字符，分别操作字符、字符数组或字符串，而字节流
处理单元为 1 个字节，操作字节和字节数组。
4、字节流是最基本的，所有的 InputStrem 和OutputStream 的子类都是字节流,主要用在处理二进制数据，它是按字节来处理的。
5、实际文本，又提出了字符流的概念，它是按虚拟机的编码来处理，也就是要进行字符集的转化，这两个之间通过InputStreamReader,OutputStreamWriter（转换流）来关联，实际上是通过 byte[]和 String 来关联的;

1、流就像管道一样，在程序和文件之间，输入输出的方向是针对程序而言，向程序中读入东西，就是输入流，从程序中向外读东西，就是输出流。输入流是得到数据，输出流是输出数据。

三、节点流和处理流有什么区别?
答:
节点流：
可以从或向一个特定的地方（节点）读写数据。如FileReader
FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流
处理流：
是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。
如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。
BufferedImputStrean BufferedOutputStream BufferedReader BufferedWrite

四、word 文档能使用字符流操作吗?为什么?
答:
不能。因为 word 文档不是纯文本文件，除了文字还包含很多格式信息。不能用字符流操作。可以用字节流操作;

五、流对象使用完后，一般要调用 close 方法关闭，释放资源。 这种做法对吗?
答:
对。因为绝大多数流对象都打开了底层操作系统的 IO，如果不手动关闭，底层操作系统资源会一直使用，造成资源浪费;

六、InputStream 和 OutputStream 基本特点是?
答:
二者都是【字节】输入输出流的抽象父类。以字节为单位处理数据，每次读取/写入一个字节。适合处理二进制文件，如音频、视频等.
实现类有FileInputStream 和 FileOutputStream

        FileOutputStream  out = null;
          try {
            out = new FileOutputStream("e:\\测试类文件\\file.txt");//有异常需try catch
               String  Str = new String ("疯狂的学习");
                byte[] b = Str.getBytes();
                    out.write(b);//有异常需try catch
                    System.out.println("写入ok");
          } catch (Exception e) {
            e.printStackTrace();
        }finally{
            try {
                out.close();//有异常需try catch
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
FileInputStream in = null;
              try {
              in = new FileInputStream("e:\\测试类文件\\file.txt");//有异常需try catch
                byte [] b =new byte [1024];
                      int w=in.read(b);//有异常需try catch
                      System.out.println(w);//int w获取字节个数查API
                      String s = new String(b,0,w);//,0,获取元素个数查API
                      System.out.println(s+s.length());
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                try {
                    in.close();//有异常需try catch
                } catch (IOException e) {
                    e.printStackTrace();
                } 
            }

七、Reader 和 Writer 的基本特点是?
答:
二者都是【字符】输入输出流的抽象父类。以字符为单位处理数据，每次读取/写入一个字符。适合处理文本文件。实现类有 FileReader 和 FileWriter 等
FileWriter writer = null;
try {
writer = new FileWriter(“e:\测试类文件\writer.txt”);//有异常用try catch包围
writer.write(“疯狂的人们\n疯狂的学习”);
System.out.println(“ok”);
writer.flush();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
writer.close();//有异常用try catch包围
} catch (IOException e) {
e.printStackTrace();
}
}
FileReader reader = null;
BufferedReader buffered = null;
try {
reader = new FileReader(“e:\测试类文件\writer.txt”);//有异常用try catch包围
buffered = new BufferedReader(reader);//有异常用try catch包围
String S =null;//readLine返回String类型，查API
while((S =buffered.readLine())!=null){//利用循环进行读
System.out.println(S);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
try {
buffered.close();//有异常用try catch包围
reader.close();//有异常用try catch包围
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

八、BufferedInputStream 和 BufferedOutputStream 的特点是？
答:
1、BufferdedInputStream 和 BufferedOutputStream 分别是【缓冲】字节输入输出流，还有【缓冲】字符输入输出流（BufferReader 和 BufferedWriter）。
2、缓冲流是处理流，它不直接连接数据源/目的地，而是以一个节点流为参数，在节点流的基础上，提供一些简单操作
3、优点：减少对硬盘的读取次数，降低对硬盘的损耗

九、InputStreamReader 和 OutputStreamWriter 的作用是?
答:
二者都是转换流，从字节流转换为字符流，是包装流，

// 节点流；
InputStream is = new FileInputStream(new File(“e:\测试类文件\file.txt”));
// 处理流：把字节流转换成了字符流；
InputStreamReader isr = new InputStreamReader(is, “utf-8”);
int temp = 0;
// 以字符（而不是字节）为单位读取文本文件，方便操作。
while ((temp = isr.read()) != -1) {
System.out.print((char) temp);
}
isr.close();
Writer out = new OutputStreamWriter(new FileOutputStream(new File(“e:\测试类文件\file.txt”)));
out.write(“hello world!!”) ; // 使用字符流输出
out.close() ;
十、PrintStream 打印流经常用于什么情况? System.out 是不是打印流?
答:
1、PrintStream：字节打印流，是 OutputStream 的实现类。提供了多个重载的print,println 等方法，可以方便地向文本文件中写入数据。
2、System.out 是字节打印流（PrintStream的对象），它被称作标准的输出流,输出的目的地是标准的输出设备，即显示器.
3、当我们使用 System.out.print 或
System.out.println 时会向屏幕（显示器）输出数据。

十一、DataInputStream 和 DataOutputStream 的特点是?
答:
1、二者都是处理流，要以一个节点流为参数；二者被称为数据流，是用来操作基本数据类型的。
2、用DataInputStream 写入一个类型的数据，用 DataOutputStream 读出数据时可以保持类型不变。
数据流特点：

1. 写入是什么类型的数据，读出是相应类型的数据；
2. 要先写后读；用 DataOutputStream 流写，用 DataInputStream 流读；
3. 数据流可以跨平台写入和读出，适合网路应用。

Person p = new Person("张三",123);
                DataOutputStream data = null;
        try {
            //异常需要try catch
             data = new DataOutputStream(new FileOutputStream("e:\\测试类文件\\Person.txt"));
             data.writeUTF(p.getName());//异常需要try catch
                data.writeInt(p.getAge());  //异常需要try catch
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }  finally{
            try {
                data.close();//异常需要try catch
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }   
DataInputStream date = null;
           try {
             date = new DataInputStream(new FileInputStream("e:\\测试类文件\\Person.txt"));
              String name =date.readUTF();
                      int  age =date.readInt();
                      Person p = new Person(name,age);
                      System.out.println(p);
           } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                date.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

十二、【编程题】自定义一个对象 使用ObjectInputstream 和 ObjectOutputStream 储到硬盘上并读取出来？
答:

//需实现Serializable
public class Student implements Serializable {}
//将对象序列化到本地（磁盘）
          Student str = new Student("张三",35);
          ObjectOutputStream object=null;
         try {
            //创建ObjectOutputStream对象
        object = new ObjectOutputStream(new FileOutputStream("e:\\测试类文件\\Student.txt"));
                    object.writeObject(str);
                    object.flush();
         } catch (Exception e) {
            e.printStackTrace();
        }finally{
            try {
                object.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //对象的反序列化
        ObjectInputStream In=null;
            try {
                //创建ObjectInputStream对象
                In = new ObjectInputStream(new FileInputStream("e:\\测试类文件\\Student.txt"));
                  Student St =(Student)In.readObject();   
                  System.out.println(St);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }finally{
                try {
                    In.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

十三、unicode 字符集是几个字节表示一个字符?
答:
Unicode 字符集中 2 个字节表示一个字符。

十四、序列化和反序列化指的是什么?
答:
序列化：
将对象以 byte 流的形式写入到文件中,
被序列化的对象的类要实现 Serializable 接口;该类的对象具有了将对象以 byte 流的形式写进文件的功能。
反序列化：
将文件中的数据以 byte 流的形式读到程序中来，依然是一个对象;

十五、序列化某个类的对象，该类必须实现 sierializable 接口吗?
答:
要序化的对象必须实现 Serializable 接口，以启动序列化的功能

十六、说说 sierializable 接口的特点?
答:
1、需要被序列化的对象的类必须实现 Serializable 接口。
2、 给类加个序列化编号，即给类定义一个标记，如：
public static final long serialVersionUID=1L;
新的修改后的类还可以操作曾经序列化的对象。
3、静态是不能被序列化的，序列化只能对堆中的对象进行序列化 ，不能对”方法区”中的对象进行序列化。
4、不需要序列化的字段前加 transient,如：
private transient String password;

十七、transient 的作用是？
答:
不希望序列化的属性，可以添加 transient 关键字;
如:密码铭感属性不需要些到文件中