IO流:常见输入输出流：文件输入输出流，字符转换流；复制文件或多级文件夹；

IO流

一.概述及分类

A:IO流概述
	IO流用来处理设备之间的数据传输
	Java对数据的操作是通过流的方式
	Java用于操作流的对象都在IO包中 java.io
B:IO流分类
	a:按照数据流向 站在内存角度
		输入流	读入数据
		输出流	写出数据
	b:按照数据类型
		字节流 可以读写任何类型的文件 比如音频 视频  文本文件
		字符流 只能读写文本文件

二、字节输入输出流

InputStream:字节输入流，输入流所关联的文件不存在，则会报错
OutputStream:字节输出流，输出流所关联的文件不存在，会自动创建
注意：流用完之后必须关闭以释放资源，否则可能出现内存泄漏

1、文件输入流(FileInputStream)

常用方法

构造方法:
FileInputStream(File|String file|name);
FileInputStream in=new FileInputStream("e.txt");
in.read();//一次读取一个字节，如果最后读取不到，则返回-1
in.read(new byte[1024]);//一次最多读取1024个字节存进字节数组，返回值为读取到的字节长度
in.read(new byte[1024],起始索引,读取字节长度);//从此输入流中将最多 len 个字节的数据读入一个 byte 数组中
in.close();//流用完之后关掉

2、文件输出流(FileOutputStream)

常用方法

FileOutputStream out=new FileOutputStream(file|name);
//通过文件输出流，往他所关联的文件中，写入数据
out.write(97);//一次写入一个字节,超过一个字节会丢弃掉多余字节 //写入a
out.write(字节数组);//一次写入一个字节数组
out.write(字节数组，起始索引，写入字节个数);//一次写入一个字节数组的一部分
//UTF-8编码，一个汉字占三个字节
out.write("\r\n".getBytes());//windows系统换行
FileOutputStream(file|name,true);//参数2为true，追加写入
out.close();//关闭流

3、使用文件输入输出流进行文件的复制

方式一：一次读一个字节，写一个字节（效率低，一般不使用）

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

public class Demo1 {
    public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("e.txt");
        FileOutputStream out = new FileOutputStream("ee.txt");
        int len=0;
        while ((len=in.read())!=-1){//读取字节
            out.write(len);//写入字节
            out.flush();//刷新
        }
        out.close();//关闭输出流
        in.close();//关闭输入流
    }
}

方式二：一次读写一个字节数组（效率高）

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

public class CopyFile {
    public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("e.txt");
        FileOutputStream out = new FileOutputStream("ee.txt");
        byte[] bytes=new byte[1024*1024];//定义缓冲数组
        int len=0;
        long start = System.currentTimeMillis();
        while ((len=in.read(bytes))!=-1){//读取字节到数组
            out.write(bytes,0,len);//将数组中的字节写入
            out.flush();//刷新
        }
        long end = System.currentTimeMillis();
        System.out.println((end-start)+"ms");
        in.close();//关闭输入流
        out.flush();//关闭输出流
    }
}

4、流的异常处理

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

