Java-IoStream详解（举例+代码）-妈妈再也不用担心我分不清流了

1，概述

Java 中的 IO 流可以分为两大类：字节流（Byte Stream）和字符流（Character Stream）。每个类别又可以进一步分为输入流（InputStream）和输出流（OutputStream），以及读取器（Reader）和写入器（Writer）。

2，字节流

2.1，字节输出流（FileOutputStream）

* 演示：字节输出流FileOutputStream
* 实现需求：写一段文字到本地文件中
*
* 实现步骤：
*        创建对象
*           细节1：参数是字符串表示的路径或者File对象都是可以的
*           细节2：如果文件不存在会创建一个新的文件，但要保证父级文件存在
*           细节3：如果文件已经存在，会清空文件
*        写出数据
*           细节1：write方法参数是整数，实际是写入的是整数在ASCII对应的字符
*        释放资源
*           每次使用完流之后都会释放资源

package IoStream.fileoutputstream;

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

public class demo1
{
    public static void main(String[] args) throws IOException
    {
        //1,创建对象-建立程序与文件的通道
        FileOutputStream fileOutputStream = new FileOutputStream("src/IoStream/a.txt");
        //2,写出数据
        fileOutputStream.write(97);
        fileOutputStream.close();
    }
}

FileOutputStream写数据的三种方式
* void write(int b)----->一次写一个字节数据
* void write(byte b)----->一 次写一个字节数组数据
* void write(byte b,int off ,int len)---->一次写一个字节数组的部分数据
*           参数1：数组
*           参数2：起始索引
*           参数3：写入个数

package IoStream.fileoutputstream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class demo2
{
    public static void main(String[] args) throws IOException
    {
        //1,创建对象
        FileOutputStream fileOutputStream = new FileOutputStream(new File(".\\src\\IoStream\\FileStream\\a.txt"));
        //2,写出数据-1
        fileOutputStream.write(97);
        fileOutputStream.write(98);
        //fileOutputStream.close();
        //2,写出数据-2
        byte[] bytes = {97,98,99,100,101,102};
        fileOutputStream.write(bytes);
        //2,写出数据-3
        fileOutputStream.write(bytes,1,2);
        fileOutputStream.close();
    }
}

    数据写出
    //1,如何换行写数据？
    //2,打开文件如何不清空原始数据？

package IoStream.fileoutputstream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class demo3
{
    //数据写出
        //1,如何换行写数据？
        //2,打开文件如何不清空原始数据？
    public static void main(String[] args) throws IOException
    {
        //创建对象
        FileOutputStream fileOutputStream = new FileOutputStream(".\\a.txt",true);//打开续写功能
        //写出数据
        String str = "horty";
        byte[] bytes = str.getBytes();
        fileOutputStream.write(bytes);

        String str1 = "\r\n";//写入换行
        byte[] bytes2 = str1.getBytes();
        fileOutputStream.write(bytes2);

        String str2 = "33114";
        byte[] bytes3 = str2.getBytes();
        fileOutputStream.write(bytes3);

        fileOutputStream.close();
    }
}

2.2，字节输入流（FileInputStream）

* 演示：字节输出流FileInputStream
 * 实现需求：读取文件中的数据
 *
 * 实现步骤：
 *        1创建对象
 *           细节1：如果文件不存在直接报错
 *
 *        2读取数据
 *           细节1：一次读取一个字节，实际是读取的是ASCII字符对应的整数
 *           细节2：读到文件末尾，read返回-1；
 *        3释放资源
 *           每次使用完流之后都会释放资源

package IoStream.fileinputstream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class demo1
{
    public static void main(String[] args) throws IOException
    {
        //1.创建对象
        FileInputStream fileInputStream = new FileInputStream(".\\a.txt");

        //2.读取数据
        int b1 = fileInputStream.read();
        System.out.println((char)b1);
        //3.循环读取
        int b;
        while ((b = fileInputStream.read()) != -1){
            System.out.print((char)b);
        }
        fileInputStream.close();

    }
}

2.3，带缓存区的字节输入输出流（BufferedStream）

package IoStream.bufferedstream;

import java.io.*;

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

        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(".\\a.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(".\\copya.txt"));

        int b;
        while ((b = bis.read()) != -1){
            bos.write((char)b);
        }
        bos.close();
        bis.close();
    }
}

package IoStream.bufferedstream;

import java.io.*;

public class BufferedStreamdemo2
{
    public static void main(String[] args) throws IOException
    {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(".\\a.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(".\\copya1.txt"));
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }
        bos.close();
        bis.close();
    }
}

3，字符流

3.1，字符输出流（FileWriter）

package IoStream.filewriter;

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

