java：IO流（File，字节流/输入输出流（InputStream（FileInputStream），OutputStream（FileOutStream）），字符流（Reader，Writer））

File：

* java.io.File类:代表一个文件或目录。
* 常用的构造方法:
* File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
* File(String parent, String child)根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
* File(File parent, String child)根据 parent对象 和 child 路径名字符串创建一个新 File 实例。
*
* 常用方法1:
* getName()返回由此抽象路径名表示的文件或目录的名称。
* getPath()将此抽象路径名转换为一个路径名字符串。
* isFile() 测试此抽象路径名表示的文件是否是一个标准文件。
* isDirectory()测试此抽象路径名表示的文件是否是一个目录。
* length() 返回由此抽象路径名表示的文件的长度。目录是没有大小。
* canExecute() 测试应用程序是否可以执行此抽象路径名表示的文件。
* canRead() 测试应用程序是否可以读取此抽象路径名表示的文件。
* canWrite() 测试应用程序是否可以修改此抽象路径名表示的文件。
* exists()测试此抽象路径名表示的文件或目录是否存在。
* mkdir()创建此抽象路径名指定的目录。只能创建一级目录(父目录必须存在)
* mkdirs()创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
* createNewFile()当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
* delete()删除此抽象路径名表示的文件或目录，如果都是文件夹则删除最下级空文件夹，如果文件夹包含文件，则谁也不删除。
* 注意:java中'\'字符是转义符，如果利用'\'表示路径必须写出"\\"

import java.io.File;
import java.io.IOException;

