Java IO流

Java IO流 1.File类

概念：代表物理盘符中的一个文件或者文件夹。

常见方法：

方法名	描述
createNewFile()	创建一个新文件。
mkdir()	创建一个新目录。
delete()	删除文件或空目录。
exits()	判断file对象所代表的对象是否存在。
getAbsolutePath()	获取文件的绝对路径。
getName()	取得名字。
getParent()	获取文件/目录所在的目录。
isDirectory()	是否是目录。
isFile()	是否是文件。
length()	获得文件的长度。
listFiles()	列出目录中的所有内容。

示例：

public class FileDemo {
    public static void main(String[] args) throws IOException {
	    //文件相关的操作
//        File file = new File("D:\zhangpan\IDEA\Java基础WorkSpace\Basics\src\com\lanou\Demo1.java");
//        System.out.println("文件的绝对路径:"+ file.getAbsoluteFile());
//        System.out.println("文件构造路径:"+file.getPath());
//        System.out.println("文件名称:"+file.getName());
//        System.out.println("文件的大小有多大:"+file.length()+"字节。");
        //判断文件 createNewFile()
        File file1 = new File("D:\IO\file.txt");
        //判断文件是否存在
        if (file1.exists()) {
            file1.createNewFile();//创建文件
            //file1.delete();//删除
        }
        System.out.println("是否是文件："+file1.isFile());

        System.out.println("--------------------");
        //文件夹相关的操作
        File dir = new File("D:\IO");
        System.out.println("文件夹的绝对路径:"+ dir.getAbsoluteFile());
        System.out.println("文件夹构造路径:"+dir.getPath());
        System.out.println("文件夹名称:"+dir.getName());
        System.out.println("文件夹的大小有多大:"+dir.length()+"字节。");
        if (!dir.exists()) {//如果目录不存在就创建
            //dir.mkdirs();//创建多级目录
            dir.mkdir();//创建单集目录
        }else {
//            dir.delete();
        }
        System.out.println("是否是文件："+dir.isFile());
        System.out.println("是否是目录："+dir.isDirectory());
        System.out.println("-----------------");
		//遍历文件夹
        String[] list = dir.list();
        for (String str : list) {
            System.out.println(str);
        }
        System.out.println("--------------");
        //列出目录中的所有内容
        File[] files = dir.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }
}

2.什么是IO流

当你编辑一个文本文件，忘了保存，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘中。那么数据都是在那些设备上的呢？键盘，内存，硬盘，外接设备等。

我们把这种数据传输，可以看作是一种数据的流动，按照流动的方向，以内存为基准，分为输入input和输出output，即流向内存是输入流，流出内存是输出流。

Java中I/O操作主要指使用java.io包下的内容。进行输入，输出操作。输入也叫做读取数据，输出也叫做写出数据。

3.IO分类

根据数据的流向分为输入流，输出流。

输入流：把数据从其他设备上读取到内存中的流。

**输出流：**把数据从内存中写到其他设备上的流。

根据数据的类型分为：字节流和字符流

**字节流：**以字节为单位，读写数据的流。

**字符流：**以字节为单位，读写数据的流。

	输入流	输出流
字节流	字节输入流 InputStream	字节输出流 OutputStream
字符流	字符输入流 Reader	字符输出流 Writer

4.字节流

一切皆为字节

一切文件数据（文本，图片，视频等）在存储的时候，都是以二进制数字的形式保存，都是一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什们样的流对象，底层传输的始终为二进制数据。

字节输出流

java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将制定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

public void close();	关闭此输出流并释放与此流相关联的任何系统资源
public void flush();	刷新此输出流并强制任何缓冲的输出字节被写出。
public void write(byte[] b);	将b.length字节从指定的字节数组写入此输出流
public void write(byte[] b,int off,int len);	从自定的字节数组写入len字节，从偏移量off开始输出到此输出流
public abstract void write(int b);	将指定的字节输出流

FileOutputStream类

构造方法：

public FileOutputStream(File file); 创建文件输出流以写入由指定的File对象表示的文件。

public FileOutputStream(String name)；创建文件输出流以指定的名称写入文件。

1.写出字节：write(int b)方法，每次可以写出一个字节的数据。

2.写出字节数组：write(byte[] b)，每次可以写出数组中的数据

