java文件流式导出 java文件转流

转载

jiecho 2024-04-17 02:47:08

文章标签 java文件流式导出 java Test 字符流 文章分类 Java 后端开发

一. 文件流（节点流）

1.字符流

（1）输入流

（2）输出流

（3）同时使用输入流和输出流对文本文件进行复制

2.字节流

（1）对图片进行复制

二. 缓冲流

1.字符流

2.字节流

三. 转换流

1.字节流 ---> 字符流

2.字符流 ---> 字节流

	字节流 (8 bit)	字符流 (16 bit)
输入流	InputStream	Reader
输出流	OutputStream	Writer

字符流不能用来处理如图片、视频等二进制数据；字节流不能用来处理字符，可能会引起乱码。

对于文本文件通常使用字符流处理，对于图片、视频、音频等非文本文件使用字节流处理。

	字节输入流	字节输出流	字符输入流	字符输出流
基类	InputStream	OutputStream	Reader	Writer
访问文件	FileInputStream	FileOutputStream	FileReader	FileWriter
访问数组	ByteArrayInputStream	ByteArrayOutputStream	CharArrayReader	CharArrayWriter
访问管道	PipedInputStream	PipedOutputStream	PipedReader	PipedWriter
访问字符串			StringReader	StringWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流			InputStreamReader	OutputStreamWriter
对象流	ObjectInputStream	ObjectOutputStream
打印流		PrintStream		PrintWriter
数据流	DataInputStream	DataOutputStream
	FilterInputStream	FilterOutputStream	FilterReader	FilterWriter

一. 文件流（节点流）

除了节点流，其他流都是用来处理节点流的处理流。

1.字符流

（1）输入流

①读入的文件一定要存在，否则会报FileNotFound；

②需要进行异常处理，使用try-catch-finally（IDEA中异常处理的快捷键CTRL+ALT+T和ALT+ENTER）；

read()：一次读一个字符，返回读入的一个字符，如果达到文件末尾，则返回-1

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Test{
    public static void main(String[] args){
        File file = new File("test.txt");        //1.指明要操作的文件

        FileReader fileReader = new FileReader(file);     //2.提供具体的输入流

        int data = fileReader.read();         //3.读入数据。read()方法返回读入的一个字符，如果达到文件末尾，则返回-1
        while(data != -1){
            System.out.print((char)data);
            data = fileReader.read();
        }

        fileReader.close();         //4.关闭
    }
}