public class Demo2 {
    public static void main(String[] args) {

        FileInputStream in=null;
        FileOutputStream out=null;
        try {
            File file = new File("e.txt");
            if(file.exists()){
                in = new FileInputStream(file);
            }
            File file1 = new File("ee.txt");
            if(file1.exists()){
                out = new FileOutputStream(file1);
            }
            if(in!=null&&out!=null){
                byte[] bytes=new byte[1024*1024];//定义缓冲数组
                int len=0;
                long start = System.currentTimeMillis();
                while ((len=in.read(bytes))!=-1){//读取字节到数组
                    out.write(bytes,0,len);//将数组中的字节写入
                    out.flush();//刷新
                }
                long end = System.currentTimeMillis();
                System.out.println((end-start)+"ms");
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                if (in != null) {
                    in.close();//关闭输入流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (out != null) {
                    out.flush();//关闭输出流
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

5、高效(通过内部缓冲区实现)的文件输入输出流

BufferedInputStream:高效的文件输入流
BufferedInputStream(InputStream in):
          创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedInputStream(InputStream in, int size) 
          创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedOutputStream:高效的文件输出流
BufferedOutputStream(OutputStream out) 
          创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
BufferedOutputStream(OutputStream out, int size) 
          创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。

复制文件方式三 :使用高效的文件输入输出流

import java.io.*;

public class Demo {
    public static void main(String[] args) throws IOException {
        BufferedInputStream bufferIn = new BufferedInputStream(new FileInputStream("a.txt"));
        BufferedOutputStream bufferOut = new BufferedOutputStream(new FileOutputStream("aa.txt"));
        int len;
        byte[] bytes=new byte[1024*8];
        while ((len=bufferIn.read(bytes))!=-1){
            bufferOut.write(bytes,0,len);
            bufferOut.flush();
        }
        bufferIn.close();
        bufferOut.close();
    }
}

三、字符输入输出流

Reader:用于读取字符流的抽象类
Writer:写入字符流的抽象类
编码：把字符串转成字节数组，采用默认的码表进行编码，也可指定码表
解码：把字节数组转换成字符串，采用默认的码表进行解码，也可指定码表
注意：a、编解码使用码表要一致，否则会出现乱码
	 b、写入数据后必须刷新，否则数据写不过去

1、InputStreamReader（字符转换输入流）

//字节流通向字符流的桥梁，可使用指定的码表解码
InputStreamReader in=new InputStreamReader(new FileInputStream("a.txt"));//
in.read();//一次读取一个字符，读取不到返回-1
in.read(new char[1024]);//一次最多读1024个字符（一个字符数组）存进字节数组，返回值是实际读取到的字符个数
in.read(new char[1024],0,3);//将字符读入数组中的某一部分，返回值是实际读取到的字符个数

2、OutputStreamWriter(字符转换输出流)

//字符流通向字节流的桥梁，可使用指定的码表编码
OutputStreamWriter out=new OutputStreamWriter(new FileOutputStream("aa.txt",true));//加true追加
out.write('你');//一次写一个字符
out.write("你好");//一次写一个字符串
out.write("你好",0,1);//一次写一个字符串的一部分
out.write(new byte[]{'a','你','好'});//一次写一个字符数组
out.write(new byte[]{'a','你','好'},1,2);//一次写一个字符数组的一部分
out.close();//释放资源

3、FileWriter和FileReader

FileWriter和FileReader和InputStreamReader和OutputStreamWriter区别：
FileWriter和FileReader不可指定编码表编码。

4、高效字符流(缓冲区)

BufferedReader bin=new BufferedReader(new FileReader("a.txt"));
bin.readLine();//一次读一行
BufferedWriter bout=new BufferedWriter(new FileWriter("aa.txt"));
bout.newLine();//写一个换行符

5、复制文本文件

方式一：读一个字符数组，写一个字符数组

import java.io.*;

public class Demo {
    public static void main(String[] args) throws IOException {
        InputStreamReader in = new InputStreamReader(new FileInputStream("a.txt"));
        OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("aaa.doc"));
        char[] chars = new char[1000];
        int len=0;
        while ((len=in.read(chars))!=-1){
            out.write(chars,0,len);
            out.flush();
        }
        in.close();
        out.close();
    }
}

方式二：读一行写一行

import java.io.*;

public class MyTest2 {
    public static void main(String[] args) throws IOException {
        BufferedReader bin = new BufferedReader(new FileReader("MyTest1.java"));
        BufferedWriter bout = new BufferedWriter(new FileWriter("Test.java"));
        String line=null;
        char[] chars = new char[1000];//充当缓冲区
        while ((line=bin.readLine())!=null){
            bout.write(line);
            bout.newLine();//换行
            bout.flush();//必须刷新
        }
        //关闭流，释放资源
        bin.close();
        bout.close();
    }
}

6、第二种键盘录入方式

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test{
    public static void main(String[] args) throws IOException {
        //Scanner scanner = new Scanner(System.in);//第一种
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入数据");
        String s = reader.readLine();
        System.out.println(s);
    }
}

四、例题

1、将多级文件夹复制到指定目录下

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

public class CopyFolder {
    public static void main(String[] args)throws IOException {
        File sourceFile = new File("C:\\Users\\Administrator\\Desktop\\新建文件夹");
        File copyFile = new File("D:\\");
        CopyMultistageFile(sourceFile,copyFile);
    }

    private static void CopyMultistageFile(File sourceFile, File copyFile) throws IOException {
        File file = new File(copyFile, sourceFile.getName());
        if(sourceFile.isFile()){
            copyFile(sourceFile, file);
            return;
        }
        if(!file.exists()){
            file.mkdir();
        }
        File[] files = sourceFile.listFiles();
        for (File f : files) {
            if(f.isFile()){
                File file1 = new File(file, f.getName());
                copyFile(f, file1);
            }else {
                CopyMultistageFile(f,file);
            }
        }
    }

    private static void copyFile(File f, File f1) throws IOException {
        FileInputStream in = new FileInputStream(f);
        FileOutputStream out = new FileOutputStream(f1);
        int len;
        byte[] bytes=new byte[1024*1024];
        while ((len=in.read(bytes))!=-1){
            out.write(bytes,0,len);
            out.flush();
        }
        in.close();
        out.close();
    }
}

2、复制多级文件夹只保留其中的.txt文件并将其修改为.doc文件

import java.io.*;

public class CopyModify {
    public static void main(String[] args) throws IOException {
        File sourceFolder = new File("C:\\Users\\Administrator\\Desktop\\新建文件夹");
        File targetPath = new File("D:\\");
        copyModifyTheSuffixName(sourceFolder,targetPath);
    }

    private static void copyModifyTheSuffixName(File sourceFolder, File targetPath) throws IOException {
        File file = new File(targetPath, sourceFolder.getName()+"(doc)");
        if(!file.exists()){
            file.mkdir();
        }
        File[] files = sourceFolder.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                if(name.endsWith(".txt")||new File(dir,name).isDirectory()){
                    return true;
                }
                return false;
            }
        });
        for (File f : files) {
            if(f.isFile()){
                copy(f,file);
            }else {
                copyModifyTheSuffixName(f,file);
            }
        }
    }

    private static void copy(File f, File f2) throws IOException {
        FileInputStream in = new FileInputStream(f);
        File file = new File(f2, f.getName().replace(".txt", ".doc"));
        FileOutputStream out = new FileOutputStream(file);
        int len=0;
        byte[] bytes = new byte[1024 * 8];
        while ((len=in.read(bytes))!=-1){
            out.write(bytes,0,len);
            out.flush();
        }
        in.close();
        out.close();
    }
}

3、合并文件：将两首歌合并为一首

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;

public class MyDemo1 {
    public static void main(String[] args) throws IOException {
        FileInputStream in1 = new FileInputStream("许巍 - 曾经的你.mp3");
        FileInputStream in2 = new FileInputStream("许巍 - 蓝莲花.mp3");
        FileOutputStream out = new FileOutputStream("许巍大合唱.mp3");
        ArrayList<FileInputStream> list = new ArrayList<>();
        list.add(in1);
        list.add(in2);
        int len=0;
        byte[] bytes = new byte[1024 * 1024];
        for (FileInputStream in : list) {
            while ((len= in.read(bytes))!=-1){
                out.write(bytes,0,len);
                out.flush();
            }
            in.close();
        }
        out.close();
    }
}