3.写出指定长度字节数组：write(byte[] b,int off,int len)，每次写出从off索引开始，len个字节。

示例：

public class FileOutputStreamDemo {
//字节输出流的写方法
    public static void main(String[] args) {
        //1.创建字节输出流
        FileOutputStream outputStream1 = null;
        try {
//            outputStream1 = new FileOutputStream("D:\IO\FileOutPutStream.txt");//默认是覆盖原有的内容
            outputStream1 = new FileOutputStream("D:\IO\FileOutPutStream.txt",true);//在原有的内容上追加数据
            //FileOutputStream outputStream2 = new FileOutputStream(new File("D:\IO\FileOutPutStream.txt"));//不常用
            //2.写出数据，写一个字节。
            //写出数据，虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
//            outputStream1.write(97);
//            outputStream1.write(98);
//            outputStream1.write(99);
            //写一个字节数组
//            byte[] bytes = "hello,world".getBytes();
//            outputStream1.write(bytes);
            //写出一个字节数组，指定区间
            byte[] bytes = "abcdefg".getBytes();
            outputStream1.write(bytes,2,3);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //3.最后一定要关闭流。
                outputStream1.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字节输入流

java.io.InputStream抽象类是表示字节输入流的所有类的超类。可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

public void close()；关闭此输入流并释放与此流相关的任何系统资源。

public abstract int read()；从输入流读取数据的下一个字节。

public int read(byte[] b)；从输入流中读取一些字节数，并将他们存储到字节数组中。

FileInputStream类

构造方法：

FileInputStream(File file)；通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的File对象file命名。

FileInputStream(String name)；通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名 name命名。

1、读取字节：read()方法，每次可以读取一个字节的数据，提升为int类型。读取到文件末尾，返回-1。

2、使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1。

示例：

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        //1.创建输入流对象，相对路径，抛出异常
        FileInputStream inputStream = new FileInputStream("fis.txt");
        //2.读取数据
//        char c = (char) inputStream.read();
//        System.out.println("字符1："+c);
//        c = (char) inputStream.read();
//        System.out.println("字符2："+c);
//        c = (char) inputStream.read();
//        System.out.println("字符3："+c);
//        int end = (char) inputStream.read();
//        System.out.println("文件的末尾end："+end);
        //一个字节一个字节的读取。和上面一样（简化版）
//        int c;
//        while ((c = inputStream.read()) != -1) {
//            System.out.println("字符："+(char) c);
//        }
        //读取一个字节数组
        byte[] bytes = new byte[2];
        int len;//每次读取到的有效的字节个数。
        while((len = inputStream.read(bytes)) != -1){
//            System.out.println("字节串："+new String(bytes));
            System.out.println("字符串："+ new String(bytes,0,len));
        }

        //3.关闭流
        inputStream.close();
    }
}

综合案例：图片复制

//1.创建流
//1.1文件字节输入流
public class Copy {
    public static void main(String[] args) throws IOException {
        //1.创建输出流。
        FileInputStream inputStream = new FileInputStream("D:\IO\a.jpg");
        FileOutputStream outputStream = new FileOutputStream("D:\IO\A.jpg");

        //2.其实就是一边读取数据，一边写出数据
        byte[] buffer = new byte[1024];
        int len;//每次有效读取的字节个数
        while ((len=inputStream.read(buffer)) != -1) {
            outputStream.write(buffer,0,len);
        }

        //3.关闭流
        inputStream.close();
        outputStream.close();
    }
}

5.字符流 字符输入流

java.io.Reader抽象类时表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

public void close()；关闭此流并释放与此流相关联的任何系统资源。

public int read()；从输入流读取一个字符。

public int read(char[] cbuff)；从输入流读取一些字符。并将他们存储到字符数组cbuff中。

FileReader类

构造方法

FileReader(File file)：创建一个新的FileReader，给定要读取的file对象。

FileReader(String fileName)：创建一个新的FileReader,给定要读取的文件的名称。

1.读取字符：read方法，每次可以读取一个字符的数据，提升为int类型。读取到文件末尾，返回-1，循环读取。

2.使用字符数组：read(char[] cbuff)，每次读取b的长度个字符到数组中，返回读取到有效字符个数，读取到末尾时，返回-1。

示例：

public class FileReaderDemo {
    public static void main(String[] args) throws IOException {
        //1.创建一个字符输入流
        FileReader reader = new FileReader("read.txt");
        //2.读取数据
//        char c = (char)reader.read();
//        System.out.println("c:"+c);

//        int ch;
//        while((ch=reader.read()) != -1){
//            System.out.println("数据ch："+(char)ch);
//        }

        //字符数组
        char[] charbuffer = new char[2];//每次读两个
        int len;
        while((len = reader.read(charbuffer)) != -1){
            System.out.println("内容："+ new String(charbuffer,0,len));
        }

        //3.关闭资源
        reader.close();
    }
}

字符输出流

java.io.writer抽象类是表示用于写出字符流的所有类的超类，将制定的字符信息写出到目的地。它定义了字符输出流的基本共性功能方法。

​ void write(int c)；写入单个字符。

​ void write(char[] cbuf)；写入字符数组。

​ abstract void write(char[] cbuff, int off, int len)；写入字符数组的某一部分，off数组的开始索引，len写的字符个数。

​ void write(String str)；写入字符串。

​ void write(String str, int off, int len)；写入字符串的某一部分。off字符串的开始索引，len写的字符个数。

​ void flush()；刷新该流的缓冲

​ void close()；关闭此流，但要先刷新它。

FileWriter类

FileWriter(File file)：创建一个新的FileWriter，给定要读取的File对象。

FileWriter(String fileName)：创建一个新的FileWriter，给定要读取的文件的名称。

构造时使用系统默认的字符编码和默认字节缓冲区。

1.写出字符：write(int b) 方法，每次可以写出一个字符数据

2.**写出字符数组：**write(char[] cbuf) 和 write(char[] cbuf, int off, int len)，每次可以写出字符数组中的数据。用法类似于FileOutputStream。

3.**写出字符串：**write(String str) 和 write(String str, int off, int len)，每次可以写出字符串中的数据，更方便。

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流。就需要flush方法了。

示例：

public class FileWriterDemo {
    public static void main(String[] args) throws IOException {
        //1.创建一个字符输出流
        FileWriter FileWriter = new FileWriter("writer.txt");

        //2.写出数组
        //(2.1 写出一个字符)
//        FileWriter.write(97);
//        FileWriter.write(98);
//        FileWriter.write(99);
//        FileWriter.write(100);

        //(2.2 写出一个字符数组)
//        char[] c = "abcdef".toCharArray();
//        FileWriter.write(c,0,3);

        //(2.3 直接写出字符串)
//        FileWriter.write("你好吗中国人");
        FileWriter.write("你好吗中国人",0,2);

        //3.关闭资源(关闭流之后无法继续写，)
//        FileWriter.close();
        FileWriter.flush(); //刷新
        FileWriter.write("你好吗中国人",0,3);

        FileWriter.close();
    }
}

6.缓冲流 概述

缓冲流也叫高效流，是对4个基本的FileXxx流的增强，所以也是4个流，按照数据类型来分类。

​ 字节缓冲流：BufferedInputStream，BufferedOutputStream

​ **字符缓冲流：**BufferedReader，BufferedWriter

缓冲流的基本原理，在创建流对象时。会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写。减少系统IO次数，从而提升读写的效率。

字节缓冲流

构造方法：

public BufferedInputStream(InputStream in)：创建一个新的缓冲输入流。

public BufferedOutputStream(OutputStream out)：创建一个新的缓冲输出流。

示例：

//创建字节缓冲输入流
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("文件的路径以及名称"));
//创建字节缓冲输出流
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("文件的路径以及新名称"));

