java IO流知识梳理

最新推荐文章于 2024-07-25 09:48:00 发布
最新推荐文章于 2024-07-25 09:48:00 发布
阅读量87 收藏 1
点赞数
文章标签： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WAX_1197975711/article/details/125841040
版权

IO就是对文件的读和写

I是读取文件到内存

O是写出内存文件

字节输入流（InputStream）：抽象类

     常用子类：  FileInputStream   

      构造方法：

                        public  FileInputStream(String path);

                         public  FileInputStream(File  path);

    常用方法：

                    int  read( );  //读取一个字节的数据，如果没有数据返回-1；

                    int  read( );  //读取数据存入byte数据中，返回读取长度没有数据返回-1；

                    void  close( ); //释放

public static void main(String[] args) throws IOException  {
        InputStream is = new FileInputStream("a.txt");
        int i = is.read();
        System.out.println(i);
        //循环读取(方法一）
        int data;
        while((data=is.read())!=-1) {
            System.out.println(data);
        }
        //循环读取(方法二）
        while(true) {
            int data=is.read();
            if(data==-1) {
                break;
            }
            System.out.println(data);
        }
        is.close();
    }


   BufferedInputStream：缓冲字节输入流

          构造方法：

                      //调用下面构造方法的时候，底层会创建一个长度是8192的byte数组

                      //调用读取方法的时候，每次读取8K的数据，每次操作的字节就是从该数组的对应位                           置获取的。

                      //使用了缓冲区减少了读取的次数

                        public BufferedInputStream(InputStream is);

                     //调用下面的构造方法，底层会创建一个长度是size的byte数组

                          public BufferedInputStream(InputStream is,int size);

public static void main(String[] args) throws IOException {
        InputStream is = new BufferedInputStream(new FileInputStream("info.txt"));
        int data;
        while((data=is.read())!=-1) {
            System.out.print((char)data);
        }
        is.close();
    }


     ObjectInputStream:(反序列化)

              构造方法：

                                public ObjectInputStream(InputStream is);

              成员方法：

                                  Object readObject();

             注意事项： 

                        a.序列化后，类文件结构不能改变，如果改变了反序列化就会报错。

                         如果不能保证不修改类文件结构，则可以在该类中添加一个成员变量(常量)：

                                serialVersionUID

public static void main(String[] args) throws IOException, ClassNotFoundException  {
        Person p = new Person("张良",20);
        p.car = new Car();//给成员变量car赋值
        p.m = new Money();
 
       ObjectInputStream ois = new ObjectInputStream(new FileInputStream("p.txt"));
        Object obj = ois.readObject();
        Person p2 = (Person)obj;
        System.out.println(p2);
        ois.close();
        System.out.println(p2==p);//反序列化回来后，会重新构建一个对象
}
 
class Person implements Serializable{
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    public Car car;
    public transient Money m;
    
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", car=" + car + ", m=" + m + "]";
    }
}


 字节输出流（OutputStream）：抽象类   

       常用子类：    FileOutputStream;

       构造方法：     

                         public  FileOutputStream(String path);

                         public  FileOutputStream(File  path);

                        public  FileOutputStream(String path , boolean append);

                         public  FileOutputStream(File  path , boolean  append);

        成员方法：

                           void close();  //释放流

                           void flush();

                           void write(int data);  //写一个字节的数据

                          void write(byte[] b);

                          void write(byte[] b,int offset,int len);

     

  OutputStream os = new FileOutputStream("a.txt");
        os.write(98);
        byte[] b = {97,98,99,100,101};
        os.write(b);
        os.write(b, 0, 3);
        os.write("我是中国人，我深情的爱着我的祖国和人民！！！".getBytes());
        os.close();
        System.out.println("数据写出完毕....");


