java I/O系统

java I/O系统

I:Input 输入 O:Output 输出

二：流的分类

按照方向：输入流  输出流

按照最小单位：字节流 （byte）  字符流 (char)

三：

所有的I/O系统操作都由以下步骤构成

1）建立流

2）操作流

3）关闭流

四：文件类

java.io包中的File类提供了管理磁盘文件和目录的基本功能

File类有四种构造方法

最常用的的是  public File(URI uri)  URI是资源统一标识符

java.io.File的一些方法，主要还是要查看API文档。

package com.lovo;

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

/**
 * File类测试
 * 
 * @author hellokitty
 *
 */
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);
        }
54 
        // 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件对象
        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();
            }

            try {
                // 创建空文件
                System.out.println("文件是否创建成功：" + file.createNewFile());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

五：字节流 byte：用于处理二进制文件

InputStream  ----》FileInputStream    (读取)   OutputStream ---》FileOutputStream   (写入)

字节流的输入输出流代码测试

package com.lovo;

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 hellokitty
 *
 */
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[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 {
74                     out.close();//已经带有刷新的了
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

六：字符流 char 用于处理文本文件   Reader----》InputStreamReader--->FileReader       Write---》OutputStreamWrite---》FileWrite

package com.lovo;

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

/**
 * 字符输入输出流测试
 * 
 * @author14  *
 */
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 {
68                     writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

七：缓冲流

package com.lovo.day2;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
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 BufferedTest {

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        copyByBuffer("E:\myeclipse-2015-2014-07-11-offline-installer-windows.exe", "d:\test.exe");
        long end = System.currentTimeMillis();
        System.out.println("缓冲：" + (end - start));
        System.out.println("***************");
        start = System.currentTimeMillis();
        copy("E:\myeclipse-2015-2014-07-11-offline-installer-windows.exe", "d:\test2.exe");
        end = System.currentTimeMillis();
        System.out.println("不带缓冲：" + (end - start));
    }
    
    private static void copy(String source, String destination){
        InputStream in = null;
        OutputStream out = null;
        
        File file = new File(destination);
        if (!file.getParentFile().exists()){
            file.getParentFile().mkdirs();
        }
        
        try {
            // 打开流
            in = new FileInputStream(source);
            out = new FileOutputStream(file);
            // 操作：读写
            byte[] b = new byte[1024];
            int len;
            
            while(-1 != (len=in.read(b))){
                out.write(b, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            if (in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(out != null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    private static void copyByBuffer(String source, String destination){
        BufferedInputStream in = null;
        BufferedOutputStream out = null;
        
        try {
            // 打开流
            in = new BufferedInputStream(new FileInputStream(source), 8 * 1024 * 1024);
            out = new BufferedOutputStream(new FileOutputStream(destination), 8 * 1024 * 1024);
            // 读写
            byte[] b = new byte[1024];
            int len;
            
            while(-1 != (len = in.read(b))){
                out.write(b, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 释放资源
            if (in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (out != null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    } 
}

有缓冲的比没有缓冲要快些。

未完。。。