Java I/O系统

Java I/O系统：

1.  Java类库提供了大量类，可以帮助我们从不同的设备读取数据，并保存或输出到不同的设备中。这些类同一放在java.io包和java.nio包中，统称为java I/O系统。

2.  流：我们可以将流理解为传送数据的管道，流是java I/O的基础，是java语言对 I/O 的一个最基本的抽象

　　　　流的两个最基本特性：

　　　　　　　　①含有流质。流质就是数据

　　　　　　　   ②有方向。方向就是读或写，即针对设备进行信息的输入和输出

　　　　流的分类：

　　　　　　1)输入流和输出流——按流的方向分

　　　　　　　　输入流：从数据源读取数据到程序中。只能读不能写。io包中的输入流都继承自抽象类OutputStream或Reader 。

　　　　　　　　输出流：将数据从程序写入数据目的地。只能写不能读。io包中的输出流都继承自抽象类InputStream或Writer 。

　　　　　　2)字节流和字符流——流按处理数据的最小单位的不同分

　　　　　　　　字节流：以byte为最小单位进行数据传送。io包中的字节流都继承自抽象类InputStream或OutputStream 。

　　　　　　　　字符流：以char为最小单位进行数据传送。io包中的字节流都继承自抽象类Reader 或Writer 。

　　　　　　3)节点流和处理流——按流的功能分

　　　　　　　　节点流：又叫低级流，是可以直接 从 / 向 一个特定的数据源 读 / 写 数据的流 。

　　　　　　　   处理流：又叫高级流，处理流不能直接连接到设备，而是连接在已存在的流之上，通过对数据的处理为程序提供更强大的 读 / 写 功能 。

　　　　　　　　　*  如果类的构造器带有一个已存在的流作为参数，那它就是高级流 。

3.  I/O库中类具有对成性：

　　　　　　　　　　　  1)输入流和输出流的对称

　　　　　　　　　　 　 2)字节流和字符流的对称

I/O操作步骤：建立流—>操作流—>关闭流

4.  文件类：将File对象看成是代表一个文件或目录的名称和位置的字符串。

5.  字节流：用于处理二进制文件

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 
 /**
  * 字节输入输出流测试
  * 
  * 
  */
public class IOTest {

     public static void main(String[] args) {
         StringBuffer buffer = new StringBuffer(); // 字符串缓冲
         
         /* 输入流 */
         InputStream in = null;
 
         try {
             // 1. 打开输入流
             in = new FileInputStream("E:\\jg\\exercise.txt");
             // 2. 读取
 //            byte[] b = new byte[128];
             byte[] b = new byte[1024 * 4];
            int len = in.read(b); // 返回读取到的字节数，返回-1表示读取到流结尾
             while(len != -1){
                 buffer.append(new String(b, 0, len)); // 将读取到的字节解析为String追加到缓冲
                 len = in.read(b);
            }
 //            System.out.println("读到" + len + "字节的数据");
             System.out.println(buffer.toString());
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             // 3. 释放资源，关闭输入流
             if (in != null){
                try {
                    in.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
         
         /* 输出流 */
         OutputStream out = null;
         
         try {
             File file = new File("D:\\test\\demo\\test.txt");
             if (!file.getParentFile().exists()){ // 文件路径不存在，则创建路径中所有不存在的目录
                 file.getParentFile().mkdirs();
             }
             // 1. 打开输出流
             out = new FileOutputStream(file);
             // 2. 写
             out.write(buffer.toString().getBytes());
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             // 3. 释放输出流资源
             if (out != null){
                try {
                     out.flush();
                     out.close();
                 } catch (IOException e) {
                    e.printStackTrace();
                 }
             }
         }
     }
 }

 

6.  字符流：用于处理文本文件

 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Reader;
 import java.io.Writer;
 
 /**
  * 字符输入输出流测试
  * 
  *
  */
 public class IOTest2 {
 
     public static void main(String[] args) {
         StringBuffer buffer = new StringBuffer();
 
         /* 输入流 */
         Reader reader = null;
 
         try {
             // 1. 打开流
             reader = new FileReader("E:\\jg\\exercise.txt");
             // 2. 读取
             char[] ch = new char[128]; // 缓冲区
             int len;
             do {
                 len = reader.read(ch);
                 if (len == -1)
                     break;
                 buffer.append(new String(ch, 0, len));
            } while (len != -1);
            System.out.println(buffer.toString());
        } catch (FileNotFoundException e) {
             e.printStackTrace();
        } catch (IOException e) {
             e.printStackTrace();
         } finally {
             // 3. 释放资源
             if (reader != null) {
                 try {
                     reader.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
 
         /* 输出流 */
 
         Writer writer = null;
 
         try {
             // 1. 打开流
             writer = new FileWriter("d:\\test.txt");
             // 2. 写入
             writer.write(buffer.toString());
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             // 3. 释放资源
             if (writer != null) {
                 try {
                     writer.flush();
                     writer.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
            }
         }
     }
 } 

 

7.  对象流：基于对象的读写，由ObjectInputStream / ObjectOutputStream来提供

　　　　　　读写对象：①对应的类必须实现java.io.Serializable接口；

　　　　　　　　　　　②类被序列化之后通过ObjectInputStream / ObjectOutputStream对对象进行读写。

　　　　　　在定义类是用 transient 修饰属性则该属性不能被实例化。这样有利于保护数据安全性。

　　　　　　实现接口后使用ObjectInputStream 类将对象拆成字节序列的过程称为序列化；使用 ObjectOutputStream 类将字节序列还原称对象的过程称为反序列化。

8. java IO一般使用原则：

　　8.1按数据来源（去向）分类：

　　　　1、是文件：FileInputStream, FileOutputStream, FileReader, FileWriter 

　　　　2、是byte[]：ByteArrayInputStream, ByteArrayOutputStream 

　　　　3、是Char[]: CharArrayReader, CharArrayWriter 

　　　　4、是String: StringBufferInputStream, StringReader, StringWriter 

　　　　5、网络数据流：InputStream, OutputStream, Reader, Writer 

　　8.2按是否格式化输出分：

　　　　1、要格式化输出：PRintStream, PrintWriter 

　　8.3按是否要缓冲分：

　　　　1、要缓冲：BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter 

　　8.4按数据格式分：

　　　　1、二进制格式（只要不能确定是纯文本的）: InputStream, OutputStream及其所有带Stream结束的子类

　　　　2、纯文本格式（含纯英文与汉字或其他编码方式）；Reader, Writer及其所有带Reader, Writer的子类

　　8.5按输入输出分：

　　　　1、输入：Reader, InputStream类型的子类

　　　　2、输出：Writer, OutputStream类型的子类

　　8.6特殊需要：

　　　　1、从Stream到Reader,Writer的转换类：InputStreamReader, OutputStreamWriter 

　　　　2、对象输入输出：ObjectInputStream, ObjectOutputStream 

　　　　3、进程间通信：PipeInputStream, PipeOutputStream, PipeReader, PipeWriter

　　　　4、合并输入：SequenceInputStream 

　　　　5、更特殊的需要：PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader