Java学习（15）—— I/O流（1）

最新推荐文章于 2023-06-23 21:25:42 发布
最新推荐文章于 2023-06-23 21:25:42 发布
阅读量143 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Archer__13/article/details/121276067
版权

目录

一. 文件流（节点流）

     1.字符流

       （1）输入流

       （2）输出流

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

     2.字节流

         （1）对图片进行复制

二. 缓冲流

     1.字符流

     2.字节流

三. 转换流

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

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

字节流 (8 bit)字符流 (16 bit)
输入流InputStreamReader
输出流OutputStreamWriter

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

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

字节输入流字节输出流字符输入流字符输出流
基类InputStreamOutputStreamReaderWriter
访问文件FileInputStreamFileOutputStreamFileReaderFileWriter
访问数组ByteArrayInputStreamByteArrayOutputStreamCharArrayReaderCharArrayWriter
访问管道PipedInputStreamPipedOutputStreamPipedReaderPipedWriter
访问字符串StringReaderStringWriter
缓冲流BufferedInputStreamBufferedOutputStreamBufferedReaderBufferedWriter
转换流InputStreamReaderOutputStreamWriter
对象流ObjectInputStreamObjectOutputStream
打印流PrintStreamPrintWriter
数据流DataInputStreamDataOutputStream
FilterInputStreamFilterOutputStreamFilterReaderFilterWriter

一. 文件流（节点流）

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

     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();
                }
            }
        }
    }
}
Yacht13
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java IO详解（五)------包装流
06-19 291
File 类的介绍：http://www.cnblogs.com/ysocean/p/6851878.html Java IO 流的分类介绍：http://www.cnblogs.com/ysocean/p/6854098.html Java IO 字节输入输出流：http://www.cnblogs.com/ysocean/p/6854541.html Java IO 字符输入输出流：https://i.cnblogs.com/EditPosts.aspx?postid=6859242 　　.
Reader（Java）
写写代码
12-21 822
Reader类讲解FileReader类、BufferedReader类、InputStreamReader类 Reader类 之 FileReader类：文件字符输入流 try { Reader fr = new FileReader("F:\\Reader.txt"); char[] cbuf = new char[10]; // 可存储10个字符的数组 i...
JavaSE基础笔记——IO流2：缓冲流；转换流；序列化与反序列化对象；打印流；补充知识：Properties、IO框架
weixin_62993347的博客
08-21 750
缓冲流：概述、字节缓冲流作用、性能分析、字符缓冲流；转换流：字符输入转换流、字符输出转换流；序列化与反序列化对象；打印流：printStream、PrintWriter、输出语句的重定向；补充知识：Properties、IO框架
java利用缓冲区及流式对大文件进行高效读写
最新发布
book_dw5189的博客
06-23 7262
java利用缓冲区及流式对大文件进行高效读写
Java进阶（三十八）IO流6：缓冲流
qq_33491651的博客
03-02 204
一、概述 1.1缓冲流 缓冲流为处理流的一种，分别对4个节点流进行了包装处理。 节点流 缓冲流 FileInputStream BufferedInputStream FileOutputStream BufferedOutputStream FileReader BufferedReader FileWriter BufferedWriter 1.2作用 提高流的读取、写入的速度。 原因：内部提供了一个缓冲区 byte buf[8192]。 二、B
java I/O
02-16
Java I/O 是Java编程语言中一个至关重要的领域，它涵盖了数据的输入与输出操作，包括文件操作、流处理、字符编码、网络通信等。在Java I/O系统中，各种类和接口构成了一个庞大的框架，使得开发者能够高效地处理数据...
JAVA学习笔记2020/4/27——Stream流、方法引用
01-20
说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 1.1 引言 传统集合的...
Java I/O 操作及优化建议
12-22
　Java内存模型——或者更确切的说垃圾回收器——已经解决了许多内存问题。然而同时，也带来了新的问题。特别是在有着大量并行用户的J2EE运行环境下，内存越来越成为一种至关重要的资源。乍看之下，这似乎有些奇怪...
Java I/O总结
08-27
Java I/O总结  从new BufferedReader(new InputStreamReader... Java I/O总结——InputStream  Java I/O总结——OutputStream  Java I/O总结——Reader  Java I/O总结——Writer  Java I/O总结——补充说明
java——IO流技术.pdf
04-03
javaIO流
Android应用处理数据的方法
GUYIIT的博客
09-27 637
Android应用处理数据的方法 几种数据存储方式 a. SQLiteDB 在Android中我们使用SQLiteDB作为数据库，它具有以下特点： Light : 轻量级 Standard : 标准化 Open-Src : 开源 No Server : 没有服务器 Single-tier : 单层的 Loose-type : 宽松类型 App-process : 在应...
bufferreader与bufferwrite以及用法与readline()方法原理自述总结
hhhhhhhhuang的博客
06-22 4355
bufferreader： bufferwrite： 用法：
3、字符流
weixin_53330986的博客
10-21 135
3、字符流 Writer 写入字符流的抽象类。子类必须实现的方法仅有write（char[] ,int,int）、flush()和close()。但是，多数子类将重写此处的定义的一些方法，以提供更高的效率或其他功能。 与OutputStream一样，对文件的操作使用，FileWrite类实现 Reader 用于读取字符流的抽象类。子类必须实现的方法仅有write（char[] ,int,int）、flush()和close()。但是，多数子类将重写此处的定义的一些方法，以提供更高的效率或其他功能。 使用Fi
【Java、File 文件相关操作】
piano_diano的博客
11-23 147
平常写java时，经常会遇到文件相关的操作。文件读写，基本可以概括为从具体文件（File），到流（Stream），最后到字节（byte[ ]），或者反过来。 也就是说文件操作一切都归结为操作字节： 读 = 将文件通过流读出字节 写 = 将字节通过流写入到文件中 File相关概念 文件流相关概念 File 与 byte[ ] 的转换 1、把 File 转换为 byte[ ] /** * * @param file 目标文件 * @retu...
浅析文本文件的基本操作
XGP专栏
11-13 1272
                           浅析文本文件的基本操作                     作者：  XGP    .Net对文件的操作是以I/O流的方式进行的，因此在介绍.NET的文件操作之前，我们先来简单地了解一下流的概念。    流(stream)是一个字节序列。一个流代表着输入或者输出到一个数据源的数据流动，对于流的操作是按照流中字节流动的先后顺序进行的。按照数据
(len = is.read(buffer)) != -1.md
奋斗的IT小民工的博客
09-29 1万+
(len = is.read(buffer)) != -1的原理详解 InputStream.read(buffer) 方法 在java中api文档有read()这几种方法 方法摘要 方法 作用 abstract int read() 从输入流中读取数据的下一个字节 int read(byte[]&amp;nbsp;b) 将输入流中读取一定数量 并将其存储在缓冲区数组 b 中。 ...
Java中BufferedInputStream和BufferedOutputStream基本使用详解
热门推荐
刘先森
10-03 5万+
BufferedInputStream的使用 BufferedInputStream:缓冲字节输入流，是一个高级流(处理流)，与其他低级流配合使用。 构造方法//创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。创建一个内部缓冲区数组并将其存储在 buf 中,该buf的大小默认为8192。 public BufferedInputStream(Inpu
javaIO与文件(ppt文档).ppt
11-17
1. **字节流**: 字节流是Java I/O的基础，它处理的是8位的字节序列。Java中提供了两个主要的抽象基类——`InputStream`和`OutputStream`，分别用于处理输入和输出。`InputStream`不能直接创建对象，但`System.in`是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值