public class TestFile {
    public static void main(String[] args) {
//        File file = new File("D:\\code\\day6\\TestArray.java");
//        File file = new File("D:/code/day6/TestArray.java");
        File file = new File("D:/code/day6","TestArray.java");
        System.out.println("文件名称:"+file.getName());
        System.out.println("文件路径:"+file.getPath());
        System.out.println("File对象是否表示文件:"+file.isFile());
        System.out.println("File对象是否表示目录:"+file.isDirectory());
        System.out.println("文件的大小:"+file.length()+"字节");
        System.out.println("该文件是否可执行:"+file.canExecute());
        System.out.println("该文件是否可读:"+file.canRead());
        System.out.println("该文件是否可写:"+file.canWrite());
        System.out.println("该文件是否存在:"+file.exists());
        System.out.println("------------------------------");
        File file2 = new File("D:/test/aa/bb");
        if(!file2.exists()){
//            file2.mkdir();//创建目录
            file2.mkdirs();//创建多级目录
            System.out.println("目录创建成功!");
        }
        File file3 = new File(file2,"aa.txt");
        try {
            if(!file3.exists()){
                file3.createNewFile();//创建文件
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        //删除文件
        file3.delete();
        //删除目录
        file2.delete();
    }
}

*File类中的常用方法2:
* File[] listFiles():返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
* lastModified()返回此抽象路径名表示的文件最后一次被修改的时间。
*需求:模拟Dos命令中的dir命令，输出D:\code目录下所有子目录或子文件的名称
2017/05/31 18:13 <DIR> day6
2017/06/01 17:28 <DIR> day7
2017/06/01 17:49 12,941 day7.zip

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestFile2 {
    public static void main(String[] args) {
        File file = new File("D:/code");
        File[] subFiles = file.listFiles();//获取子文件或子目录
        for (File f : subFiles) {
            StringBuffer sb=new StringBuffer();
            long time = f.lastModified();//获取文件的最后修改时间
            Date date = new Date(time);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
            String dateStr = sdf.format(date);
            sb.append(dateStr+"\t");//2017/05/31  18:13
            //判断是否为目录
            if(f.isDirectory()){
                sb.append("<DIR>\t\t");
            }
            //判断是否为文件
            if(f.isFile()){
                long fileSize = f.length();//获取文件大小
                sb.append("\t"+fileSize+"\t");
            }
            //获取文件名称
            String fileName = f.getName();
            sb.append(fileName);
            System.out.println(sb);
        }
    }
}

* 需求:输出某个目录下的所有子目录或子文件的路径
* 递归算法:将复杂的问题分解成若干个相同的子问题进行解决。

import java.io.File;

public class TestFile3 {

    public static void showPath(File file){
        File[] fs = file.listFiles();//获取指定目录下所有的直接子目录或子文件。
        for (File f : fs) {
            if(f.isDirectory()){
                String path = f.getAbsolutePath();
                System.out.println(path);
                showPath(f);//递归调用
            }else{
                String path = f.getAbsolutePath();
                System.out.println(path);
            }
        }
    }

    public static void main(String[] args) {
        File file = new File("D:/test");
        showPath(file);
    }
}

*数据源:原始数据的源头。
*流的分类
*1.按照方向可以分为:输入流和输出流(相对于应用程序来说).
* 输入流:数据源--->应用程序(磁盘或网络)
* 输出流 :应用程序--->数据源
*2.按照读写单位来分:字节流和字符流
* 字节流:每次读写1个字节。
* 字符流:每次读写1个字符。
*3.按照功能来分:节点流和处理流
* 节点流:能直接操作数据源或目的地的流。
* 处理流:不能直接操作数据源或目的地(不能单独使用)，处理流必须与节点流结合使用，其主要作用是简化流的操作和提高流的读写效率。
*
*字节流:InputStream(字节输入流)/OutputStream(字节输出流)
* java.io.InputStream类:抽象类
* --java.io.FileInputStream类:继承了InputStream，从文件系统中的某个文件中获得输入字节。
* 常用的构造方法:
* FileInputStream(File file):通过打开一个到实际文件的连接来创建一个 FileInputStream
* FileInputStream(String name): 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定
* 常用的方法:
* read()从此输入流中读取一个数据字节。
* read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
* read(byte[] b, int off, int len) 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
* close()关闭此文件输入流并释放与此流有关的所有系统资源。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TestInputStream {
    public static void main(String[] args) {
        FileInputStream fis =null;
        try {
//            File file = new File("D:/test/aa.txt");
//            FileInputStream fis = new FileInputStream(file);
            fis = new FileInputStream("D:/test/aa.txt");
            int i;
            while((i=fis.read())!=-){
                char c=(char)i;
                System.out.print(c);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

FileInputStream输入方法2：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
 *String(byte[] bytes)通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
 */
public class TestInputStream2 {
    public static void main(String[] args) {
        FileInputStream fis =null;
        try {
            fis = new FileInputStream("D:/test/aa.txt");
            byte[] bs = new byte[];//用于保存从输入流读取的字节
            fis.read(bs);
            String content = new String(bs);
            System.out.println(content);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

FileInputStream输入方法3：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * read(byte[] b, int off, int len)从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
 * String(byte[] bytes, int offset, int length)通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
 */
public class TestInputStream3 {
    public static void main(String[] args) {
        FileInputStream fis =null;
        try {
            File file = new File("D:/test/aa.txt");
            fis = new FileInputStream(file);
            byte[] bs = new byte[];//用于保存从输入流读取的字节
            int len = fis.read(bs,,bs.length);
            String content = new String(bs,,len);//不同！！！
            System.out.println(content);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

FileOutStream输出方法：

*java.io.OutputStream类(字节输出流):抽象类
*--java.io.FileOutputStream类:继承了OutputStream
*常用的构造方法:
* FileOutputStream(File file)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* File file = new File("D:/test/aa.txt"); FileOutputStream fos = new FileOutputStream(file);
* FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流。
* FileOutputStream fos = new FileOutputStream("D:/test/aa.txt");
* FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* File file = new File("D:/test/aa.txt"); FileOutputStream fos = new FileOutputStream(file,true);
* FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流。
* FileOutputStream fos = new FileOutputStream("D:/test/aa.txt",true);
*
*常用的方法:
* write(int b)将指定字节写入此文件输出流。
* write(byte[] b)将 b.length 个字节从指定 byte 数组写入此文件输出流中。
* write(byte[] b, int off, int len)将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
* close()关闭此文件输出流并释放与此流有关的所有系统资源。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestOutputStream {
    public static void main(String[] args) {
        File file = new File("D:/test/aa.txt");
        FileOutputStream fos=null;
        try {
//            fos = new FileOutputStream(file);
//            fos = new FileOutputStream("D:/test/aa.txt");
//            fos = new FileOutputStream(file, true);//是否追加
            fos = new FileOutputStream("D:/test/aa.txt", true);
            fos.write('z');
            fos.write('z');
            fos.write('s');
            fos.write('x');
            fos.write('t');
            fos.write('!');
            System.out.println("写入完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

*需求:将D:/mp3/test.mp3复制到F:/test.mp3
*分析:
*1.使用字节输入流FileInputStream读取D:/mp3/test.mp3文件
*2.使用字节输出流FileOutputStream写入F:/test.mp3文件中

//复制的时候，输入和输入的后缀名必须相同：

//复制的时候，只能复制文件，文件夹不能复制！必须得创建

方法1：

fis=new FileInputStream("D:/kuang/cc/Notepad_6.4.5.exe");

fos=new FileOutputStream("D:/kuang/cc/zz/12231.exe"); //后面加true时，TXT文件，exe，jpg，文件都会追加

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopy {
    public static void main(String[] args) {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            fis = new FileInputStream("D:/mp3/test.mp3");
            fos = new FileOutputStream("F:/test.mp3");
            //1.使用输入流读取文件
            int i;
            while((i=fis.read())!=-){
                fos.write(i);
            }
            System.out.println("复制完毕!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fis.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

方法2：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopy2 {
    public static void main(String[] args) {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            fis = new FileInputStream("D:/mp3/test.mp3");
            fos = new FileOutputStream("F:/test.mp3");
            //1.使用输入流读取文件
            byte[] bs = new byte[];
            int len;
            while((len=fis.read(bs,,bs.length))!=-){
                //2.使用输出流写入目的地
                fos.write(bs,,len);
            }
            System.out.println("复制完毕!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fis.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

FileOutputStream方法3:

*java.io.OutputStream类(字节输出流):抽象类
*--java.io.FileOutputStream类:继承了OutputStream
*常用的构造方法:
* FileOutputStream(File file)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 
* File file = new File("D:/test/aa.txt"); FileOutputStream fos = new FileOutputStream(file);
* FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流。
* FileOutputStream fos = new FileOutputStream("D:/test/aa.txt");
* FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* File file = new File("D:/test/aa.txt"); FileOutputStream fos = new FileOutputStream(file,true);
* FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流。
* FileOutputStream fos = new FileOutputStream("D:/test/aa.txt",true);
* 
*常用的方法:
* write(byte[] b, int off, int len)将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
* close()关闭此文件输出流并释放与此流有关的所有系统资源。
*/

byte[] byt=new byte[];
     int len;
     while((len=fis.reade(byt))!=-){
         fos.write(byt); //后面有大量空格，范围更大
     }

FileOutputStream方法:

*java.io.OutputStream类(字节输出流):抽象类
*--java.io.FileOutputStream类:继承了OutputStream
*常用的构造方法:
* FileOutputStream(File file)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* File file = new File("D:/test/aa.txt"); FileOutputStream fos = new FileOutputStream(file);
* FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流。
* FileOutputStream fos = new FileOutputStream("D:/test/aa.txt");
* FileOutputStream(File file, boolean append) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
* File file = new File("D:/test/aa.txt"); FileOutputStream fos = new FileOutputStream(file,true);
* FileOutputStream(String name, boolean append)创建一个向具有指定 name 的文件中写入数据的输出文件流。
* FileOutputStream fos = new FileOutputStream("D:/test/aa.txt",true);
* String类中的方法: byte[] getBytes()使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
*常用的方法:
* write(byte[] b)将 b.length 个字节从指定 byte 数组写入此文件输出流中。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestOutputStream2 {
    public static void main(String[] args) {
        FileOutputStream fos=null;
        try {
            fos = new FileOutputStream("D:/test/aa.txt", true);
            String str="what are you  name?";
            fos.write(str.getBytes(),,str.length());
            System.out.println("写入完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

字符流：

*字符流:以字符为单位进行读写。Reader/Writer
*Reader(字符输入流):抽象类
*--InputStreamReader类:转换流属于处理流，将字节流转换字符流。
*----FileReader类:用来读取字符文件的便捷类。
* 常用的构造方法:
* FileReader(File file)在给定从中读取数据的 File 的情况下创建一个新 FileReader。
* FileReader(String fileName)在给定从中读取数据的文件名的情况下创建一个新 FileReader。
* 常用的方法:
* read() 读取单个字符。
* read(char[] cbuf) 将字符读入数组。
* read(char[] cbuf, int offset, int length)将字符读入数组中的某一部分。
* close()关闭该流并释放与之关联的所有资源。
*
*String类
*String(char[] value)分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
*String(char[] value, int offset, int count) 分配一个新的 String，它包含取自字符数组参数一个子数组的字符。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TestReader3 {
    public static void main(String[] args) {
        File file = new File("F:/测试.txt");
        FileReader fileReader=null;
        try {
            fileReader = new FileReader(file);
            char[] cs = new char[];//缓冲区
            int len = fileReader.read(cs,,cs.length);
            String str = new String(cs,,len);
            System.out.println(str);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }
}

String类
*String(char[] value)分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TestReader2 {
    public static void main(String[] args) {
        File file = new File("F:/测试.txt");
        FileReader fileReader=null;
        try {
            fileReader = new FileReader(file);
            char[] cs = new char[];//缓冲区
            fileReader.read(cs);
            String str = new String(cs);
            System.out.println(str);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class TestReader {
    public static void main(String[] args) {
        File file = new File("F:/测试.txt");
        FileReader fileReader=null;
        try {
            fileReader = new FileReader(file);
            int i;
            while((i=fileReader.read())!=-){
                char c = (char)i;
                System.out.print(c);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }
}

Homework：

1.使用字节流复制D:/mp3下所有文件和目录到到F:/mp3目录下（完成一个目录的复制）
2.使用字符流复制D:/test下所有的文件和目录到F:/test目录下，要求F盘符下如果没有test文件夹，进行自动创建。

eg：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 1.使用字节流复制D:/mp3下所有文件和目录到到F:/mp3目录下（完成一个目录的复制）--->复制整个目录(包含有文件和文件夹)
 * 分析:
 *  1.复制文件夹(使用递归获取目录结构和名称)
 *     a.使用递归遍历该文件夹的所有文件或文件夹
 *     b.在目标位置创建同名的文件夹
 *     c.复制该文件到目标位置
 *  2.复制文件
 */
public class Homework {
    /**
     * 复制文件到目标位置
     * @param source:源文件
     * @param target:目的地
     */
    public void copyFile(File source,File target){
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            fis = new FileInputStream(source);//将源文件转换为输入流
            fos = new FileOutputStream(target);// 目的地
            byte[] bs = new byte[];//缓冲区
            int len;
            //使用输入流读取数据
            while((len=fis.read(bs))!=-){
                //使用输出流写入数据
                fos.write(bs, , len);
            }
            fos.flush();//刷新缓冲区
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                fis.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 复制整个目录到指定位置
     * @param source: D:/mp3/test.mp3
     * @param target: F:/mp3
     */
    public void copyDir(File source,File target){
        //如果目标位置不存在，先创建目录
        if(!target.exists()){
            target.mkdirs();
        }
        //遍历源文件的目录结构，如果是子目录在目的地创建相同名称目录，如果是子文件需要将该文件复制到目的地位置
        File[] fs = source.listFiles();
        for (File file : fs) {
            String fileName = file.getName();
            File f = new File(target,fileName);
            //如果是文件，直接复制到目的地
            if(file.isFile()){
                copyFile(file,f);
            }
            //如果是目录,在目的地创建子目录
            if(file.isDirectory()){
                //创建目录
                f.mkdirs();
                //递归调用
                copyDir(file,f);
            }
        }
    }

    public static void main(String[] args) {
        Homework homework = new Homework();
        File source = new File("D:/mp3");
        File target = new File("F:/mp3");
        homework.copyDir(source,target);
        System.out.println("目录复制完成!");
    }
}