Java文件与IO流

首先我们要清楚什么是流，正如其名，很形象，流就是像水一样的东西，具有方向性，在java中

，流大概就是类

接下来，我们要对输入输出流有一个基本认识，什么是输入输出流呢？

输入输出明显需要一个参照，而这个参照就是主存。

清楚了上面的概念，我们接着看下去吧。

文件

文件的创建

文件创建共有三种方式

1、

File file = new File(文件的路径);

file.createNewFile();

2、

File file = new File(文件的父目录, 文件名);

3、

File file = new File(文件的父目录, 文件的子目录);

package file;

import org.junit.jupiter.api.Test;
import java.awt.*;
import java.io.File;
import java.io.IOException;

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

    }
    //@Test
    public void create01() throws IOException {
        String filePath = "E:\\new1.txt";
        File file = new File(filePath);
        file.createNewFile();
        System.out.println("文件创建成功");
    }
    //@Test
    public void create02() throws IOException {
        File file1 = new File("E:\\");
        String fileName = "new2.txt";
        File file = new File(file1, fileName);
        file.createNewFile();
        System.out.println("文件创建成功2");
    }
    @Test
    public void create03()
    {
        String FilePath = "E:\\";
        String FileName = "new3.txt";
        File file = new File(FilePath, FileName);
        try {
            file.createNewFile();
            System.out.println("文件创建成功3");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

文件信息的获取

package file;

import java.io.File;

public class FileInformation {
    public static void main(String[] args) {
        FileInformation fileInformation = new FileInformation();
        fileInformation.info();
    }
    public void info()
    {
        File file = new File("E:\\new1.txt");
        System.out.println("文件名=" + file.getName());
        System.out.println("文件的句=绝对路径" + file.getAbsoluteFile());
        System.out.println("文件的父目录" + file.getParentFile());
        System.out.println("文件的大小" + file.length());
        System.out.println("文件是否存在" + file.exists());
        System.out.println("是否是一个文件" + file.isFile());
        System.out.println("是否是一个目录" + file.isDirectory());
    }
}

目录文件的创建和删除

删除

package file;

import com.sun.javafx.image.BytePixelSetter;
import org.junit.jupiter.api.Test;

import java.io.File;

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

    }
    @Test
    public void f1()
    {
        String filePath = "E:\\new1.txt";
        File file = new File(filePath);
        if(file.exists())
        {
            if(file.delete()) System.out.println("删除成功");
            else System.out.println("删除成功");
        }else{
            System.out.println("该文件不存在");
        }
    }
}

目录创建

mkdir创建一级目录、mkdirs创建多级目录

@Test
    public void f3()
    {
        String filePath = "D:\\demo\\a\\b\\c";
        File file = new File(filePath);
        if(file.exists())
        {
            System.out.println("目录存在");
        }else {
            if(file.mkdirs()) System.out.println("该目录创建成功");
            else System.out.println("该目录创建失败");
        }
    }

IO流

流的分类

1、按照数据单位不同分为字节流（操作二进制的文件）和字符流（一个字符占多少个字节是不确定的这和编码有点关系，操作文本文件）

2、按流向单位不同分为输入流和输出流。

3、按流的角色分：节点流和处理流（这里角色改没有引入下面会介绍）

InputStream和OutStream、Reader、Writer是四个个抽象类，其他类均是实现的这四个Abstract类，均以他们作为后缀名

输入流

字节输入流

package inputstream;

import org.junit.jupiter.api.Test;

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

