Java——IO流（节点流或文件流）

最新推荐文章于 2024-05-25 12:01:51 发布
最新推荐文章于 2024-05-25 12:01:51 发布
阅读量283 收藏 3
点赞数 2
分类专栏： Java 文章标签： java IO流 节点流 文件流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiangqian0721/article/details/120229147
版权

IO流（节点流或文件流）

前提知识
首先我们先了解一下主要的两个流的体系，然后再去看看四大基本流的使用方法。
流的体系结构
在这里插入图片描述

InputStream & Reader

  • InputStream 和 Reader 是所有输入流的基类。
  • InputStream（典型实现：FileInputStream）
    • int read()
    • int read(byte[] b)
    • int read(byte[] b, int off, int len)
  • Reader（典型实现：FileReader）
    • int read()
    • int read(char [] c)
    • int read(char [] c, int off, int len)
  • 程序中打开的文件 IO 资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件 IO 资源。
  • FileInputStream 从文件系统中的某个文件中获得输入字节。FileInputStream 用于读取非文本数据之类的原始字节流。要读取字符流，需要使用 FileReader。

InputStream

  • int read()
    从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。
  • int read(byte[] b)
    从 此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。否则以整数形式返回实际读取的字节数。
  • int read(byte[] b, int off,int len) （不常用）
    将输入流中最多 len 个数据字节读入 byte 数组。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值 -1。
  • public void close() throws IOException
    关闭此输入流并释放与该流关联的所有系统资源。

Reader

  • int read()
    读取单个字符。作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)（2个字节的Unicode码），如果已到达流的末尾，则返回 -1。（所以我们想要读取字符，需要强转（char））。

  • int read(char[] cbuf)
    将字符读入数组。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。

  • int read(char[] cbuf,int off,int len) （不常用）
    将字符读入数组的某一部分。存到数组cbuf中，从off处开始存储，最多读len个字符。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。

  • public void close() throws IOException
    关闭此输入流并释放与该流关联的所有系统资源。
    说明：

    1. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
    2. 读入的文件一定要存在，否则就会报FileNotFoundException。

OutputStream & Writer

  • OutputStream 和 Writer 也非常相似：
    • void write(int b/int c);
    • void write(byte[] b/char[] cbuf);
    • void write(byte[] b/char[] buff, int off, int len);
    • void flush(); （处理流中有的流自动调用刷新，有的流需要手动调用）
    • void close(); 需要先刷新，再关闭此流
    • 因为字符流直接以字符作为操作单位，所以 Writer 可以用字符串来替换字符数组，即以 String 对象作为参数。
    • void write(String str);
    • void write(String str, int off, int len);
  • FileOutputStream 从文件系统中的某个文件中获得输出字节。FileOutputStream 用于写出非文本数据之类的原始字节流。要写出字符流，需要使用 FileWriter。

OutputStream

  • void write(int b)
    将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。 即写入0~255范围的。
  • void write(byte[] b)
    将 b.length 个字节从指定的 byte 数组写入此输出流。write(b) 的常规协定是：应该与调用 write(b, 0, b.length) 的效果完全相同。
  • void write(byte[] b,int off,int len)
    将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
  • public void flush()throws IOException
    刷新此输出流并强制写出所有缓冲的输出字节，调用此方法指示应将这些字节立即写入它们预期的目标。
  • public void close() throws IOException
    关闭此输出流并释放与该流关联的所有系统资源。

说明：

  • 在写入一个文件时，如果使用构造器FileOutputStream(file)，则目录下有同名文
    件将被覆盖。
  • 如果使用构造器FileOutputStream(file,true)，则目录下的同名文件不会被覆盖，在文件内容末尾追加内容。