以上代码会报错，需要对上面的代码进行异常处理，如下所示：

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Test{
    public static void main(String[] args){
        FileReader fileReader = null;     //2.提供具体的输入流
        try {
            File file = new File("test.txt");        //1.指明要操作的文件

            fileReader = new FileReader(file);

            int data = fileReader.read();         //3.读入数据。read()方法返回读入的一个字符，如果达到文件末尾，则返回-1
            while(data != -1){
                System.out.print((char)data);
                data = fileReader.read();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileReader != null){
                try {
                    fileReader.close();         //4.关闭
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

read(char[])：返回一次读取到数组中字符的个数，在数组中定义一次最多可以读取的数量，最后如果达到文件末尾，则返回-1；

例如：如果定义一次最多可以读取5个字符，则每次读取5个字符，如果最后只剩下了3个字符，则返回3个字符。

import java.io.File;
import java.io.FileReader;


public class Test{
    public static void main(String[] args){
        File file = new File("test.txt");

        FileReader fileReader = new FileReader(file);

        char[] cbuf = new char[5];
        int len = fileReader.read(cbuf);      //记录每次读入到cbuf数组中的字符的个数
        while(len != -1){
            for(int i = 0; i < len; i++){
                System.out.print(cbuf[i]);
            }
            len = fileReader.read(cbuf);
        }

        fileReader.close();
    }
}

import java.io.File;
import java.io.FileReader;
import java.io.IOException;


public class Test{
    public static void main(String[] args){
        FileReader fileReader = null;
        try {
            File file = new File("test.txt");

            fileReader = new FileReader(file);

            char[] cbuf = new char[5];
            int len = fileReader.read(cbuf);      //记录每次读入到cbuf数组中的字符的个数
            while(len != -1){
                for(int i = 0; i < len; i++){
                    System.out.print(cbuf[i]);
                }
                len = fileReader.read(cbuf);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

（2）输出流

输出操作对应的文件可以不存在：①如果不存在，会自动创建该文件；②如果存在，调用的构造器是FileWriter(file)或FileWriter(file,flase)，则会对原有文件进行覆盖；调用的是FileWriter(file,true)，则不会对原文件进行覆盖，而是在原有文件的内容后面追加新输出的数据

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

public class Test{
    public static void main(String[] args){
        File file = new File("test.txt");        //1.指明写出到的文件名

        FileWriter fileWriter = new FileWriter(file);     //2.提供具体的输出流

        fileWriter.write("Hello");             //3.写出数据
        fileWriter.write("World"); 

        fileWriter.close();             //4.关闭
    }
}

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

public class Test{
    public static void main(String[] args){
        FileWriter fileWriter = null;     //2.提供具体的输出流
        try {
            File file = new File("test.txt");        //1.指明写出到的文件名

            fileWriter = new FileWriter(file);

            fileWriter.write("Hello");             //3.写出数据
            fileWriter.write("World");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileWriter != null){
                try {
                    fileWriter.close();             //4.关闭
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

（3）同时使用输入流和输出流对文本文件进行复制

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;

public class Test{
    public static void main(String[] args){
        File fr = new File("test.txt");
        File fw = new File("test1.txt");

        FileReader fileReader = new FileReader(fr);
        FileWriter fileWriter = new FileWriter(fw);

        char[] cbuf = new char[5];
        int len = fileReader.read(cbuf);      //记录每次读入到cbuf数组中的字符的个数
        while(len != -1){
            fileWriter.write(cbuf,0,len);  //每次写入len个字符
            len = fileReader.read(cbuf);
        }

        fileWriter.close();
        fileReader.close();
    }
}

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Test{
    public static void main(String[] args){
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        try {
            File fr = new File("test.txt");
            File fw = new File("test1.txt");

            fileReader = new FileReader(fr);
            fileWriter = new FileWriter(fw);

            char[] cbuf = new char[5];
            int len = fileReader.read(cbuf);      //记录每次读入到cbuf数组中的字符的个数
            while(len != -1){
                fileWriter.write(cbuf,0,len);  //每次写入len个字符
                len = fileReader.read(cbuf);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fileReader != null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.字节流

（1）对图片进行复制

使用read(byte[])

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

public class Test{
    public static void main(String[] args){
        File file1 = new File("test1.jpg");
        File file2 = new File("test2.jpg");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        byte[] buffer = new byte[5];
        int len = fis.read(buffer);
        while(len != -1){
            fos.write(buffer,0,len);
            len = fis.read(buffer);
        }

        fos.close();
        fis.close();
    }
}

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

public class Test{
    public static void main(String[] args){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            File file1 = new File("test1.jpg");
            File file2 = new File("test2.jpg");

            fis = new FileInputStream(file1);
            fos = new FileOutputStream(file2);

            byte[] buffer = new byte[5];
            int len = fis.read(buffer);
            while(len != -1){
                fos.write(buffer,0,len);
                len = fis.read(buffer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

二. 缓冲流

加入缓冲流的作用：提高流的读取和写入的速度

1.字符流

使用read(char[])

import java.io.*;

public class Test{
    public static void main(String[] args){
        //1.文件
        File file1 = new File("test1.txt");
        File file2 = new File("test2.txt");

        //2.节点流
        FileReader fr = new FileReader(file1);
        FileWriter fw = new FileWriter(file2);

        //3.缓冲流
        BufferedReader br = new BufferedReader(fr);
        BufferedWriter bw = new BufferedWriter(fw);

        //4.读取和写入
        char[] buffer = new char[5];
        int len = br.read(buffer);
        while(len != -1){
            bw.write(buffer,0,len);
            len = br.read(buffer);
        }

        //5.关闭：关外层流（缓冲流）时会自动关闭内层的流（节点流），因此可以只关缓冲流，关闭节点流的操作可以省去
        bw.close();
        br.close();
    }
}

import java.io.*;

public class Test{
    public static void main(String[] args){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //1.文件
            File file1 = new File("test1.txt");
            File file2 = new File("test2.txt");

            //2.节点流
            FileReader fr = new FileReader(file1);
            FileWriter fw = new FileWriter(file2);

            //3.缓冲流
            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);

            //4.读取和写入
            char[] buffer = new char[5];
            int len = br.read(buffer);
            while(len != -1){
                bw.write(buffer,0,len);
                len = br.read(buffer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bw != null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

使用readLine()：一次读取一行

import java.io.*;

public class Test{
    public static void main(String[] args){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            //1.文件
            File file1 = new File("test1.txt");
            File file2 = new File("test2.txt");

            //2.节点流
            FileReader fr = new FileReader(file1);
            FileWriter fw = new FileWriter(file2);

            //3.缓冲流
            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);

            //4.读取和写入
            String data = br.readLine();
            while(data != null){
                bw.write(data);
                data = br.readLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bw != null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.字节流

import java.io.*;

public class Test{
    public static void main(String[] args){
        //1.文件
        File file1 = new File("test1.jpg");
        File file2 = new File("test2.jpg");

        //2.节点流
        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        //3.缓冲流
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //4.读取和写入
        byte[] buffer = new byte[5];
        int len = bis.read(buffer);
        while(len != -1){
            bos.write(buffer,0,len);
            len = bis.read(buffer);
        }

        //5.关闭：关外层流（缓冲流）时会自动关闭内层的流（节点流），因此可以只关缓冲流，关闭节点流的操作可以省去
        bos.close();
        bis.close();
    }
}

import java.io.*;

public class Test{
    public static void main(String[] args){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.文件
            File file1 = new File("test1.jpg");
            File file2 = new File("test2.jpg");

            //2.节点流
            FileInputStream fis = new FileInputStream(file1);
            FileOutputStream fos = new FileOutputStream(file2);

            //3.缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //4.读取和写入
            byte[] buffer = new byte[5];
            int len = bis.read(buffer);
            while(len != -1){
                bos.write(buffer,0,len);
                len = bis.read(buffer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

三. 转换流

提供字符流与字节流之间的转换；转换流属于字符流

1.字节流 ---> 字符流

InputStreamReader：将一个字节的输入流转换为字符的输入流，相当于将字节解码为字符

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class Test{
    public static void main(String[] args){
        File file = new File("test.txt");

        FileInputStream fis = new FileInputStream(file);

        InputStreamReader isr = new InputStreamReader(fis);   //将字节流按照默认的字符集转换为字符流
        //InputStreamReader isr = new InputStreamReader(fis,"UTF-8");    


        char[] buffer = new char[20];
        int len = isr.read(buffer);
        while(len != - 1){
            String str = new String(buffer,0,len);
            System.out.print(str);
            len = isr.read(buffer);
        }

        isr.close();
    }
}

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

public class Test{
    public static void main(String[] args){
        InputStreamReader isr = null;   //将字节流按照默认的字符集转换为字符流
        try {
            File file = new File("test.txt");

            FileInputStream fis = new FileInputStream(file);

            isr = new InputStreamReader(fis);

            char[] buffer = new char[20];
            int len = isr.read(buffer);
            while(len != - 1){
                String str = new String(buffer,0,len);
                System.out.print(str);
                len = isr.read(buffer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(isr != null){
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.字符流 ---> 字节流

OutputStreamWriter：将一个字符的输出流转换为字节的输出流

import java.io.*;

public class Test{
    public static void main(String[] args){
        File file1 = new File("test1.txt");
        File file2 = new File("test2.txt");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        InputStreamReader isr = new InputStreamReader(fis);
        OutputStreamWriter osw = new OutputStreamWriter(fos);

        char[] buffer = new char[20];
        int len = isr.read(buffer);
        while(len != -1){
            osw.write(buffer,0,len);
            len = isr.read(buffer);
        }
        
        osw.close();
        isr.close();
    }
}

import java.io.*;

public class Test{
    public static void main(String[] args){
        InputStreamReader isr = null;
        OutputStreamWriter osw = null;
        try {
            File file1 = new File("test1.txt");
            File file2 = new File("test2.txt");

            FileInputStream fis = new FileInputStream(file1);
            FileOutputStream fos = new FileOutputStream(file2);

            isr = new InputStreamReader(fis);
            osw = new OutputStreamWriter(fos);

            char[] buffer = new char[20];
            int len = isr.read(buffer);
            while(len != -1){
                osw.write(buffer,0,len);
                len = isr.read(buffer);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(osw != null){
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(isr != null){
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：ant design vue 菜单过多美化滚动条 ant design pro vue 动态菜单

下一篇：系统镜像预装服务定制系统镜像包含驱动吗

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