java-IO流，文件操作

思维导图：

简述:

1.流:从一端移动到另一端，源头与目的地

2.Io流分类：

（1）流向:输入流，输出流

（2）数据:

字节流:二进制，可以一切文件，包括，纯文本，doc,音频，视频等等

字符流:文本文件，只能处理文本文件

（3）功能:

节点：包裹源头

处理：增强功能，提供性能

3.字符流与字节流及文件

（1）字节流:

输入流：->InputStream:

read(byte[] b),

read(byte[] b,int off,int len),

close();

->FileInputStream

   //文件读取
    public void readFile(String PATH) throws IOException {
        //获得当前路径下面的文件对象
        Long start=System.currentTimeMillis();
        File file=new File(PATH);
        InputStream in=null;
        try{
            //创建输入流
            in = new FileInputStream(file);
            //创建缓冲区用于存放流中的二进制内容,大小为1M
            byte [] bytes=new byte[1024*1024];
            int len=0;
            while(-1!=(len=in.read(bytes))){
                in.read(bytes);
            }
            //进行文件读取
            in.read(bytes);
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            if(in!=null){
                in.close();
            }
        }
        System.out.println("程序耗时："+(System.currentTimeMillis()-start));
    }

输出流:->OutputStream:

write(byte[] b),

write(byte[] b,int off,int len),

flush(),

close(); 

->FileOutputStream

//文件写入
    public void writeFile(String PATH) throws IOException{
        OutputStream outputStream=null;
        try{
            //创建输出流
            outputStream=new FileOutputStream(new File(PATH));
            byte bytes[]=new String("hello").getBytes("UTF-8");
            //将文件内容写入字节数组l
            outputStream.write(bytes);
            outputStream.flush();
12         }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(outputStream!=null){
                outputStream.close();
            }
        }
    }

（2）字符流:

输入流: ->Reader:

read(char[] cbuf),

read(char[] cb,int off,int len ),

close();

->FileReader

    //用于测试字符输入流，读取字符
    public void testReader() throws IOException{
        Reader reader=null;
        try {
            reader= new FileReader(new File(PATH));
            reader=new BufferedReader(new FileReader(new File(PATH)));
            char c[]=new char[5];
            int len=0;
            while(-1!=(len=reader.read())){
                reader.read(c);
            }
            System.out.println(Arrays.toString(c));
        }catch (Exception e){

        }finally{
            if(reader!=null){
                reader.close();
            }
        }
    }

输出流:->Writer:

write(char[] cbuf),

write(char[] cbuf,int off,int len),

flush(),

close();

->FileWriter

字符流:只能处理纯文本文件或者文本内容，全部为可见字符
类似输入流: Reader-> FileReader
类似输出流: Writer->FileWriter

1).纯文本读取
（1）建立联系
（2）选择流 Reader-> FileReader
（3）读取 char[] charRead=new char[1024]
（4）关闭流

2).纯文本写出
（1）建立联系
（2）选择流 Writer-> FileWriter
（3）写入 char[] charWrite=new char[1024]
（4）关闭流

4.处理流

处理流:增强功能，提供性能（在节点流之上）
1).缓冲流
（1）字节缓冲流
    BufferedInputStream

   //缓冲流
    public void testBufferedStream() throws IOException{
        Long start=System.currentTimeMillis();
        BufferedInputStream inputStream=null;
        try {
            inputStream= new BufferedInputStream(new FileInputStream(new File(PATH)));
            byte [] b=new byte[1024*1024];
            int len=0;
            while(-1!=(len=inputStream.read(b))) {
                inputStream.read(b);
            }
            System.out.println(Arrays.toString(b));
        }catch (IOException e){

        }finally {
            if(inputStream!=null){
                inputStream.close();
            }
        }
        System.out.println("程序耗时："+(System.currentTimeMillis()-start));
    }

    BufferedOutputStream

（2）字符缓冲流
    BufferedReader
    BufferedWriter

2).转换流  ->  字节流转化为字符流 处理乱码（编码集，解码集）
（1）编码与解码的概念:
         编码:  字符 ->编码字符集->二进制
         解码:  二进制->解码字符集->字符
（2）乱码:
         编码与解码的字符集不一致
         字节缺少，长度丢失
5.其他流
节点流:
1.字节数组 字节 节点流
输入流:ByteArrayInputStream
输出流:ByteArrayOutputStream

 //测试节点流
    public void testByteArrayStream() throws IOException{
        ByteArrayInputStream inputStream=null;
        byte[] bytes=null;
        try {
            bytes= new String("hello").getBytes("UTF-8");
            inputStream= new ByteArrayInputStream(bytes);
            inputStream.markSupported();
            //当前流在索引为1的位置上标记
            inputStream.mark(1);
            inputStream.read(bytes);
            //设置再次读取的内容限制在索引1位置及之前
            inputStream.reset();
        }catch (Exception e){

        }
        finally {
            if(inputStream!=null){
                inputStream.close();
            }
        }
        System.out.println(Arrays.toString(bytes));
    }