public class FileInputStream_ {
    public static void main(String[] args) {
    }
    //@Test
    public void readFile01() throws IOException {
        String filePath = "D:\\hello.txt";
        FileInputStream fileInputStream = null;
        int readdata = 0;
        try {
            fileInputStream = new FileInputStream(filePath);
           //返回-1表示文件读完了
            while((readdata = fileInputStream.read()) != -1){
                System.out.print((char) readdata);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //关闭文件流
            fileInputStream.close();
        }
    }
    @Test
    public void readFile02() throws IOException {
        String filePath = "D:\\hello.txt";
        byte[] buf = new byte[8];
        FileInputStream fileInputStream = null;
        int readlen = 0;
        try {
            fileInputStream = new FileInputStream(filePath);
            //返回-1表示文件读完了
            while((readlen = fileInputStream.read(buf)) != -1){
                System.out.print(new String(buf, 0, readlen));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //关闭文件流
            fileInputStream.close();
        }
    }
}

字节输出流

package outputstream_;

import org.junit.jupiter.api.Test;

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

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

    }
    @Test
    public void writeFile() throws IOException {
        String filePath = "D:\\a.txt";
        FileOutputStream fileOutputStream = null;
        try {
            String str = "Hello World";
            fileOutputStream = new FileOutputStream(filePath);
           //写一个字符
            // fileOutputStream.write('C');
            //写一个字符串
             fileOutputStream.write(str.getBytes());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            fileOutputStream.close();
        }
    }
}

        fileOutputStream = new FileOutputStream(filePath);是覆盖

        fileOutputStream = new FileOutputStream(filePath, true);是追加到源文件后

应用

package outputstream_;

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) throws IOException {
        //文件拷贝，将D:\\1.png拷贝到C:\\
        //1、创建文件的输入流，将文件读入程序
        //2、创建文件的输出流，将程序中的内容写入文件
        String filePath = "D:\\1.jpg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        byte[] buf = new byte[1024];
        int readlen = 0;
        fileInputStream = new FileInputStream(filePath);
        fileOutputStream = new FileOutputStream("E:\\1.jpg");
        while((readlen = fileInputStream.read()) != -1)
        {
            //读取后写入文件，边读边写
            fileOutputStream.write(buf, 0, readlen);
        }
        fileOutputStream.close();
        fileInputStream.close();
    }
}

FileReader

package filereader;

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

public class FileReader_ {
    public static void main(String[] args) throws IOException {
        String filePath = "D:\\a.txt";
        FileReader fileReader = null;
        int data = 0;
        try {
            fileReader = new FileReader(filePath);
            while((data = fileReader.read()) != -1)
            {
                System.out.print((char) data);
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            fileReader.close();
        }
    }
}

用字符数组来读

package filereader;

import org.junit.jupiter.api.Test;

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

public class FileReader_ {
    public static void main(String[] args){
    }
    @Test
    public void readFile01() throws IOException {
        String filePath = "D:\\a.txt";
        int readlen = 0;
        FileReader fileReader = null;
        char [] buf = new char[8];
        try {
            fileReader = new FileReader(filePath);
            while((readlen = fileReader.read(buf)) != -1)
            {
                System.out.print(new String(buf, 0, readlen));
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            fileReader.close();
        }
    }

}

FileWriter

写入数据之后一定要关流或者刷新数据才能被写入

package filewrite;

import java.io.FileWriter;
import java.io.IOException;

public class FileWriter_ {
    public static void main(String[] args) {
        String path = "D:\\a.txt";
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter(path, true);
            fileWriter.write("aaaa");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                fileWriter.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

节点流和处理流

处理流是连接在已存在的流之上为程序提供更强大的读写功能，包装流更加形象

BufferedReader & BufferedWriter

package BufferedReader_;

import javax.swing.text.Style;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReader_ {
    public static void main(String[] args) throws IOException {
        String path = "D:\\a.txt";
        BufferedReader bufferedReader = new BufferedReader(new FileReader(path));
        String line;
        try {
            //bufferedReader.readLine();按行读取，当读取到空时，表示读取结束
            while((line = bufferedReader.readLine()) != null) System.out.println(line);;
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            bufferedReader.close();
        }
    }
}

package bufferedreader;

import java.io.*;

public class BufferedReader_ {
    public static void main(String[] args) throws IOException {
        String path = "D:\\a.txt";
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(path, true));

        try {
            bufferedWriter.write("阿杜吃饱饱");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            bufferedWriter.flush();
        }

    }
}

视频、图片等是二进制文件用字节流更方便

对象流

使用细节

1、读写顺序要一致

2、要求实现序列化或反序列化对象，需要实现Serializable

3、序列化默认是将所有属性都序列化，但是static和transient不序列化

4、序列化里面的属性也要是现实Serializable接口

标准输入输出流

转换流

转换流应用的情况：

因为字符流不能指定编码格式，而字节流可以指定编码格式，可以先按字节流读入，再用转换流转化，这样就不会乱码了