Writer

  • void write(int c)
    写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。 即写入0 到 65535 之间的Unicode码。
  • void write(char[] cbuf)
    写入字符数组。
  • void write(char[] cbuf,int off,int len)
    写入字符数组的某一部分。从off开始，写入len个字符
  • void write(String str)
    写入字符串。
  • void write(String str,int off,int len)
    写入字符串的某一部分。
  • void flush()
    刷新该流的缓冲，则立即将它们写入预期目标。
  • public void close() throws IOException
    关闭此输出流并释放与该流关联的所有系统资源。
    说明：
    1. 输出操作，对应的File可以不存在的。并不会报异常
    • File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
    • File对应的硬盘中的文件如果存在：
      • 如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖。
      • 如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖，而是在原有文件基础上追加内容。

节点流(或文件流)

把上面的大致看懂了就好，我们接下来就要使用它们来进行节点流数据的输入和输出了。
输入(reader 字符流)：


    @Test
    public void testFileReader(){
        FileReader fr = null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("hello.txt");//相较于当前Module
            //2.提供具体的流
            fr = new FileReader(file);

            //3.数据的读入
            //read():返回读入的一个字符。如果达到文件末尾，返回-1
            //方式一：
//        int data = fr.read();
//        while(data != -1){
//            System.out.print((char)data);  //强制转型
//            data = fr.read();
//        }

            //方式二：语法上针对于方式一的修改
            int data;
            while((data = fr.read()) != -1){
                System.out.print((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭操作
//            try {
//                if(fr != null)
//                    fr.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
            //或
            if(fr != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    //对read()操作升级：使用read的重载方法
    @Test
    public void testFileReader1()  {
        FileReader fr = null;
        try {
            //1.File类的实例化
            File file = new File("hello.txt");

            //2.FileReader流的实例化
            fr = new FileReader(file);

            //3.读入的操作
            //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
            char[] cbuf = new char[5];
            int len;
            while((len = fr.read(cbuf)) != -1){
                //方式一：
                //错误的写法
//                for(int i = 0;i < cbuf.length;i++){
//                    System.out.print(cbuf[i]);
//                }
                //正确的写法
//                for(int i = 0;i < len;i++){
//                    System.out.print(cbuf[i]);
//                }
                //方式二：
                //错误的写法,对应着方式一的错误的写法
//                String str = new String(cbuf);
//                System.out.print(str);
                //正确的写法
                String str = new String(cbuf,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fr != null){
                //4.资源的关闭
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }

输出(writer 字符流)：

    @Test
    public void testFileWriter() {
        FileWriter fw = null;
        try {
            //1.提供File类的对象，指明写出到的文件
            File file = new File("hello1.txt");

            //2.提供FileWriter的对象，用于数据的写出
            fw = new FileWriter(file,false);

            //3.写出的操作
            fw.write("I have a dream!\n");
            fw.write("you need to have a dream!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流资源的关闭
            if(fw != null){

                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }

复制操作:(字符流)



    @Test
    public void testFileReaderFileWriter() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile = new File("hello.txt");     //不能使用字符流来处理图片等字节数据
            File destFile = new File("hello2.txt");

            //2.创建输入流和输出流的对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);


            //3.数据的读入和写出操作
            char[] cbuf = new char[5];
            int len;//记录每次读入到cbuf数组中的字符的个数
            while((len = fr.read(cbuf)) != -1){
                //每次写出len个字符
                fw.write(cbuf,0,len);

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            //方式一：
//            try {
//                if(fw != null)
//                    fw.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }finally{
//                try {
//                    if(fr != null)
//                        fr.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
            //方式二：
            try {
                if(fw != null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

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

        }

    }

}

字节流：



/**
 * 测试FileInputStream和FileOutputStream的使用
 *
 * 结论：
 * 1. 对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理
 * 2. 对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,...)，使用字节流处理
 */
public class FileInputOutputStreamTest {

    //使用字节流FileInputStream处理文本文件，可能出现乱码。
    @Test
    public void testFileInputStream() {
        FileInputStream fis = null;
        try {
            //1. 造文件
            File file = new File("hello.txt");

            //2.造流
            fis = new FileInputStream(file);

            //3.读数据
            byte[] buffer = new byte[5];
            int len;//记录每次读取的字节的个数
            while((len = fis.read(buffer)) != -1){

                String str = new String(buffer,0,len);
                System.out.print(str);

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis != null){
                //4.关闭资源
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }

    /*
    实现对图片的复制操作
     */
    @Test
    public void testFileInputOutputStream()  {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //
            File srcFile = new File("小狗.jpg");  //自己去找一个图片
            File destFile = new File("小狗1.jpg");

            //
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

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

        } 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();
                }

            }
        }

    }

    //指定路径下文件的复制，我们把这种复制操作写成一种方法，直接调用
    public void copyFile(String srcPath,String destPath){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            //
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);

            //
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

            //复制的过程
            byte[] buffer = new byte[1024]; //通常这个字节数组长度大小为1024
            int len;
            while((len = fis.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }

        } 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();
                }

            }
        }


    }
    
//测试此方法是否可用
    @Test
    public void testCopyFile(){

        long start = System.currentTimeMillis();

        String srcPath = "C:\\Users\\Administrator\\Desktop\\01-视频.avi";
        String destPath = "C:\\Users\\Administrator\\Desktop\\02-视频.avi";


//        String srcPath = "hello.txt";
//        String destPath = "hello3.txt";

        copyFile(srcPath,destPath);


        long end = System.currentTimeMillis();

        System.out.println("复制操作花费的时间为：" + (end - start));//618 记录一下复制这个视频的时间，下次我们用缓冲流之后，看时间的变化。

    }

}
  • 在读取文件时，必须保证该文件已存在，否则报异常。
  • 字节流操作字节，比如：.mp3，.avi，.rmvb，mp4，.jpg，.doc，.ppt
  • 字符流操作字符，只能操作普通文本文件。最常见的文本文件：.txt，.java，.c，.cpp 等语言的源代码。尤其注意.doc,excel,ppt这些不是文本文件。
真真最可爱
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
java——IO流技术.pdf
04-03
javaIO流
Java IO流 文件传输基础
09-02
主要介绍了Java IO流 文件传输基础的相关资料,非常不错，具有参考借鉴价值，需要的朋友可以参考下
java中FileOutputStream流，向文件中追加内容，而不是覆盖掉文件中原有的数据
热门推荐
到达的专栏
06-30 2万+
public FileOutputStream(String name,boolean append) throws FileNotFoundException 创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。 new 的时候加一个true参数则是追加。默认为false，则是覆盖。
java file已存在，新建流写入此文件是否会覆盖原本file信息
02-13 2414
java中建立文件输出流，当文件不存在时会新建一个文件：如果有同名文件，自动覆盖。不存在时自动建立。FileOutputStream的默认构造方法是直接覆盖掉原来的文件，而FileOutputStream(File file, boolean append) 的构造方法如果后面的append为true的时候就是追加到尾部而不是直接覆盖了。，当创建IO对象是，文件是以独占的方式打开，就好比...
Java——IO流详解
m0_61943950的博客
10-07 755
文件在程序中是以流的形式来操作的 Java 程序（内存）—— 输出流 —— > 文件（磁盘） 文件（磁盘） < —— 输入流 —— Java 程序（内存）流：数据在数据源（文件）和程序（内存）之间经历的路径输入流：数据从数据源（文件）到程序（内存）的路径输出流：数据从程序（内存）到数据源（文件）的路径
Java——IO流（超详细超全）
xiangqian0721的博客
09-18 1457
IO流（File类） 我们想要学好IO流，首先一定要明确什么是File类，不然你都没有对象去进行输入和输出。 java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关。 File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。 如果需要访问文件内容本身，则需要使用IO流。 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。 File对象可以作为参数传递给流的构造器 F
Java——IO流
MikW430922的博客
01-20 1500
Java IO流相关基础
Java——IO流（IO流原理及流的分类）
xiangqian0721的博客
09-11 250
IO流（IO流原理及流的分类） 前提知识 File类 Java IO原理 I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。 Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。 java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。 我们是需要把我们放在程序的位置上，来区分到底是输出还是输入。 流的分类 按操作数据单位不同分为：字节流(8 bit)，字
JAVA——IO流入门：节点流与字符流
Numtheun的博客
06-15 1627
JAVA——IO流入门：节点流与字符流 一，File file是文件和目录路径名的抽象表示 1.1 File的用法 用法： File file = new File("路径名"); //如 File file = new File("L:\\FileTestDemo\\AAA\\aaa.txt"); **注意：**在windows中，路径名不能使用单个的\，单个的\为转义字符，可以使用\\，//或/ 1.2 File的常用方法 boolean createNewFile() 当且仅当具有此名称的
JAVA——IO流（上）
weixin_62838185的博客
03-14 1046
IO流概述 1、IO流，什么是IO？ I : Input O : Output 通过IO可以完成硬盘文件的读和写。 画图理解： 2、IO流的分类？ 有多种分类方式： 一种方式是按照流的方向进行分类： 以内存作为参照物， 往内存中去，叫做输入(Input)。或者叫做读(Read)。 从内存中出来，叫做输出(Output)。或者叫做写(Write)。 ...
JavaIO流——文件的读取与传输
Tomas_yue的博客
12-18 3748
I/O也叫做输入/输出，在java编程语言中，I/O更被看作是一种流；JavaI/O的体系设计与Linux内核I/O有着密不可分的关系； 为了操作系统的安全考虑，Linux进程是无法直接操作I/O设备的，必须通过内核来协助完成I/O动作，而内核会为每个I/O设备维护一个缓冲区Buffer，又叫做缓冲区； 数据从I/O设备拷贝到buffer缓冲区（等待数据阶段）； 数据再从缓冲区拷贝到Linux进程（拷贝数据阶段）； 此过程可分为五种模型： **阻塞I/O模型（Blocking I/O）：**在Linux中
Java IO流原理及流的体系——节点流（文件流）
PandaMan~的博客
04-19 991
I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
Java基于IO流读取文件的方法
09-03
主要介绍了Java基于IO流读取文件的方法,涉及Java文件流操作的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
Java IO流和文件操作实现过程解析
08-25
主要介绍了Java IO流和文件操作实现过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java IO流文件的读写具体实例
09-04
主要介绍了java IO流文件的读写具体实例，有需要的朋友可以参考一下
java学习和项目总结
2301_79390585的博客
05-24 683
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
Java高级面试精粹：问题与解答集锦（一）
Layla_c的博客
05-23 1424
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
JVM学习-执行引擎
丢爸
05-21 1129
当然是否需要启动JIT编译器将字节码直接编译为对应平台的本地机器指令，则需要根据代码被调用。大部分的程序代码转换为物理机的目标代码或虚拟机能执行的指令集之前，都需要经过下图各个步骤。，将其直接编译为对应平台的本地机器指令，以此提升Java程序的执行性能。”，JIT编译器在运行时会针对那些频繁被调用的热点代码做出。Java代码编译是由Java源码编译器来完成，流程图如下。而定，关于那些需要被编译为本地代码的字节码，称为“Java字节码的执行是由JVM执行引擎来完成。
数据访问与Spring Data JPA
最新发布
无远弗届
05-25 513
假设我们要处理一个用户表（users），可以创建一个User@Entity // 标识这是一个实体类 public class User {@Id // 标识这是主键字段 @GeneratedValue(strategy = GenerationType . AUTO) // 主键生成策略 private Long id;// Getter 和 Setter ... }@Entity // 标识这是一个实体类 public class User {
java中io流读取写入文件
06-09
在Java中，可以使用IO流进行文件的读取和写入。下面是一个简单的示例： 1. 文件读取 ```java import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

真真最可爱

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值