JAVA_IO流四大家族(1)

最新推荐文章于 2022-09-25 15:08:53 发布
最新推荐文章于 2022-09-25 15:08:53 发布
阅读量3.4k 收藏 3
点赞数 6
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSNN2019/article/details/114344174
版权

JAVA_IO四大家族体系：

JAVA_IO流四大家族(1)

JAVA_IO流四大家族（2）

文章目录

常识介绍

IO流，什么是IO?

I：Input
O：Output
通过IO可以完成硬盘文件的读写

IO流的分类：

一种方式是按照流的方向进行分类：
以内存为参照物，
往内存中去，叫做输入，或者叫做读，
从内存中出来，叫做输出，或者叫做写

另一种方式是按照读写数据方式不同进行分类：
有的流是按照字节的方式读取数据，一次读取一个字节byte，等同于一次读取8个二进制位，这种流是万能的，什么类型的文件都能读取。包括：文本文件，图片，声音文件，视频

假设文件file.txt，采用字节流是这样读的：
a中国bc张三fe

第一次读：一个字节，正好读到’a‘，
第二次读：一个字节，正好读完‘中’字符的一半
第三次读：一个字节，正好读到‘中’字符的另外一半

有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取：图片，声音，视频等文件，只能读取纯文本文件，连word文件都没法读取。
假设文件file.txt，采用字符流是这样读的：
a中国bc张三fe
第一次读：'a’字符（'a’字符在windows系统中占有一个字节）
第二次读：'中’字符（'a’字符在windows系统中占有两个字节）

综上所述：流的分类
输入流，输出流
字节流，字符流

JAVA中主要研究：

怎么new流对象
调用流对象的哪个方法读，哪个方法写

四个家族首领

java.io.InputStream 字节输入流
java.io.OutputStream 字节输出流

java.io.Reader 字符输入流
java.io.Writer 字符输出流

四大家族首领都是抽象类（abstract class）

所有的流都实现了：java.io.Closeable接口，都是可关闭的，都有close（）方法。
流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费很多资源。养成好习惯，用完流一定要关闭

所有的输出流都实现了：
java.io.Flushable接口，都是可刷新的，都有flush（）方法；养成好习惯，输出流在最终输出之后，一定要记得flush（）刷新一下，这个刷新表示将通道/管道当中剩余未输出的数据强行输出完（清空管道）刷新的作用就是清空管道
注意：如果没有flush（）可能会导致丢失数据；还有只有输出流有flush（），输入流并没有

在这里插入图片描述

注意：在java中只要“类名”以Stream结尾的都是字节流，以“Reader/Writer”结尾的都是字符流

java.io包下需要掌握的流有16个：

文件专属：
java.io.FileInputStream
java.io.FileOutputStream
java.io.FileReader
java.io.FileWriter

转换流：（将字节流转换为字符流）
java.io.InputStreamReader
java.io.OutputStreamWriter

缓冲流专属：
java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferedInputStream
java.io.BufferedOutputStream

数据流专属：
java.io.DataInputStream
java.io.DataOutputSteam

标准输出流：
java.io.PrintWriter
java.io.PrintStream

对象专属流：
java.io.ObjectInputStream
java.io.ObjectOutputStream

FileInputStream

read方法

调用一次read方法，文件指针会往后移动一位，即如下图
在这里插入图片描述

当执行到f下一个位置时，read返回值就为-1，那么这种read（）读取实现的话，就可以用循环来实现

read方法1代码