BufferedOutputStream：缓冲字节输出流

           构造方法：

                            //调用这个构造方法，底层会创建一个长度是8192的byte数组

                            //写出的数据，存入缓冲区(8192的byte数组)中

                            //存满了，或者显示的调用flush(close)方法，会把缓冲区中的数据写出去

                           //有了缓冲区减少了写出的次数

                                public BufferedOutputStream(OutputStream os);

                           //调用这个构造方法，底层会创建一个长度是size的byte数组

                                public BufferedOutputStream(OutputStream os,int size);

public static void main(String[] args) throws IOException {
        OutputStream os = new BufferedOutputStream(new 
          FileOutputStream("a.txt",true),1024*10);
        os.write("测试缓冲字节输出流".getBytes());
        os.flush();
        os.close();
    }
ObjectOutputStream：(序列化)

                        构造方法:

                                        public ObjectOutputStream(OutputStream os);

                        成员方法:

                                        void writeObject(Object obj);

                        注意事项：                  

                        a.序列化的对象必须是Serializable类型

                         b.成员变量的类型也必须是Serializable类型

                         c.使用transient关键字修饰的成员变量不进行序列化        

public static void main(String[] args) throws IOException, ClassNotFoundException  {
        Person p = new Person("张良",20);
        p.car = new Car();//给成员变量car赋值
        p.m = new Money();
 
       ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("p.txt"));
        oos.writeObject(p);
        oos.close();
        System.out.println("序列化成功...");
}
 
class Person implements Serializable{
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    public Car car;
    public transient Money m;
    
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", car=" + car + ", m=" + m + "]";
    }
}


  字符输入流(Reader)

                  常用方法：

                                          int read(); //读取一个字符数据

                                          int read(char[] ch);  //读取数据存入char数组中，返回读取的长度

                                          void close();

public static void main(String[] args) throws IOException {
        Reader r = new FileReader("b.txt");
        int data = r.read();//读取一个字符的数据
        System.out.println((char)data);
 
        char[] ch = new char[3];
        r.read(ch);
        System.out.println(ch);
}


常用子类： FileReader

               构造方法：

                                //减少读取的次数，提高效率。数组大小不能改变。

                                //调用下列构造方法的时候，底层会创建一个长度是8192的byte数组。

                                //每次调用读取方法，至少读取8192多字节的数据，存入该byte数组中。

                                //把byte数组中对应位置的元素，转换成char类型的值。

                                        public FileReader(String path);

                                        public FileReader(File path);

     BufferedReader：

              构造方法;

                        //调用下面构造方法的时候，底层会创建长度是8192的char数组

                        //每次调用读取方法，读8192byte的数据存入byte数组中

                        //把byte数组中的数据转换存入char数组中，直到char数组存满

                        //我们操作的数据是从char数组中对应位置获取//和FileReader比较，读取次数是 一样的。从byte转换为char转换次数不一样

                           public BufferedReader(Reader r);

                          //调用下面构造方法的时候，底层会创建一个长度是size的char数组

                            public BufferedReader(Reader r,int size);

             成员方法：

                                  String readLine();//如果没有数据则返回null

public static void main(String[] args) throws IOException {
        Reader r = new BufferedReader(new FileReader("b.txt"));
        
        r.close();
    }


      InputStreamReader：

                          构造方法：

                                        public InputStreamReader(InputStream is);

                                         public InputStreamReader(InputStream is,String charsetName);

public static void main(String[] args) throws IOException {
        //转换输出流
        Reader r = new InputStreamReader(new FileInputStream("c.txt"),"UTF-8");
        int data = r.read();
        System.out.println((char)data);
        r.close();
}


字符输出流(Writer)：

           成员方法：

                           void write(char[] ch);  //写出char数组数据

                           void write(char[] ch,int offset,int len);

                           void write(int data); //写出一个字符的数据

                           void flush();  //刷新缓冲区，不关闭流，还可以传入数据

                           void write(String str);

                           void write(String str,int offset,int len);

                           void close();  //关闭流，刷新缓冲区

