java中的io流（输入输出流，序列化与反序列化，字节流 ， 字符流，包装流，缓冲流）

最新推荐文章于 2021-06-07 17:35:55 发布
最新推荐文章于 2021-06-07 17:35:55 发布
阅读量746 收藏
点赞数
分类专栏： java高级 文章标签： java中的io流 输入输出流 序列化与反序列化 字节流 字符流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XA5851477/article/details/73522369
版权
四大抽象类（ InputStream     OutputStream  Reader  Writer   ）
八大子类( FileInputStream,    FileOutStream,  FileReader, FileWriter
                      DataOutputStream ,  DataInputStream ObjectInputStream, ObjectOutputStream )
输入输出流：
     在程序的角度   读取文件 输入流
                             写数据到文件中 输出流

IO流按照方向： 输入流  /   输出流
     输入流 
InputStream 抽象类 -》子类   FileInputStream,         Reader 抽象类
     输出流
           OutputStream  抽象类 -》子类   FileOutStream,           Writer  抽象类


按照操作的字节数： 字节流  字符流
     字节流 
InputStream 抽象类 -》子类   FileInputStream,  输入字节流   单个字节读取
OutputStream  抽象类 -》子类   File OutputStream   ,   输出字节流   单个字节写入
    
     字符流 :按照一个字符来操作的2个字节
      Reader 抽象类
                    子类 InputStreamReader ->子类 FileReader
      Writer  抽象类
                     子类 OutputStreamReader ->子类 FileWriter
