java-IO

IO流

分类

• 按照流的方向
  • 往内存中去，叫输入
  • 从内存出来，叫输出
• 读取数据的方式
  • 按照字节方式读取数据，一次读取一个字节->万能，什么类型的文件都可以读取，文本、图片、视频等。
  • 按照字符方式读取数据，一次读取一个字符，方便读取普通文本，这种流不能读取：图片、视频等，只能读取纯文本文件。
• 综上，流的分类->输入流、输出流、字节流、字符流
• java中的IO流都已经写好了，java是如何分别是字符或者字节的我们不用管，直接用即可。

IO流四大家族

• java.io.InputStream 字节输入流
• java.io.outputStream 字节输出就
• java.io.Reader 字符输入流
• java.io.Writer字符输出流
• 都是可关闭的，都有close()方法
• 流是内存和硬盘之间的通道，用完一定要关闭，不然会占用很多资源
• 所有的输出流都有java.io.Flushable接口，都是可刷新的，都有flush()方法。养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下，将通道/管道中剩余的未输出的数据强行输出完，注意，没有flush()可能会导致丢失数据。

java.io需要掌握的16个流

java.io.FileInputStream

• 文件字节输入流，万能的，任何类型的文件都可以采用这个流来读
• 字节的方式，完成输入的操作，（硬盘->内存）
• 读取一个字节示例：

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

public class FileInputStreamTest01 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            //创建文件字节流对象
            fis = new FileInputStream("C:/Users/Administrator/Desktop/hello.txt");
            //开始读
            int readData = fis.read();
            System.out.println(readData);
            //循环读取
			//int readData = 0;
            //while ((readData = fis.read()) != -1){
                //System.out.println(readData);
           // }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        //最终执行
        }finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

• read()一次读取一个字节，与硬盘的交互太多，效率低
• 使用read(byte[] b)方法读取多个字节

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

public class FileImputStreamtest {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("hello.txt");
            byte[] bytes = new byte[4];
            //这个方法返回的是读取的字节数量，而不是字节本身,如果数据的字节长度不是定义的字节数组bytes
            //长度的倍数，最后一组数据长度可能小于数组长度
            //例如，数据字节长度为6，那么第二次读取的数据长度为2，而bytes的内容也是错误的
            //所以应该读取多少字节，转换多少字节
            //int readCount = fis.read(bytes);
            //字节转成字符串，offset=0从0开始读，读取readCount的字节长度
            //String readData = new String(bytes, 0, readCount);
            int readCount = 0;
            while ((readCount = fis.read(bytes)) != -1){
                String readData = new String(bytes, 0, readCount);
                System.out.print(readData);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

• int available() ：返回流当中剩余的没有读到的字节数量
• 一次读取所有数据，不适合大文件读取

fis = new FileInputStream("hello.txt");
byte[] bytes = new byte[fis.available()];
int readCount = fis.read(bytes);
String readData = new String(bytes);

• long skip(long n) ：跳过几个字节不读

java.io.FileOutputStream

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileImputStreamtest {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //参数为文件路径+文件名称，如果文件不存在就新建，这种会覆盖重写源文件
            //fos = new FileOutputStream("text");
            //true表示追加写入，不会清空源文件
            fos = new FileOutputStream("text", true);
            byte[] bytes = {97,98,99,100};
            //将bytes全部输出
            fos.write(bytes);

            //写字符串
            String s = "你好，世界";
            //字符串转byte方法
            byte[] b = s.getBytes(StandardCharsets.UTF_8);
            fos.write(b);

            //必须刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null) {
                try {

                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

java.io.BufferedReader

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;

/*
BufferReader:
    带有缓冲区的字符输入流
    使用这个流的时候不需要自定义char或byte数组，自带缓冲
 */
public class BufferedReaderTest {
    public static void main(String[] args) throws Exception {
        //BufferedReader需要传入一个reader类型的参数，只能传入字符流
        //如果获取的是字节流，需要通过转换流转换成字符流
        FileReader reader = new FileReader("hello");
        //当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做，节点流
        //外部复制包装的流叫做：包装流或处理流
        //当前程序：FileReader就是节点流，BufferedReader就是包装流
        BufferedReader br = new BufferedReader(reader);
        //读取一行，但不带换行符
        String readLine = br.readLine();

        //循环读取文件,BufferedReader在读取不到文件时返回值为null
        String s = null;
        while ((s = br.readLine()) != null) {
            System.out.println(s);
        }
    }
}

java.io.BufferedWriter

java.io.File

• File类和四大家族没有关系，不能完成文件的读和写
• 文件和目录路径的抽象表示形式
• 常用方法->File f1 = new File("D:\\file")
  • f1.exists() 判断文件是否存在
  • f1.createNewFile() ：以文件形式创建
  • f1.mkdir() ：以目录形式创建
  • f1.mkdirs() ：创建多级目录
  • f1.getParent()：获取父级目录
  • f1.getAbsulutePath()：获取文件绝对路径
  • f1.getName()：获取文件名
  • f1.delete()：删除文件
  • f1.isDirectory()：判断是否是一个目录
  • f1.isFile()：判断是否是一个文件
  • f1.lastModified()：获取最后一次修改时间，返回1970到现在的毫秒数
  • f1.length()：获取文件大小
  • f1.listFile()：获取当前目录下的所有子文件，返回一个File数组