public static void main(String[] args) throws IOException {
        Writer w = new FileWriter("b.txt",true);
        
        w.write("\n");
        //获取操作系统对应的换行符
        String lineSeparator = System.lineSeparator();
        w.write(lineSeparator);
        w.write(98);
 
        w.write(new char[] {'我','爱','你','中','国'});
 
        char[] ch = new char[] {'我','爱','你','中','国'};
        w.write(ch,3,2);
 
        w.write("我爱你中国");
        w.write("我爱你中国",0,3);
 
        w.close();
        System.out.println("操作完毕...");
    }


常用子类：FileWriter

     构造方法：

            //调用下列构造方法，底层会创建一个长度是8192的byte数组

           //写出的字符转换成字节，存入该缓冲区(8192的byte数组)中

           //缓冲区中的数据存不下了，或者调用flush(close)方法,会强制把缓冲区中的 数 据 写 出去。

             public FileWriter(String path);

             public FileWriter(File path);

             public FileWriter(String path,boolean b);

             public FileWriter(File path,boolean b);

Properties是Hashtable的子类：

                   所属包：

                                        java.util;

                  构造方法：

                                        public Properties();

                 成员方法：

                                     Object setProperty(String key,String value);

                                      String getProperty(String key);

                                      Set<String> stringPropertyNames();

public static void main(String[] args) {
        Properties p = new Properties();
        p.setProperty("韩国", "首尔");
        Object obj = p.setProperty("中国", "北京");
        System.out.println(obj);
        obj = p.setProperty("中国", "西安");
        System.out.println(obj);
        System.out.println(p);
        
        String value = p.getProperty("中国");
        System.out.println(value);
        
        Set<String> keys = p.stringPropertyNames();
        System.out.println(keys);
    }
                         void store(OutputStream os,String comments);

                           void store(Writer w,String comments);

public static void main(String[] args) throws IOException {
        Properties p = new Properties();
        p.setProperty("韩国", "首尔");
        p.setProperty("中国", "北京");
        
        Writer w = new FileWriter("info.txt");
        p.store(w, "test Properties writer");//把Properties对象中的数据，以某种格式写出到info.txt文件中去了
        w.close();
        System.out.println("操作完毕....");
    }


BufferedWriter：

    构造方法：

       //调用下面构造方法的时候，底层会创建一个长度是8192的char数组

       //写出数据线存入8192的char数组，直到char数组存满了，或者显示的调用flush方法

       //会把char数组中的内容转换存入到byte数组中，再把byte数组中的数据写出去。

      //和直接使用FileWriter的区别在于，字符转换字节的次数(效率)不相同，写出次数是相同的。

                  public BufferedWriter(Writer w);

       //调用下面构造方法的时候，底层会创建一个长度是size的char数组

                public BufferedWriter(Writer w,int size);

     成员方法：

                        void newLine();//写出一个换行

public static void main(String[] args) throws IOException {
        Writer w = new BufferedWriter(new FileWriter("b.txt"));
        w.write("测试缓冲字符输出流");
        w.close();
    }


OutputStreamWriter：

                构造方法：

                                 public OutputStreamWriter(OutputStream os);

                                  public OutputStreamWriter(OutputStream os,String charsetName);

public static void main(String[] args) throws IOException {
        //转换输出流
        Writer w = new OutputStreamWriter(new FileOutputStream("c.txt"),"UTF-8");
        w.write("我爱你中国");
        w.close();
}


PrintStream：打印流

     成员方法：

                          void println();

                           void print(参数);

      构造方法：

                         public PrintStream(String pathname);

                        public PrintStream(File pathname);

public static void main(String[] args) {
        System.out.println();
        
        //正常结构。默认获取的打印流对象，流向到控制台
        PrintStream xx = System.out;
        xx.println();
        
        //匿名对象
        System.out.println();
    }


 

