Java I/O系统

一、I/O系统：就是Java中用于数据写入和读取的类和方法，而这些类和方法都存在于java.io包和java.nio包中。其中的 "I" 是Input, "O" 是 Output, 所以也叫输入输出系统；

二、流：所谓流，简单的说，就是文件和程序之间传输的数据，而流也有方向，它必有源端和目的端，也就是输入端和输出端；

三、流的分类：

　　1. 根据处理数据的单位不同可分为字节流和字符流　　　　

　　　　字节流：以字节为单位操作流

　　　　　　InputStream

　　　　　　OutputStream

　　　　字符流：以字符为单位操作流

　　　　　　Reader

　　　　　　Writer

　　2. 根据流向的不同可分为输入流和输出流

　　　　输入流：文件 ---> 程序

　　　　　　InputStream

　　　　　　Reader

　　　　输出流：程序 ---> 文件

　　　　　　OutputStream

　　　　　　Writer

　　3. 根据流的功能可以分为节点流（低级流）和处理流（高级流，也叫过滤流）

　　　　节点流：直接与数据相连，来操作流

　　　　处理流：要在其他已有流的基础上，进行数据传输

四、流的使用步骤：

　　1. 打开一个输入/输出流对象

　　2. 读取或写入数据

　　3. 释放资源，关闭输入/输出流对象

 

五、文件类

　　1. File 类（文件或目录的表示），提供了管理磁盘文件和目录的基本功能。

　　2. 常用的方法：

　　　　delete() 删除文件或目录，如果此路径名表示一个目录，则该目录必须为空才能删除 

　　　　exists() 判断文件或目录是否存在 

　　　　isFile() 判断是否为文件 

　　　　isDirectory() 判断是否为目录 

　　　　length() 获得文件的长度 

　　　　mkdir() 创建此抽象路径名指定的目录 

　　　　mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录 

六、序列化：把对象转换为字节序列的过程称为对象的序列化。序列化能够保存对象的“全景图”。

      反序列化：把字节序列恢复为对象的过程。

　　注意：要实现序列化的对象，必需是实现了Serializable接口，（Serializable接口是一个标记接口）；

　　　　  使用了 transient修饰的属性不会被序列化；

七、实例：

　　1. 文件类的使用

package com;

import java.io.File;
import java.io.IOException;
import java.util.Date;

/**
 * File类测试
 * @author Administrator
 *
 */
public class FileTest {

    public static void main(String[] args) {
        // 创建File对象
        File file = new File("E:\jg\exercise_bak.txt");  // 参数为该文件或目的的地址

        // 能否读
        System.out.println("能否读：" + file.canRead());

        // 删除
        System.out.println("删除成功：" + file.delete());

        // 重新创建文件对象
        file = new File("E:\jg\exercise_bak.txt");

        // 判断文件是否存在
        System.out.println("是否存在：" + file.exists());

        // 目录或文件名称
        System.out.println("名称：" + file.getName());

        // 是否目录、文件
        System.out.println("是否目录：" + file.isDirectory());
        System.out.println("是否文件：" + file.isFile());

        // 最后一次修改时间
        System.out.println("最后一次修改时间：" + new Date(file.lastModified()));

        // 文件大小
        System.out.println("文件大小：" + file.length());

        // 重新创建File对象
        file = new File("E:\jg");

        System.out.println("文件目录列表：");
        // 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录
        String[] list = file.list();
        for (String string : list) {
            System.out.println(string);
        }
        System.out.println("*******************************");

        // 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件对象
        File[] files = file.listFiles();
        for (File item : files) {
            if (item.isDirectory()) { // 当前File对象为目录，则遍历该目录下所有子目录与文件
                System.out.println(item.getName() + " 目录下子目录与文件：");
                String[] it = item.list();
                for (String i : it) {
                    System.out.println(i);
                }
                System.out.println("*******************************");
                continue;
            }

            System.out.println(item.getName() + "  文件");
        }

        // 重新创建File对象
        file = new File("E:\jg\test\demo\test.txt");
        if (!file.exists()) { // 文件不存在
            // 获取文件路径
            File dir = file.getParentFile();
            if (!dir.exists()) { // 目录不存在，则创建路径中所有不存在的目录
                dir.mkdirs();
            }85         }

    }
}

 

 

　　2. 字节流的使用

package com;

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;

/**
 * 字节输入输出流测试
 * 
 * @author Administrator
 *
 */
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();
                }
            }
        }
    }
}

 

 

　　3. 字符流的使用

package com;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

/**
 * 字符输入输出流测试
 * 
 * @author Administrator
 *
 */
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();
                }
            }
        }
    }
}