处理流:
1.基本类型String 保留数据+类型
输入流:DataInputStream   readXxx()
输出流:DataOutputStream  writeXxx();
2.引用类型(对象) 保留数据+类型
反序列化 输入流:ObjectInputStream  readObject()
序列化 输出流 :ObjectOutputStream  writeObject()

   //一般用于对象的序列化保存以及反序列化操作，被操作的对象需要实现序列化接口Serializable
    public void testObjectStream() throws IOException{
        ObjectOutputStream outputStream=null;
        try {
            //将对象的信息存储到本地文件上面
            outputStream=new ObjectOutputStream(new FileOutputStream(new File(PATH)));
            //将对象写入
            outputStream.writeObject(new User(1,"张三"));
            //创建输入流读取文件内容
            ObjectInputStream inputStream=new ObjectInputStream(new FileInputStream(new File(PATH)));
            //强制转换
            User user=(User)inputStream.readObject();
            System.out.println(user);
        }catch (Exception e){

        }
        finally {
            if(outputStream!=null) {
                //关闭流
                outputStream.close();
            }
        }
    }

//实体类实现序列化接口
class User implements Serializable {
    private int id;
    private String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "User{" +
            "id=" + id +
            ", name='" + name + '\'' +
            '}';
    }
}

注意:
先序列化后反序列化，反序列化顺序必须与序列化一致；
不是所有的对象都可以序列化:java.io.Serializable
不是所有的属性都需要序列化 :transient  ->(透明的)

6.操作：

读取文件->建立与文件的联系->选择对应流->读取/写出->定义数组大小->读取/写出->释放资源

文件->流操作代码：

/*
 * 两个常量:路径分割符，文件分割符：File.pathSeparator(),File.Separator();
 * 文件的读取,写入，创建
 * 操作目录:mkdir(),父目录必须存在，如果不存在创建失败，mkdirs(),无要求，若父目录不存在直接新建，相当于新建一条文件目录链
 * list(),返回文件名，目录名的字符串形式，需用数组进行存储。
 * listFiles();返回子文件或子目录的抽象File对象，可利用for循环获取相关信息
 */
public class FileIO {

    public static void main(String[] args) throws IOException {
        System.out.println("***文件读取***");
        readFile("test.txt");
        System.out.println("***文件目录查看***");
        showDir("F:/Test");
        System.out.println("***创建目录***");
        makeDir("F:/span");
        System.out.println("***获取文件部分信息***");
        getfileInfo("test.txt");
        System.out.println("***简单信息写入文件***");
        writeFileTest("F:/test.txt");
        System.out.println("***输入流数据写入输出流***");
        writeFileFromInputStream("F:/test.txt","E:/test.txt");
        System.out.println("***文件递归读取文件信息***");
        readFolder("F:/Test");
        copyDir("F:/测试","F:/Test1");
    }
    
    public static void readFile(String path) throws IOException {
        //相对路径，直接从当前工作目录读取路径
        File file=new File(path);
        //文件写入io流,然后写入byte数组，转String字符串输出
        InputStream fis=new BufferedInputStream(new FileInputStream(file));
        //建立缓冲区大小与文件大小一致
        byte[] b=new byte[fis.available()];
        fis.read(b);
        //关闭流
        fis.close();
        System.out.println(new String(b));
    }

    public static void showDir(String path) {
        //建立路径并将其文件引入
        File file=new File(path);
        //判断文件是否存在
        System.out.println(file.exists());
        //判断是否为目录
        System.out.println(file.isDirectory());
        //获取绝对路径
        System.out.println(file.getAbsolutePath());
        //利用String 数组存放文件名和目录名
        String[] src=file.list();
        //循环遍历
        for(String name:src) {
            System.out.println(name);
        }
        System.out.println("************************");
        //另一种形式获取
        File[] sf=file.listFiles();
        for(File name:sf) {
            System.out.println(name);
        }
    }

    //新建目录/新建目录链
    public static void makeDir(String path) {
        File file=new File(path);
        //由于span目录不存在，所以调用file.mkdir()并没有真正实现目录的创建
        boolean bo=file.mkdir();
        System.out.println(bo?"成功":"失败");
        boolean bool=file.mkdirs();
        System.out.println(bool?"成功":"失败");
    }

    //获取当前文件的具体信息
    public static void getfileInfo(String path) {
        File file=new File(path);
        //获取相对路径
        System.out.println(file.getParent());
        //获取文件袋绝对路径
        System.out.println(file.getAbsoluteFile());
        //判断是否为绝对路径
        System.out.println(file.isAbsolute());
    }