精灵王富贵
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
javaio流电子书整理面试必考io流帮助你入职阿里腾讯
03-12
Java IO流是Java平台中用于处理输入输出操作的重要部分，对于任何Java开发者，尤其是准备面试或希望在大型公司如阿里、腾讯工作的候选人来说，掌握IO流的知识是必不可少的。以下是对Java IO流的详细解析： **一、为...
javaIO流思维导图
07-20
自己整理了一下javaIO流的相关知识点 用xmind软件做了一下
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
Java中IO流知识梳理
isGentleman的博客
06-27 501
2. 反序列化：将字节序列转换回对象的过程称为反序列化。3. 实例化具有默认构造函数的对象：在反序列化过程中，如果类没有提供自定义的readObject()方法，Java会试图实例化一个具有默认构造函数的对象，并通过将对象的状态信息从字节序列中读取来恢复对象的状态。总之，通过Java的IO流的序列化和反序列化功能，我们可以方便地将对象转换为字节序列并进行存储或传输，以及将字节序列还原为对象。在Java中，IO流的序列化和反序列化是用于将对象转换为字节序列以便存储或传输，并在需要时将其重新构造为对象的过程。
Java IO流 知识点整理
qingyun989的博客
01-11 817
有多种分类方式：一种方式是按照流的方向进行分类：以内存作为参照物往内存中去，叫做输入（Input）。或者叫做读（Read）从内存中出来，叫做输出（Output）。或者叫做写（Write）一种方式是按照读取数据方式不同进行分类：有的流是按照字节的方式读取数组，一次读取1个字节byte，等同于一次读取8个二进制这种流是万能的，什么类型的文件都可以读取，包括：文本文件，图片，声音文件，视频文件，等等假设文件file1.txt，采用字符流的话是这样读的：
【Java IO流知识总结】
独上高楼，望尽天涯路。
04-03 556
Java IO（Input&Output）😊😊 java.io包 核心组成：一个类（File）、一个接口（Serializable）、四个抽象类（InputStream/OutputStream、Reader/Writer） InputStream 此抽象类是表示字节输入流的所有类的父类。InputSteam是一个抽象类，它不可以实例化。数据的读取需要由它的子类来实现。根据节点的不同，它派生了不同的节点流子类。 继承自InputSteam的流都是用于向程序中输入数据，且数据的单位为字节（8 bi
java中io流知识梳理
qq_64891979的博客
12-15 587
java中IO流主要用于硬板、内存、键盘等处理设备上得数据操作，根据处理数据的数据类型的不同可以分为： 字节流（抽象基类为InPutStream和OutPutStream）列如：jpg，MP3，MP4等等文件 字符流（抽象基类为Reader和Writer）列如：word文档，excal文档等等。 根据流向不同，可以分为：输入流和输出流。 通过file关键字对文件，文件夹操作，file类可以跨平台进行操作，因为java是跨平台的开发环境。 主要的方法如下图： java.io包下...
JavaIO流：NIO梳理
栗筝i的博客
11-25 2550
NIO 也叫 Non-Blocking IO 是同步非阻塞的 IO 模型。线程发起 IO 请求后，立即返回。同步指的是必须等待 IO 缓冲区内的数据就绪，而非阻塞指的是，用户线程不原地等待 IO 缓冲区，可以先做一些其他操作，但是要定时轮询检查 IO 缓冲区数据是否就绪。本篇内容包括：Java NIO 介绍、Java NIO 核心组件、NIO 代码示例。
小白必看！Java中各种IO流的梳理总结
weixin_39158966的博客
03-17 348
同样的，程序中的IO流，则是以程序代码为标准，程序写出数据到文件是输出流，程序读取文件数据是输入流。当然，不同的场景需要应用不同的IO流，平哥给大家整理了不同流的应用场景。字符转换流：可以将字节流转换为字符流，可以用在对于字节流的优化上，例如socket编程中，将字节流的数据传输转字符流来提升性能。字节缓冲流：带缓冲区的字节流，是对字节节点流的性能优化，当需要读写大批量的数据时可选择字节缓冲流，例如拷贝视频文件。字符缓冲流：带缓冲的字符流，与字节缓冲流类似，其性能比字节缓冲流更高，但只能读写文本文件。
Java IO流总结
书生
08-19 300
整理IO流相关知识，看到一篇非常好的博客，特地转来保存，如有侵权，立马删除！ 文章出处http://www.cnblogs.com/oubo/archive/2012/01/06/2394638.html Java流操作有关的类或接口： 结构图如下： 流的概念和作用 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或
Java——IO流超详细总结
ywb201314的专栏
08-18 6281
该系列博文会告诉你如何从入门到进阶，一步步地学习Java基础知识，并上手进行实战，接着了解每个Java知识点背后的实现原理，更完整地了解整个Java技术体系，形成自己的知识框架。 在初学Java时，IO流是我遇到的一个很头疼的东西，Java IO 体系看起来类很多，感觉很复杂，但其实是 IO 涉及的因素太多了。在设计 IO 相关的类时，编写者也不是从同一个方面考虑的，所以会给人一种很乱的感觉，并且还有设计模式的使用，更加难以使用这些 IO 类，所以特地对 Java 的 IO 做一个总结。 1|0
JAVA_IO流整理思维导图.emmx
06-04
JAVA_IO流整理思维导图.
JAVA核心知识整理.pdf
02-20
### JAVA核心知识整理 ...以上内容覆盖了JAVA核心知识整理中的关键知识点，包括JVM的基础知识、垃圾回收机制、引用类型、GC垃圾收集器的选择、IO/NIO模型及其实现、类加载机制以及常见的集合类等。
JAVA核心知识点整理
03-12
5. **IO流**：Java的输入输出系统支持字节流和字符流，包括文件操作、网络通信和对象序列化。BufferedReader和PrintWriter用于文本处理，FileInputStream和FileOutputStream处理二进制数据。 6. **多线程**：Java...
分布式系统常见软件架构模式
最新发布
Ben的专栏
07-25 949
简而言之，有效管理数据和通信流对于构建健壮且可扩展的分布式系统至关重要。对等、API 网关、发布-订阅、请求-响应、事件溯源、ETL、批处理、流处理和编排等架构模式提供了有价值的解决方案，以应对系统设计和实现中的各种挑战。通过理解这些软件架构和分布式系统模式及其各自的优势和权衡，架构师和开发人员可以做出明智的决策，设计出满足其应用程序和用户不断变化的需求的系统。
SpringBoot整合Elastic-Job 2.1.53版本任务调度，手动任务，动态添加任务演示
小哇
07-23 394
zookeeper安装并成功运行。
数据分析师学习路线与就业环境分析报告
关注收藏，可以私信解决问题！
07-23 955
数据分析师负责收集、处理和分析数据，以帮助企业做出基于数据的决策。他们使用统计方法、数据建模和数据可视化技术来解释复杂的数据集。
江苏科技大学24计算机考研数据速览，有专硕复试线大幅下降67分！
m0_72717598的博客
07-23 499
江苏科技大学（Jiangsu University of Science and Technology），坐落在江苏省镇江市，是江苏省重点建设高校，江苏省人民政府与中国船舶集团有限公司共建高校，国家国防科技工业局与江苏省人民政府共建高校 ，教育部卓越工程师教育培养计划高校，教育部本科教学工作水平评估优秀学校，江苏省高水平大学建设高峰计划B类建设高校，中国船舶与海洋工程产业知识产权联盟、江苏船舶与海洋类高校协同发展联盟牵头单位。其中，研究生新生学业奖学金特等奖3万，一等奖1.2万，二等奖0.8万；
javaio流知识点思维导图
08-27
但是，我可以为您提供一个简要的java IO流知识点总结。 Java IO流是Java中用于处理输入和输出的机制。它提供了一种有效的方式来读取和写入数据，以及与文件、网络和其他设备进行交互。 Java IO流包括字节流和字符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值