eg:实现文件的拷贝
public static void main(String[] args) throws IOException {
                   File file = new File("E:\\培训\\java\\index.jsp");
                   File file2 = new File("E:\\培训\\java\\copy\\copy5.jsp");
                   FileReader reader=null;
                   FileWriter writer =null;
                   try {
                              reader =new FileReader(file);
                              writer=new FileWriter(file2);
                             int a=reader.read();
                             char array[]=new char [(int)file.length()];
                             reader.read(array);
                             writer.write(array);
                             writer.flush();// 必须写，不然只是拷贝到文件的缓冲区，并无真实内容
                   } catch (Exception e) {
                             e.printStackTrace();
                   }finally{
                             if (writer!=null) {
                                      writer.close();
                             }
                             if (reader!=null) {
                                      reader.close();
                             }
                   }
包装流：
1.DataOutputStream    / DataInputStream
      1. 与机器底层无关的输入，输出 包装流
可以适当方式将基本 Java 数据类型写入输出流中
     

eg:向文件中写入数据
public static void main(String[] args) throws IOException {
                   File file = new File("E:\\培训\\java\\tt.txt");
                   try {
                             FileOutputStream out = new FileOutputStream(file);
                             DataOutputStream dOut = new DataOutputStream(out);
                             dOut.writeInt(20);
                             dOut.writeDouble(3.14);
                             dOut.writeChar('x');
                             dOut.writeUTF("好好学习");
                             dOut.flush();
                             dOut.close();

                             FileInputStream in = new FileInputStream(file);
                             DataInputStream din = new DataInputStream(in);
                             int a = din.readInt();
                             double d = din.readDouble();
                             char c = din.readChar();
                             String s = din.readUTF();

                             //必须按照写入的数据类型顺序来读才不会出现乱码
                             System.out.println(a);
                             System.out.println(d);
                             System.out.println(c);
                             System.out.println(s);

                   } catch (FileNotFoundException e) {
                             e.printStackTrace();
                   }
          }



   
2.序列化与反序列化
   读写对象的 序列化 反序列化
ObjectInputStream 反序列化

ObjectOutputStream 序列化
    序列化 ->就是把对象写入到文件中去保存 

     反序列化->就是把文件中的对象读取到内存中去

java.io.Serializable 接口 可序化接口
一个对象要实现 序列化与反序列化这个对象的类就必须实现Serializable 接口
序列化只能对类的成员属性，不能对类的static成员进行
eg：将person对象写入到文件中，然后从文件中读取对象到内存中去
public static void main(String[] args) {
                   try {
                             Person p = new Person(1, "张三丰", "男");
                             ObjectOutputStream objOut = new ObjectOutputStream(
                                                new FileOutputStream(new File("E:\\培训\\java\\object.txt")));
                             objOut.writeObject(p);
                             objOut.flush();
                             objOut.close();
                   } catch (Exception e) {
                             e.printStackTrace();
                   }
                   try {
                             ObjectInputStream inObj = new ObjectInputStream(
                                                new FileInputStream(new File("E:\\培训\\java\\object.txt")));
                             Person person = (Person) inObj.readObject();
                             System.out.println(person);
                             System.out.println(person.num);//
                   } catch (Exception e) {
                             e.printStackTrace();
                   }

缓冲流：
BufferedReader 
  可以实现文件一行行的读写内容    
eg：实现拷贝文件的功能

package com.zt;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferReaderDemo {
    public static void main(String[] args) throws IOException {
        File file1 =new File("E:\\培训\\java\\index.jsp");
        File file2 =new File("E:\\培训\\java\\index7.jsp");
        FileReader reader;
        FileWriter writer;
        try {
            reader = new FileReader(file1);
            writer = new FileWriter(file2);
            BufferedReader breader =new BufferedReader(reader);
            BufferedWriter bwriter=new BufferedWriter(writer);
            String str =breader.readLine();
            while (str!=null) {
                bwriter.write(str);
                bwriter.newLine();
                str=breader.readLine();
            }
            bwriter.flush();
            bwriter.close();
            breader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

eg:实现控制台复制输出功能，可以代替Scanner工具类实现同样的接收控制台输入数据的功能
public static void main(String[] args) {
                   BufferedReader in =new BufferedReader(new InputStreamReader(System.in));
                   try {
                             String string="";
                             while (!"exit".equals(string)) {
                                      string=in.readLine();
                                      System.out.println(string);
                             }
                   } catch (Exception e) {
                             e.printStackTrace();
                   }
          }

创建对象的方法；
1：new 
2：反序列化  类就必须实现serializable接口
          通过ObjectInputStrem 的readObject
eg:

public  class SerializableUtil {
          //序列化方法
          public  static boolean Serializable(Object obj,String path) {
                   File file=new File(path);
                   FileOutputStream out =null;
                   ObjectOutputStream objOut=null;
                   boolean result =true;
                   try {
                              out =new FileOutputStream(file);
                              objOut=new ObjectOutputStream(out);
                             objOut.writeObject(obj);
                             objOut.flush();
                             objOut.close();
                   } catch (Exception e) {
                             result=false;
                             e.printStackTrace();
                   }finally{
                   try {
                             if (out!=null) {
                                      out.close();
                             }
                   } catch (Exception e2) {
                             e2.printStackTrace();
                   }
                   }
                   return result;
          }

          //反序列化方法
          public  static Object reverSerializable(String path ) {
                   Object obj =null;
                   File file =new File(path);
                   FileInputStream in =null;
                   ObjectInputStream ojbin=null;
                   try {
                             in =new FileInputStream(file);
                              ojbin=new ObjectInputStream(in);
                              obj=ojbin.readObject();
                   } catch (Exception e) {
                             e.printStackTrace();
                   }finally{
                   try {
                             if (in!=null) {
                                      in.close();
                             }
                             if (ojbin!=null) {
                                      ojbin.close();
                             }
                   } catch (Exception e2) {
                             e2.printStackTrace();
                   }
                   }
                   return obj;
          }
          public static void main(String[] args) {
                   //序列化
                   Person p = new Person(1, "张三丰", "男"); //注：person类必须实现Serializable接口
                   boolean f =Serializable(p,"E:\\培训\\java\\object2.txt");
                   System.out.println(f);
                   //反序列化
                   Person p2  =        (Person) reverSerializable("E:\\培训\\java\\object2.txt");
                   System.err.println(p2);
          }
}

3：克隆 类就必须实现Cloneable接口
          通过类对象的clone（）方法进行克隆
eg：
public class Person  implements Cloneable{...｝//必须实现Cloneable接口
      public static void main(String[] args) {
                   Person p = new Person(1, "张三丰", "男");
                   Person p2=(Person) p.clone();
                   System.out.println(p2);
          }

4：反射
     Class.forName(“类路径”).newIntance();
必须确保类里面有默认的构造器
eg:
package com.zt;
public class Pig {...}
public static void main(String[] args) {
          try {
                   Pig p =(Pig) Class.forName("com.zt.Pig").newInstance();
                   p.name="呆呆";
                   p.sex="公";
                   System.out.println(p);
          } catch (Exception e) {
                   e.printStackTrace();
          }
}


流的使用步骤：
     1：创建流     
     2：使用流
     3：关闭流
eg：实现文件的输出

package com.zt;

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

public class FileInputStreamDemo {
    public static void main(String[] args) {
        File file =new File("E:\\培训\\java\\index.jsp");

        try {
            FileInputStream in =new FileInputStream(file);
            try {
                //第一种方式  会出现中文乱码问题
                /*    int n  = in.read();
            while (n!=-1) {
                char c= (char) n;
                System.out.print(c);
                n  = in.read();
            }*/
                //第二种方式
        byte[] bs =new byte[(int) file.length()];
            in.read(bs);
            String str =new  String(bs);
            System.out.println(str);


            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

eg：实现文件的拷贝

package com.zt;

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

public class FileCopyDemo3 {

    public static boolean copy(File file, File file2) {
        boolean f = true;
        FileInputStream in = null;
        FileOutputStream out = null;
        try {
            in = new FileInputStream(file);
            byte[] bs = new byte[(int) file.length()];
            in.read(bs);
            out = new FileOutputStream(file2);
            out.write(bs);
        } catch (Exception e) {
            f = false;
            e.printStackTrace();
        } finally {
            try {
                // 先关闭out输入流
                if (out != null) {
                    out.close();
                }
                if (in != null) {
                    in.close();
                }
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        return f;

    }

    public static void main(String[] args) {
        File file = new File("E:\\培训\\java\\index.jsp");
        File file2 = new File("E:\\培训\\java\\copy\\copy4.jsp");
        copy(file, file2);

    }
}

萧十一郎XA
关注
专栏目录
序列化 和 打印输出流
Johnsontao
03-03 326
序列化和反序列化的概述 序列化就是把对象存储到文件中。 要想实现对象的序列化 ，这个类必须要实现serializable接口（充当一个标记作用） 有了这个标记，在序列化时，系统会自动分配一个序列号（用作校对序列前后，也可手动指定） 对象序列化流 ObjectOutPutStream （对象输出流） 和 ObjectInputStream （对象输入流） ObjectOutPutStream （对...
字节流和字节顺序(用于序列化和反序列化)
game_helloworld的博客
04-10 3806
介于要设计游戏服务器和客户端逻辑，现在需要普及一下我在代码中用到的一些数据结构，这一篇讲一下字节流--- ByteStream。 字节流就是自己实现的一个数据存储区，可对基础数据和其他特定数据进行序列化和反序列化。用与玩家数据或者其他服务器数据的落地保存。也可用于客户端和服务器,、服务器和服务器之间的通信。里面也添加了对字节顺序的处理逻辑。如果是通信的数据包可以启动字节顺序转换。 需要注意的一点是我对输入的每一个元素只拷贝元素内容，没有存储其类型，所以在字节流输出的时候没有办法做类型校验，这样对于结构经
输入输出流，序列化
wang289529801的博客
08-17 808
输入输出流 输入流以inputStream和Reader为基类；输出流以OutputStream和Writer为基类； 其中还有字节、字符流，字节（inputStream，OutputStream）可以对任何文件进行操作，而字符流（Reader，Writer）只能对文本数据进行操作。 在基本流的后面还有包装流（buffered..）buffered..的包装流是继承上面的基类，将数据先写到缓冲
JAVA笔记_IO(字节流、字符流、包装流)
哈哈哈哈_哈士奇的博客
08-02 910
Java IO 什么是IO I---->input　　从文件中读取数据 O—>output　　向目标写入数据 在编程中：无论是文件还是文件夹，都是文件 File文件操作类 java.io包下 作用：将具体的文件映射到内存中 构造方法： 　　File file = new FIle(String path); 　　path是文件的路径 文件路径： 　　相对路径：一般是从某个特定的目...
关于序列化：把某个对象序列化成字节流
yanziguilai的专栏
07-11 1926
在网络编程中，一个经常的操作是将本地的数据块转换成字符流并将其发送到远端，远端将这个字符串流恢复成数据库。假设有如下一个类CObject，编写两个函数，分别将CObject中的成员变量转换为一个字符流（convert2Stream()函数），并将字符流的数据重新恢复到一个CObject对象中（convert2Object()函数）： char* convert2Stream(const CObj
io_输入输出流_序列化反序列化_04.zip
09-20
本文将深入探讨Java中的IO流体系，包括字节流与字符流，以及序列化和反序列化的概念。我们将通过标题"io_输入输出流_序列化反序列化_04.zip"中的内容，详细解析这些关键知识点。 首先，让我们从IO流的基本概念开始...
Java的IO流讲解代码: File 类、RandomAccessFile 类、字节流（文件字节流、缓冲字节流、基本数据类型
最新发布
06-20
File 类、RandomAccessFile 类、字节流（文件字节流、缓冲字节流、基本数据类型字节流、打印流、对象序列化流、字节数组流）、字符流（缓冲字符流、文件字符流、转换流、格式化输出流、字符数组流） 这份代码源码...
day21_缓冲流、转换流、序列化流、Commons IO.pdf
11-02
总的来说，缓冲流、转换流和序列化流是Java IO编程中的重要组成部分，它们提供了更高的效率和灵活性，帮助开发者更好地处理数据的读写和对象的持久化。了解并熟练运用这些流，对于提升Java应用的性能至关重要。在...
IO流与序列化
05-09
在Java编程语言中，`IO流`（Input/Output Stream）和`序列化`是两个重要的概念，它们在处理数据传输、持久化存储以及对象状态的保存等方面发挥着关键作用。 **IO流**： IO流是Java提供的用于处理输入输出操作的机制...
java包装流_java 节点流（字符流，字节流）和包装流（缓冲流，转换流）
weixin_29529047的博客
02-12 312
packagestream;importjava.io.File;importjava.io.FileNotFoundException;importjava.io.FileReader;importjava.io.FileWriter;importjava.io.IOException;importorg.junit.jupiter.api.Test;/** 流的体系结构： 抽象...
序列化和反序列化
weixin_44893467的博客
06-25 115
1、序列化和反序列化的定义： (1)Java序列化就是指把Java对象转换为字节序列的过程 Java反序列化就是指把字节序列恢复为Java对象的过程。 (2)序列化最重要的作用：在传递和保存对象时.保证对象的完整性和可传递性。对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。 反序列化的最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。 总结：核心作用就是对象状态的保存和重建。（整个过程核心点就是字节流中所保存的对象状态及描述信息） 2、json/xml
序列化与反序列化 字符流和字节流：通过网络传输结构化的数据
yinlingjishu的博客
11-05 993
一、前言 在TCP的连接上，它传输数据的基本形式就是二进制流，也就是一段一段的1和0。在一般编程语言或者网络框架提供的API中，传输数据的基本形式是字节，也就是Byte。一个字节就是8个二进制位，8个Bit，所以在这里，二进制流和字节流本质上是一样的。对于我们编写的程序来说，它需要通过网络传输的数据是结构化的数据，比如，一条命令、一段文本或者一条消息。对应代码中，这些结构化的数据都可以用一个类或者一个结构体来表示。 要想使用网络框架的API来传输结构化的数据，必须得先实现结构化的数据与字节流之间的双向转换。
IO流,File类,序列化,字符流,字节流,简单基础学习
weixin_52188374的博客
06-07 147
1.File类 //----------------------------------File类--------------------------------------------------- File file = new File("D:\\图片"); File file1 = new File("D:\\", "图片1"); File file2 = new File(file1, "1.jpg"); ..
对象序列化字节流 与 字节流发序列化为对象
痛苦只是暂时的
05-16 248
import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; /* * 对象序列化为字节流 *...
IO流/属性类/序列化
TU_BO的博客
11-27 335
一:IO流1.合并流 构造方法1: public SequenceInputStream(InputStream s1,InputStream s2) 示例: //分别封装这个两个java文件 InputStream s1 = new FileInputStream("DataStreamDemo.java") ; InputStream s2 =
Java之序列化和反序列化
wkh18891843165的博客
03-30 293
字符流和字节流，他们的操作对象是：字节（二进制），字符 序列化和反序列化的操作主体对象是：对象和二进制 什么是序列化和反序列化？ 序列化：将对象转换成二进制 反序列化：从二进制中将二进制转换成对象（类） 为什么需要序列化和反序列化？ 因为系统数据间的交互，一定传输的是二进制对象，而我们编写代码的时候不可能使用二进制进行编写，所以我们编写业务代码的时候使用的是类对象，当别人调用我的API的时候调用的是二进制，因此需要先序列化，将对象转换成二进制进行传输，那么在读取到二进制的时候进行反序列化操作就可以将.
Java基础【三】IO流-序列化与反序列化入门
qq_41204927的博客
06-22 292
IO流的作用： 在变量，数组和对象中储存的数据都是暂时存在的，程序结束后他们就是丢失 。为了能够永久的保存程序创建的数据，需要将其保存在磁盘文件中，这样就可以在其它程序中使用他们了的.java的IO技术可以将数据保存到本地文件，二进制文件甚至是ZIP压缩文件中，以达到永久性保存数据的要求。掌握IO处理技术能够提高对数据的处理能力 流概述 流是一组有序的数据序列，根据操作的类型可以将流分为两...
java序列化流：序列化与逆序列化
ll谢安生的博客
09-26 380
package com.qianfeng.test; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import ...
Java IO流详解：操作文件、序列化与实践
Java学习笔记深入探讨了IO流在Java编程中的关键作用，它涉及文件和目录操作、数据读写、以及序列化和反序列化的概念。首先，让我们从基础的IO流概念开始： 1. 文件和目录操作：`File` 类是Java中处理文件和目录的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值