效率PK

基本流示例：

public class NormalDemo {
    public static void main(String[] args) throws Exception {
        //开始的毫秒数
        long startTime = System.currentTimeMillis();
        //1.创建输入输出流
        FileInputStream fileInputStream = new FileInputStream("文件的路径以及名称");
        FileOutputStream fileOutputStream = new FileOutputStream("文件的路径以及新名称");
        //2.读写数据
        int len;
        byte[] buffer = new byte[1024];
        while ((len = fileInputStream.read()) != -1) {
            //写数据
            fileOutputStream.write(buffer,0,len);
        }
        //3.关闭资源
        fileOutputStream.close();
        fileInputStream.close();
        //结束的毫秒数
        long endTime = System.currentTimeMillis();
        System.out.println("文件复制的时间为："+ (endTime-startTime)/1000);
    }
}

缓冲流示例：

public class BufferDemo {
    public static void main(String[] args) throws Exception {
        //开始的毫秒数
        long startTime = System.currentTimeMillis();
        //1.创建缓冲流的输入输出对象
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("文件的路径以及名称"));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("文件的路径以及新名称"));
        //2.读写数据
        int len;
        byte[] buff = new byte[1024];
        while ((len = bufferedInputStream.read()) != -1) {
            bufferedOutputStream.write(buff,0,len);
        }
        //3.关闭资源
        bufferedOutputStream.close();
        bufferedInputStream.close();
        //结束的毫秒数
        long endTime = System.currentTimeMillis();
        System.out.println("文件复制的时间为："+ (endTime-startTime)/1000);
    }
}