/*
* 1.文件字节输出流，万能的，任何类型的文件都可以采用这个流来读
* 2.字节的方式，完成输入的操作，完成读的操作（硬盘--->内存）
* */

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest01 {
    public static void main(String[] args) {
    //创建文件字节输入流对象
        // 文件路径:(IDEA会自动把\编程\\，因为java中\代表转义)
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("G:\\test.txt");

            //开始读
            int readData =fis.read();//这个方法的返回值是：读取到的“字节”本身
             System.out.print(readData+"\n");

             readData =fis.read();//这个方法的返回值是：读取到的“字节”本身
              System.out.print(readData+"\n");

            
             readData =fis.read();//这个方法的返回值是：读取到的“字节”本身
             System.out.print(readData+"\n");


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //在finally语句块中确保流一定关闭
            if(fis!=null){//避免空指针异常
        //关闭流的前提是：流不是空
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在这里插入图片描述

read方法1实现截图

在这里插入图片描述

read方法2代码

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest02 {
    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("G:\\test.txt");
            while(true){
                int readData=fis.read();
                if(readData==-1){
                    break;
                }
                System.out.println(readData);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }
}
改造后for循环
  int readData=0;
            while((readData=fis.read())!=-1){
                System.out.println(readData);
            }

read方法2实现截图

在这里插入图片描述

在这里插入图片描述

read方法3代码

IDEA默认的当前路径是哪里？

首先得搞懂这个问题，我们在src下面创建一个tempfile
在这里插入图片描述
在这里插入图片描述

然后执行以下代码：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest03 {
    /*
    *
    * int read(byte[] b)
    * 一次最多读取b.length个字节
    * 减少硬盘和内存的交互，提高程序的执行效率
    * 往byte数组当中读
    * */
    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            //相对路径的话呢？相对路径一定是从当前所在的位置作为起点开始找
            //IDEA默认的当前路径是哪里？工程project的根就是IDEA的默认当前路径
            fis=new FileInputStream(
                    "tempfile");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}
毫无疑问，报错

在这里插入图片描述
找不到指定文件，很简单的原因，当前路径想错了

两个解决办法：
第一个 办法

在这里插入图片描述
先找到文件所在path
在这里插入图片描述

重点

IDEA默认的当前路径是哪里？工程project的根就是IDEA的默认当前路径

把tempfile文件拷贝一份，放在工程project的根，也就是当前的上层目录
在这里插入图片描述
拷贝完成，然后再次执行上述代码

在这里插入图片描述
运行成功

第二个 办法

把如下代码

fis=new FileInputStream(
                    "tempfile");

变成

fis=new FileInputStream(
                    "src//tempfile");

在这里插入图片描述
在这里插入图片描述
执行结果如下
在这里插入图片描述

操作过程（如何看长度）

开始读，采用byte数组，一次读取多个字节，最多读取“数组.length”个字节

   byte []bytes=new byte [4];//准备一个4个长度的数组，一次最多读取4个字节
第一次调用read(bytes)如下图：

在这里插入图片描述

 int readCount= fis.read(bytes);

这个方法的返回值是：读取到的字节数量(不是字节本身)，数据已经放在了bytes数组中去
在这里插入图片描述

第二次调用read(bytes)如下图：

在这里插入图片描述
这次读取到了两个字节

readCount= fis.read(bytes);
System.out.println(readCount);//第二次只能读到2个字节

在这里插入图片描述

第三次调用read(bytes)：

读不到任何数据返回-1

 readCount= fis.read(bytes);//第三次1个字节都没有读取到，返回-1
System.out.println(readCount);//-1

在这里插入图片描述

操作过程（如何看读取出的数据）

在这里插入图片描述

  //这个方法的返回值是：读取到的字节数量(不是字节本身)
            int readCount= fis.read(bytes);

            System.out.println(readCount);//第一次读到了4个字节
            System.out.println(new String(bytes));

             readCount= fis.read(bytes);
            System.out.println(new String(bytes));
           // System.out.println(readCount);//第二次只能读到2个字节

在这里插入图片描述

第二次只读取两个字节，然后它把读取到的5和6放在1和2位置处，但是原来数组中3和4还依然存在，这也就符合我们下图所表示的
在这里插入图片描述

操作过程注意点

问题来了，我们应该是读取了多少个，就写多少个，（不应该全部转换）而不是写数组的全部进入String中，应该用如下形式
在这里插入图片描述

  //开始读，采用byte数组，一次读取多个字节，最多读取“数组.length”个字节
            byte []bytes=new byte [4];//准备一个4个长度的数组，一次最多读取4个字节

            //这个方法的返回值是：读取到的字节数量(不是字节本身)
            int readCount= fis.read(bytes);

            System.out.println(readCount);//第一次读到了4个字节
            System.out.println(new String(bytes,0,readCount));

             readCount= fis.read(bytes);
            System.out.println(new String(bytes,0,readCount));
           // System.out.println(readCount);//第二次只能读到2个字节

            readCount= fis.read(bytes);//第三次1个字节都没有读取到，返回-1

在这里插入图片描述

总结实现代码
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest04 {
    public static void main(String[] args)  {
        FileInputStream fis=null;

        try {
            fis=new FileInputStream("src//tempfile");
            //准备一个byte数组
            byte[]bytes=new byte[4];
            int readCount=0;
            while(true){
                 readCount=fis.read(bytes);
                if(readCount==-1){
                    break;
                }
                System.out.print(new String(bytes,0,readCount));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在这里插入图片描述

改版后的while循环
  int readCount1=0;
            while((readCount1=fis.read(bytes))!=-1){
                System.out.print(new String(bytes,0,readCount1));
            }

available方法

int available()

返回流当中剩余的没有读到的字节数量

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest05 {
    public static void main(String[] args)  {
        FileInputStream fis=null;

        try {
            fis=new FileInputStream("");
            
            System.out.println("总字节数量"+fis.available());
            
            //读取1个字节
            int readByte=fis.read();
            //还剩下可以读的字节数量是5;
            
              System.out.println("剩下多少字节没有读："+fis.available()+"字节");
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在这里插入图片描述

作用如下：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamTest05 {
    public static void main(String[] args)  {
        FileInputStream fis=null;

        try {
            fis=new FileInputStream("src//tempfile");

            System.out.println("总字节数量"+fis.available());
            
            //这个方法有什么用？
            byte []bytes=new byte[fis.available()];//这种方式不太适合太大的文件，因为byte数组不能太大
            //不需要循环了
            //直接读一次就行了
            int readCount=fis.read(bytes);
            System.out.print(new String(bytes));//一次到位

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

在这里插入图片描述

注意：

这种方式不太适合太大的文件，因为byte数组不能太大

skip方法

跳过几个字节不读取

long skip (long n)

实现代码

public class FileInputStreamTest05 {
    public static void main(String[] args)  {
        FileInputStream fis=null;

        try {
            fis=new FileInputStream("src//tempfile");

      
            fis.skip(3);
            System.out.print(fis.read());

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

在这里插入图片描述
字符4的ASCII码值是52
在这里插入图片描述

FileOutputStream

实现代码1（清空再写入）

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

public class FileOutputStreamTest01 {
    /*
    * 文件字节输出流，负责写
    * 从内存到硬盘
    * */
    public static void main(String[] args) {
        FileOutputStream fos=null;

        try {
           
            fos=new FileOutputStream("myfile");

            //开始写
            byte[]bytes={97,98,99,100};

            fos.write(bytes);

            fos.write(bytes,0,2);//再写出ab

            //写完之后，最后一定要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

注意点

  1. myfile文件不存在时会自动新建
  2. 这种方式谨慎使用，这种方式会将原文件清空，然后重新写入

实现代码2（以追加的方式）

在这里插入图片描述
在这里插入图片描述

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

public class FileOutputStreamTest01 {
    /*
    * 文件字节输出流，负责写
    * 从内存到硬盘
    * */
    public static void main(String[] args) {
        FileOutputStream fos=null;

        try {
            //myfile文件不存在时会自动新建
            //这种方式谨慎使用，这种方式会将原文件清空，然后重新写入
            fos=new FileOutputStream("myfile",true);

            //开始写
            byte[]bytes={97,98,99,100};

            fos.write(bytes);

            fos.write(bytes,0,2);//再写出ab

            //写完之后，最后一定要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

注意点

  1. myfile文件不存在时会自动新建
  2. 以追加的方式在文件末尾写入，不会清空原文件内容

实现截图

执行前：
在这里插入图片描述
执行后：
在这里插入图片描述

如何写入一个String字符串


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

public class FileOutputStreamTest01 {
    /*
    * 文件字节输出流，负责写
    * 从内存到硬盘
    * */
    public static void main(String[] args) {
        FileOutputStream fos=null;

        try {
            //myfile文件不存在时会自动新建
            //这种方式谨慎使用，这种方式会将原文件清空，然后重新写入
            fos=new FileOutputStream("myfile",true);

            String s="我是一个中国人，我自豪";

            byte[] bytes3=s.getBytes();

            fos.write(bytes3);

            //写完之后，最后一定要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在这里插入图片描述

寻梦&之璐
关注
专栏目录
猿创征文｜Java中的IO流大家族 （两万字详解）
YOU__FEI的博客
09-11 2959
IO流有多种分类方式:一种方式是按照流的方向进行分类:以内存作为参照物，往内存中去，叫做输入(Input)。或者叫做读(Read)。从内存中出来，叫做输出(Output)。或者叫做写(Write) 另一种方式是按照读取数据方式不同进行分类: 有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制，这种流是万能的，什么类型的文件都可以读取。包括:文本文件，图片，声音文件，视频。 假设文件file1.txt，采用字节流的话是这样读的: a中国bc张三fe 第一次读:一个字节
Java IO流（超详细！）
热门推荐
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
Java IO流的“四大家族”
qq_63691275的博客
09-25 2726
IO流的“四大家族” 字节流：java.io.InputStream (读操作使用流） java.io.OutStream（写操作使用流） 字符流：java.io.Reader（读取器） java.io,Writer （写入器）
IO流的四大家族
m0_45421674的博客
11-17 185
IO 流这块有四大家族 字节流 字节输入流：InputStream 字节输出流：OutputStream 字符流 字符输入流：Reader 字符输出流：Witer 四大家族的流的首领是抽象类，只要是以Stream结尾的都是字节流，以Reader/Witer结尾的都是字符流 ...
JAVA_IO流四大家族（2）
寻梦&之璐
03-04 7673
文章目录FileReader实现代码查看一下读取出来的每个字符输出：FileWriter直接写入字符串：FileReader和FileWriter实现普通文本文件拷贝执行前：执行后：BufferedReader第一种（直接塞入字符流，不需转换）简介构造方法代码常识普及注意点：第二种（塞入一个字节流，经过转换成为字符流）细看构造函数转换问题解决转换问题实现代码转换代码合并注意BufferedWriter第一种（直接塞入字符流，不需转换）第二种（塞入一个字节流，经过转换成为字符流）DataOutputStrea
Java IO流大家族（总结）
liu_xin_xin的博客
06-27 571
1.IO流的分类 1.1 通过流分类:输入流，输出流 输入流：从接收器输入到java程序。 输出流：输出流接受输出字节并将这些字节发送到某个接收器，也就是从java程序输出到接收器。 1.2 通过数据单位不同分分类：字符流，字节流 在java版本中是先有字节流，再有字符流，1字符 = 2字节 字节流：每次传输一个字节，一个中文汉字是两个字节，会出现乱码。 字符流：每次传输两个字节，一般传输中文 1.3 抽...
Java中IO流
yhb500234的博客
09-09 185
本文主要概述了Java中IO流的知识,包括常用的文件字节输入流FileInputStream,文件字节输出流FileOutputStream,字符输入流FileReader,字符输出流FileReader,带有缓冲区的字符输入流BufferedReader,输出流BufferedWriter
javaio流学习总结.docx
最新发布
02-28
1. 按流的方向：Java IO流分为输入流（InputStream和Reader）和输出流（OutputStream和Writer）。输入流用于从数据源读取数据，而输出流则用于向目标位置写入数据。 2. 按数据单位：流可以分为字节流（Byte Stream...
javaio流学习总结.pdf
02-28
Java IO流是Java平台中的重要组成部分，主要用于处理输入和输出数据。本文将对Java IO流进行深入的总结和解析。 一、IO流的分类 Java IO流被分类为以下四类： 1. **按流的方向**：输入流（InputStream/Reader）...
JavaSE进阶561-581 IO流(一)流的四大家族
qq_43568982的博客
11-30 224
开始时间2020-11-22 IO流 1.Io流,什么是Io?I: Input o : output 通过Io可以完成硬盘文件的读和写。 2.Io流的分类? 按照流的方向进行分类: 以内存作为参照物，往内存中去，叫做输入(Input)。或者叫做读(Read) . 从内存中出来，叫做输出(output)。或者叫做写(write). 另一种方式是按照读取数据方式不同进行分类: 有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制这种流是万能的，什么类型的文件都可以读取。包括:文本文
IO流家族
qq_28337005的博客
02-06 435
Java中数据内存操作内存中的具体容量, 例如: byte[] buf = new byte[1024], 这只能操作byte的长度,byte.length, 当存储一些字节, 想清楚地知道里面占了多少个字节, 是无法做到的. 其已经被封装在最底层了. 因此, 我们去操作IO流时, 要操作相对应的数据内存, 就找对应的类, 以下就是IO大家族的分类: Java中其他多种多样变化的
IO流四种基本抽象的关系图
weixin_45575129的博客
10-07 316
IO流四种基本抽象的关系图：
Java集合四大家族的故事（四）——Map家族的LinkedHashMap
weixin_33893473的博客
08-16 137
2019独角兽企业重金招聘Python工程师标准>>> ...
java四大集合_Java集合四大家族的故事（四）——Map家族的LinkedHashMap
weixin_35920379的博客
02-25 126
每个家族都有一个最基本且最常用的数据类型：比如List系列的ArrayList，Map系列的HashMap，并且，它们的本质都是数组存储结构。相似的是，每个家族都有一个Linked开头的类，如List家族的LinkedList和Map家族的LinkedHashMap，这两个类的存储的数据结构又都是双向链表(其实是连续数组添加了两个方向的指针，所以既能与数组兼容，又能够有双向链表的性质)。而引入双向...
Java IO流史上最全详细汇总，确定不来瞅瞅吗！！(内容稍长，建议亲这边收藏慢慢看哦。)
我这么骄傲的一个人。
07-20 1604
目录前言一、IO流概述二、IO流的分类：Java IO流四大家族：四大家族的首领常用方法：java.io包下重要的流有16个：三、重要IO流详解文件流：FileInputStream(文件字节输入流)FileOutputStream(文件字节输出流)FileReader(文件字符输入流)FileWriter(文件字符输出流)缓冲流：BufferedReader（缓冲字符输入流）BufferedWriter（缓冲字符输出流）标准输出流：PrintStream（标准字节输出流）对象流：序列化与反序列化四、Fil
java家族_集合大家族--Java
weixin_30445963的博客
02-16 310
FROM:http://blog.csdn.net/chenssy/article/details/17732841在編寫Java程序中，我們最常用的除了八種基本數據類型，String對象外還有一個集合類，在我們的的程序中到處充斥着集合類的身影！java中集合大家族的成員實在是太豐富了，有常用的ArrayList、HashMap、HashSet，也有不常用的Stack、Queue，有線程安全的Ve...
java中常用的IO流图解
zhblanlan的博客
08-07 2063
IO家族体系图 字节流：读写的都是字节。 输入流：[xxx]InputStream 输出流：[xxx]OutputStream 字符流：读写的都是字符。 输入流：[xxx]Reader 输出流：[xxx]Writer ...
【随笔】java家族背景 一
HD_jiangbin_的博客
12-04 142
'java Card' 支持一些java小程序，运行在小内存设备平台上 'java ME (java platform micro edition)' java 平台微型版，支持java程序运行在移动终端平台上，对java API有所精简。 'java SE (java platform standard edition)' java 平台标准版，支持面向桌面级应用的java平台，提供了完整的java核心API。 'java EE (java platform enterprise edtion)'.
JAVA-IO流
weixin_49536876的博客
09-22 253
JAVA-IO流IO流的四大家族需要掌握的流共16个.FileInputStream的使用FileOutputStream的使用文件的复制文件复制的原理序列化与反序列化序列化版本号的用途Properties IO流的四大家族 **- InputStream 字节输入流 OutputStream 字节输出流 Reader 字符输入流 Writer 字符输出流 四大家族的首领都是抽象类 -注意： 在JAVA中只要“类名”以Stram结尾的都是字节流，以“Reader”/“Writer”结尾的都是字符流**，所
Java IO流详解：从入门到精通
"本文详细介绍了Java.IO流的概念，包括其应用、分类、常用类以及在面试中的常见问题。Java.IO流是Java核心库的重要组成部分，用于处理输入和输出操作，如文件读写和标准设备输出。Java.IO流基于流式处理，数据被串行...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

寻梦&之璐

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

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

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

打赏作者

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

抵扣说明：

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

余额充值