IO的基本简单操作

流式输入/输出原理：就是进行读写数据的操作，由管道相连，一端连着程序，一端连着数据源。

文件操作

File类可以表示文件和目录的信息，但是不能表示文件里面的具体内容。
File类中最常用的方法有：
创建一个新文件：public boolean createNewFile() throws IOException
删除文件：public boolean delete()
判断文件目录是否存在： public boolean exists()
创建文件夹：public boolean mkdir()
判断是否是根目录：public boolean isDirectory()
举例子：递归地输出一个目录下所有文件：

import java.io.File;

public class RecursiveListAllFiles {
public static void listAllFiles(File dir)
{
    if (dir == null || !dir.exists()) {
        return;
    }
    if (dir.isFile()) {
        System.out.println(dir.getName());
        return;
    }
    for (File file : dir.listFiles()) {
        listAllFiles(file);
    }
}
public static void main(String[] args) {
    File file = new File("D:\\java");
    RecursiveListAllFiles.listAllFiles(file);
}
}

字节文件处理复制

字节流：最原始的字节流是010101...这种二进制的形式，8位，可以处理所有数据类型的数据，在java中以Stream结尾；
 

public static void main(String[] args) throws IOException {
    //1 源文件
    File src = new File("E:/xxx.pdf");
    //2目标文件
    File target = new File("E:/yyy.pdf");
    //3 缓存
    byte[] b = new byte[1024];
    //4相对缓存来说是输入流
    FileInputStream in = new FileInputStream(src);
    //5 相对缓存来说是输出流
    FileOutputStream out = new FileOutputStream(target);
    //6每次的输入的长度
    int len;
    //如果长度大于0
    while((len = in.read(b))> 0) {
        out.write(b, 0, len);
    }
    in.close();
    out.close();
}

}

长例子：

package io;


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class StreamExample {


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

        //源文件
        String source = "D:/example/stream.txt";
        //目标文件
        String dist = "D:/example/streamCopy.txt";
        //开始
        Long stratTime = System.currentTimeMillis();
        //调用方法
        //method1(source,dist);
        //method2(source,dist);
        //method3(source,dist);
        listDir("D:\\example");
        method4(source,dist);
        //结束时间
        Long endTime = System.currentTimeMillis();
        System.out.println("所用时间"+(endTime-stratTime)+"毫秒");
    }

    //基本字节流读一个字节
    public static void method1(String source,String dist) throws IOException {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(source);
            fos = new FileOutputStream(dist);
            int c = 0;
            while((c=fis.read()) != -1) {
                fos.write(c);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (fis != null) {
                fis.close();
            }
            if (fos != null) {
                fos.close();
            }
        }
    }

    //基本字节流读一组字节
    public static void method2(String source,String dist) throws IOException {

        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(source);
            fos = new FileOutputStream(dist);
            //定义字节数组
            byte[] buf = new byte[1024];
            //定义实际读取字节数
            int hasRead = 0;
            while((hasRead = fis.read(buf)) != -1) {
                fos.write(buf, 0, hasRead);

            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (fis != null) {
                fis.close();
            }
            if (fos != null) {
                fos.close();
            }
        }

    }

    //处理流读取一个字节
    public static void method3(String source,String dist) throws IOException {

        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            fis = new FileInputStream(source);
            //处理流
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream(dist);
            //处理流
            bos = new BufferedOutputStream(fos);
            int c = 0;
            while((c = bis.read()) != -1) {
                bos.write(c);
            }
            bos.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (bis != null) {
                bis.close();
            }
            if (bos != null) {
                bos.close();
            }
        }

    }

    //处理流读取一个数组
    public static void method4(String source,String dist) throws IOException {

        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
            fis = new FileInputStream(source);
            //处理流
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream(dist);
            //处理流
            bos = new BufferedOutputStream(fos);
            int hasRead = 0;
            byte[] buf = new byte[1024];
            while ((hasRead = bis.read(buf)) != -1) {
                bos.write(buf, 0, hasRead);
            }
            bos.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (bis != null) {
                bis.close();
            }
            if (bos != null) {
                bos.close();
            }
        }

    }

    //定义读取文件的文件名
    public static void listDir(String dir) throws IOException {

        File file = new File(dir);
        //判断是否为文件目录
        if (!file.isDirectory()) {
            //不是，抛出异常
            throw new IOException(dir + "不是目录");
        }
        //定义文件名数组
        File[] files = file.listFiles();
        for (File f : files) {
            //可能是一个多级目录，使用递归
            if (f.isDirectory()) {
                listDir(f.getAbsolutePath());
            }else {
                System.out.println(f.getAbsolutePath());
            }
        }

    }



}