字符的缓冲流

构造方法

public BufferedReader(Reader in)：创建一个新的缓冲输入流。

public BufferedWriter(Writer out)：创建一个新的缓冲输出流。

示例：

//创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
//创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法

字符缓冲流的基本方法与普通字符流调用方式不一致。

​ BufferedReader：public String readLine()；读一行文字

​ BufferedWriter：public void newline()；写一行行分隔符，由系统属性定义符号。

示例1：

public class BufferDemo { //字节缓冲流
    public static void main(String[] args) throws Exception {
        //开始的毫秒数
        long startTime = System.currentTimeMillis();
        //1.创建缓冲流的输入输出对象
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("文件的路径以及名称"));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("文件的路径以及新名称"));
        //2.读写数据
        int len;
        byte[] buff = new byte[1024];
        while ((len = bufferedInputStream.read()) != -1) {
            bufferedOutputStream.write(buff,0,len);
        }
        //3.关闭资源
        bufferedOutputStream.close();
        bufferedInputStream.close();
        //结束的毫秒数
        long endTime = System.currentTimeMillis();
        System.out.println("文件复制的时间为："+ (endTime-startTime)/1000);
    }
}

示例2：

public class BufferDemo2 { //字符缓冲流
    public static void main(String[] args) throws Exception {
        //1.创建字符缓冲流
        BufferedReader bufferedReader = new BufferedReader(new FileReader("in.txt"));
        //2.读取数据
        //新增了一个方法
        //String line = bufferedReader.readLine();
        String line;
        while((line=bufferedReader.readLine()) != null){
            System.out.println(line);
        }
        //3.关闭资源
        bufferedReader.close();

        System.out.println("------------------------");

        //1.创建字符缓冲输出流对象
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("out.txt"));
        //2.写数据
        bufferedWriter.write("hello");
        bufferedWriter.newline();//换行
        bufferedWriter.write("china");
        //3.关闭流
        bufferedWriter.close();
    }
}

7.转换流

在IDEA中，使用FileReader读取项目中的文本文件。由于IDEA的设置，都是默认编码UTF-8编码。所以没有任何问题。但是当读取Windows系统中创建的文本文件时，由于Windows系统默认的编码是GBK时，就会出现乱码。

示例：

public class TransferDemo {
    public static void main(String[] args) throws Exception {
        //用默认的编码方式去读的
        FileReader fileReader = new FileReader("file.gbk.txt");
        char[] charArr = new char[100];
        int len;
        while ((len = fileReader.read(charArr)) != -1) {
            System.out.println(new String(charArr,0,len));
        }
        fileReader.close();
    }
}

那么如何读取GBK编码的文件呢？

InputStreamReader类

转换流java.io.InputStreamReader，时Reader的子类，是从字节流到字符流的桥梁。他读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

构造方法

​ InputStreamReader(InputStream in)：创建一个使用默认字符集的字符流。

​ InputStreamReader(InputStream in,String charseName)：创建一个指定的字符集的字符流。

示例：

public class InputStreamReaderDemo {
    public static void main(String[] args) throws Exception {
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("file.txt"),"UTF-8");
        char[] charArr = new char[100];
        int len;
        while((len = inputStreamReader.read(charArr)) != -1){
            System.out.println(new String(charArr,0,len));
        }
        inputStreamReader.close();

        System.out.println("---------------------");
        //1.创建对象
        OutputStreamWriter gbk = new OutputStreamWriter(new FileOutputStream("gbk.txt"), "GBK");
        //2.写出内容
        gbk.write("你好");
        gbk.write("转换流");
        gbk.close();
    }
}