public class demo1
{
    public static void main(String[] args) throws IOException
    {
        FileWriter fileWriter = new FileWriter(".\\d.txt");

        fileWriter.write("我是horty");
        fileWriter.flush();
        fileWriter.close();
    }
}

3.1，字符输入流（FileReader）

package IoStream.FileReader;

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

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

        //创建对象关联本地文件
        FileReader fileReader = new FileReader(".\\a.txt");
        FileReader fileReader1 = new FileReader(".\\a.txt");
        //read()细节：
        //     1.read默认一个字节一个字节传输，遇到中文就读取多个字节
        //     2.读取后底层会进行解密并转成10进制
        //     3.如果是gbk编码方式，中文一次是2个字节，utf-8中文一次是3个字节
        int a;
        //空参read
        while ((a = fileReader.read()) != -1){//读取末尾返回-1
            System.out.print((char)a);
        }
        fileReader.close();

        //read(char[] cubf)方法一次读取多个字符
        char[] chars = new char[2];
        int len;
        while ((len = fileReader1.read(chars)) != -1){
            System.out.print(new String(chars,0,len));
        }
        fileReader1.close();
    }
}

3.3，带缓存区的字符输入输出流（BufferedWriter and BufferedReader）

package IoStream.bufferedreader;

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

public class BufferedWriterdemo1
{
    public static void main(String[] args) throws IOException
    {
        BufferedWriter bw = new BufferedWriter(new FileWriter(".\\bwa.txt"));
        bw.write("ddddddddddd");
        bw.newLine();//跨平台换行
        bw.write("asdafafafaadadd");
        bw.close();
    }
}

package IoStream.bufferedreader;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderdemo1
{
    public static void main(String[] args) throws IOException
    {
        BufferedReader br = new BufferedReader(new FileReader(".\\a.txt"));
        //String line = br.readLine();
        //System.out.println(line);
        String line;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        br.close();
    }
}

4 四种文件拷贝比较

4.1，一次拷贝一字节

package IoStream.systheticpractice;

import java.io.*;
import java.sql.Time;

public class filecopy1
{
    //程序运行时间：266.3321714 秒
    public static void main(String[] args) throws IOException
    {
        long startTime = System.nanoTime();
        FileInputStream fis = new FileInputStream(new File(".\\a.txt"));
        FileOutputStream fos = new FileOutputStream(new File(".\\acopy1.txt"));
        int b;
        while ((b = fis.read()) != -1){
            fos.write(b);
        }
        fos.close();
        fis.close();
        long endTime = System.nanoTime();
        double runtimeInSeconds = (endTime - startTime) / 1e9;
        System.out.println("程序运行时间：" + runtimeInSeconds + " 秒");
    }
}

4.2，一次拷贝1024

package IoStream.systheticpractice;

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

public class filecopy2
{
    //程序运行时间：0.4111141 秒
    public static void main(String[] args) throws IOException
    {
        long startTime = System.nanoTime();
        FileInputStream fis = new FileInputStream(new File(".\\a.txt"));
        FileOutputStream fos = new FileOutputStream(new File(".\\acopy2.txt"));
        byte[] bytes = new byte[1024];
        int len;
        while ((len = fis.read(bytes)) != -1){
            fos.write(bytes,0,len);
        }
        fos.close();
        fis.close();
        long endTime = System.nanoTime();
        double runtimeInSeconds = (endTime - startTime) / 1e9;
        System.out.println("程序运行时间：" + runtimeInSeconds + " 秒");
    }
}

4.3，使用带缓冲区的字节流一次一字节

package IoStream.systheticpractice;
import java.io.*;
public class filecopy3
{   //程序运行时间：0.4431468
    public static void main(String[] args) throws IOException
    {
        long startTime = System.nanoTime();
        BufferedInputStream bis = new BufferedInputStream
                (new FileInputStream(new File(".\\a.txt")));
        BufferedOutputStream bos = new BufferedOutputStream
                (new FileOutputStream(".\\acopy3.txt"));

        int b;
        while ((b = bis.read()) != -1){
            bos.write(b);
        }
        long endTime = System.nanoTime();
        System.out.println((endTime-startTime)/1e9);
    }
}

4.4，使用带缓冲区的字节流一次1024

package IoStream.systheticpractice;
import java.io.*;
public class filecopy4
{
    //程序运行时间：0.1219045
    public static void main(String[] args) throws IOException
    {
        long startTime = System.nanoTime();
        BufferedInputStream bis = new BufferedInputStream
                (new FileInputStream(new File(".\\a.txt")));
        BufferedOutputStream bos = new BufferedOutputStream
                (new FileOutputStream(".\\acopy3.txt"));

        int len;
        byte[] bytes = new byte[1024];
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }
        long endTime = System.nanoTime();
        System.out.println((endTime-startTime)/1e9);
    }
}