    //将信息写入文件
    public static void writeFileTest(String path) throws IOException {
        File file=new File(path);
        //定义输出流将信息存放至指定文件下
        OutputStream in=new BufferedOutputStream(new FileOutputStream(file));
        //初始化输入数据->byte的数字范围-128~127
        byte[] b=new byte[50];
        for(byte i=0;i<50;i++) {
            b[i]=i;
        }
        in.write(b);
        //关闭资源
        in.close();

    }
    //从输入流读取数据放入输出流然后写入新文件     ps:即实现了文件的拷贝 readpath读取文件路径，writepath写入文件路径
    public static void writeFileFromInputStream(String readpath,String writepath) throws IOException {
        //路径引入,文件获取
        File fileIn=new File(readpath);
        File fileOut=new File(writepath);
        copyFile(fileIn,fileOut);
    }

    //实现文件复制：根据现实情景改进方法
    public static void copyFile(File fileread,File filewrite) throws IOException {
        //文件输入流
        InputStream inStream=new BufferedInputStream(new FileInputStream(fileread));
        //定义缓冲区大小
        byte[] b=new byte[inStream.available()];
        //读入流
        inStream.read(b);
        //关闭流
        inStream.close();
        //文件输出流
        OutputStream outStream=new BufferedOutputStream(new FileOutputStream(filewrite));
        //写入流
        outStream.write(b);
        //关闭流
        outStream.close();
    }

    //利用递归读取文件，将递归读取的文件以list集合的形式返回
    public  static ArrayList<File> readFolder(String path) throws IOException{
        ArrayList<File> fileList=new ArrayList<File>();
        File file=new File(path);
        if(file.exists()) {
            //判断该文件是否为目录
            if(file.isDirectory()){
                //定义一个文件数组用于存放文件夹file下面的所有文件
                File[] files=file.listFiles();
                for(File file3: files){
                    //如果这个文件为目录
                    if(file3.isDirectory()){
                        //递归读文件夹
                        readFolder(file3.getAbsolutePath());
                    }
                    else
                        //普通文件则将其放入集合中
                        fileList.add(file3);
                    //获取文件名
                    System.out.println("文件名称:"+file3.getName());
                }
            }
        }else {
            System.out.println("不存在该路径!");
        }
        return fileList;
    }

    //拷贝文件夹真正方法实现
    public static void copyDir(String readpath,String writepath) throws IOException{
        //源目录
        File file1=new File(readpath);
        //目标目录
        File file2=new File(writepath);
        if(file1.isDirectory()) {
            file2=new File(readpath,file1.getName());
        }
        if(file2.getAbsolutePath().contains(file1.getAbsolutePath())){
            System.out.println("父目录不能拷贝在子目录中！");
            return;
        }
        copyFileDetail(file1,file2);

    }
    
    //拷贝文件方法具体细节实现
    private static void copyFileDetail(File file1, File file2) throws IOException {
        //是文件则直接复制
        if(file1.isFile()) {
            copyFile(file1,file2);
        }
        //文件夹
        else if(file1.isDirectory()) {
            //创建目录与file1目录对应
            file2.mkdirs();
            //获取下一级目录,递归
            for(File dir:file1.listFiles()) {
                copyFileDetail(dir,new File(file2,dir.getName()));
            }
        }
    }
}

效果截图:

1.控制台:

2.具体文件:

教师信息文件的读取以及写入新文件：

实例:

package com.test;

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

/**
 * 现在对基本的文件操作已经比较熟悉，所以现在利用面向对象的理念实现教师信息从文本文件中获取
 * 1.具体步骤
 * （1）读取文件信息并利用缓冲流进行性能优化
 * （2）进行编码管理，防止出现乱码，默认时编码为一致的，所以不担心乱码
 * 2.读取完数据后，新建一个文件将读取出来的数据存放过去
 * 2019年4月30日
 */
public class TeacherInfo {

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

        /*getInfo("C:/Users/Administrator/Desktop/教师信息录入.txt");*/
        writeInfo("C:/Users/Administrator/Desktop/教师信息录入.txt","C:/Users/Administrator/Desktop/test.txt");

    }

    //文件信息读取
    public static void getInfo(String path) throws IOException {
        File file=new File(path);
        //输入流初始化
        InputStream filein=new BufferedInputStream(new FileInputStream( file));    
        //建立缓冲区，存放数据
        byte[] by=new byte[filein.available()];
        //数据读入
        filein.read(by);
        //关闭流
        filein.close();
        System.out.println(new String(by));
    }
    //文件信息写入新文件,流处理，为方便还是依旧重写输入流
    public static void writeInfo(String readpath,String writepath) throws IOException{
        //文件信息引入
        File filein=new File(readpath);
        File fileout=new File(writepath);
        //流初始化
        InputStream streamIn=new BufferedInputStream(new FileInputStream(filein));
        OutputStream streamOut=new BufferedOutputStream(new FileOutputStream(fileout));
        byte[] by=new byte[streamIn.available()];
        //数据填充
        streamIn.read(by);
        streamIn.close();
        System.out.println(new String(by));
        //数据写入
        streamOut.write(by);
        streamOut.close();
    }
}

效果截图:

 

 

 

 

 

 

 

 文章若有不当之处欢迎指正，必定加以改正，虚心求学。