io流实现循环输入 java java中io流

转载

智能开发艺术家 2023-07-20 14:34:12

文章标签 io流实现循环输入 java JAVA java 序列化处理流 文章分类 Java 后端开发

Java IO流详讲

1.IO流概述

IO流简单来说就是Input和Output流，IO流主要是用来处理设备之间的数据传输，Java对于数据的操作都是通过流实现，而java用于操作流的对象都在IO包中。

2.IO流分类

按操作数据分为：字节流和字符流。如：字节流：InpurStream，字符流Reader；

按流向分：输入流和输出流。如：输入流：InputStream，输出流：OutputStream；

按功能分：节点流和处理流。如节点流：FileInputStream，处理流：BufferedReader

注意区别以下概念：

节点流和处理流：直接与底层文件资源连接的称为节点流,对节点流进行包装从而完成更高级功能的称为处理流,处理流在构造时须为其指定一个节点流。

输入和输出：输入是读取外部数据（磁盘、光盘等存储设备）的数据到程序（内存）中，输出是将程序（内存）数据输出到磁盘、光盘等存储设备中；

3.File文件类

3.1 File构造方法：

File f1 = new File("D:\\zhang\\1.txt")或File f1 = new File("D:/zhang/1.txt");

3.2 File常用方法：

创建方法：

boolean createNewFile() 不存在就返回true；存在返回false

boolean mkdir() 创建目录

boolean mkdirs() 创建多级目录，若上层文件目录不存在，则一并创建

删除方法：

boolean delete()

boolean deleteOnExit()文件使用后删除

判断方法：

boolean exist() 判断文件是否存在

boolean isDirectory() 判断文件是目录

boolean isFile() 判断是否是文件

获取方法：

String getName() 返回由此抽象路径名表示的文件或目录的名称。

String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。

4.字节流：

4.1 InputStream:输入字节流，该类为抽象基类，处理非文本文件，如：视频、音频、图片、word文档等，主要有以下几个继承类；

FileInputStream:文件输入字节流，从文件获得输入字节，是节点流；

BufferedInputStream:字节缓冲输入流，比FileInputStream执行效率高，在实际开发中经常用该类，为处理流；

4.2 OutputStream:输出字节流，该类为抽象基类，处理非文本文件，如：视频、音频、图片、word文档等，主要有以下几个继承类；

FileOutputStream:文件输出字节流，将数据写入到磁盘文件，是节点流；

BufferedOutputStream:字节缓冲输出流，比FileOutputStream执行效率高，在实际开发中经常用该类，为处理流；

5.字符流

5.1 Reader:字符读流，该类为抽象类，处理文本文件，主要有以下几个继承类；

FileReader：文件读字符流，可实现文本文件的拷贝，是节点流；

BufferedReader:字符缓冲区读流，比FileReader执行效率高，在实际开发中经常用该类，为处理流；

5.2 Writer:字符写流，该类为抽象类，处理文本文件，主要有以下几个继承类;

FileWriter:文件写字符流，可实现文本文件的拷贝，是节点流；

BufferedWriter：字符缓冲区写流，比FileWriter执行效率高，在实际开发中经常用该类，为处理流；

6.操作流注意事项：

5.1 在操作文件时输入流操作的文件一定要存在，否则抛异常，对应的输出流可以不存在，当不存在时执行过程中会自动创建；

5.2 File文件类对象常被用来作为IO流的具体类的构造器形参；

7.其它流：

7.1 操作基本数据类型的流：

DataInputStream:对Java基本数据类型输入；

DataOutputStream:对java基本数据类型输入；

7.2 转换流：

OutputStreamWriter：将字符流转换为字节流，可使用指定的字符编码表，将要写入流中的字符编码成字节。它的作用的就是，将字符串按照指定的编码表转成字节，在使用字节流将这些字节写出去，实现的是编码过程；

InputStreamReader：将字节流转换为字符流，它使用指定的字符编码表读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集，实现的是解码过程；

7.3 标准输出输出流：

System.in:标准输入流，返回的是InputStream类型的实例；

System.out:标准输出流，返回的是PrintStream类的实例；

7.4 操作引用数据类型的流：

ObjectInputStream:字节对象输入流，操作对象必须实现序列化；

ObjectOutputStream:字节对象输出流，操作对象必须实现序列化；

理解：ObjectInputStream和ObjectOutputStream用于存储和读取对象的处理流，强大之处在于可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。

8. 序列化和反序列化

8.1 对象的序列化机制：

对象的序列化机制允许把内存中的Java对象转化成与平台无关的二进制流，从而允许吧这种二进制流持久地保存在磁盘上，或通过网络将这中二进制流传输到另一个网络节点，当其它程序获取了这种二进制流，就可以恢复成原来的Java对象。序列化是RMI(远程方法调用)过程的参数和返回都必须实现的机制，而RMI是JavaEE的基础，因此序列化机制是JavaEE平台的基础。

优点:可以将任何实现了Serializable接口的对象转换成字节数据，使其在保存和传输时可被还原。

可是实现序列化对象的类和类中的属性需要实现的接口：Serializable、Externalizable,实现其中一个即可；

注意：实现Serializable接口的类需要定义一个表示序列化版本标识的静态变量；

private static final long serialVersionUID;若没有则值在java运行时环境会根据类的内部细节自动生成，源代码修改后该值可能会变化，建议显示声明，主要是为了确保不同版本之间的兼容性；

ObjectInputStream和ObjectOutputStream不可序列化static和transient修饰的成员变量；

8.2序列化和反序列化概念：

序列化：用ObjectOutputStream类将一个java对象写入到IO流中；

反序列化：用ObjectInputStream类从IO流中恢复该java对象；

9.实例：

9.1 实现非文本文件的复制操作：

package com.test;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
 class copyFile{
   public static void copyFile(File src,File dst){
      FileInputStream fis = null;
      FileOutputStream fos = null;                
      BufferedInputStream bis = null;   
      BufferedOutputStream bos = null;  
      try{
         fis = new FileInputStream(src);    
         fos = new FileOutputStream(dst);                
         bis = new BufferedInputStream(fis);   //通过输入缓冲流包装文件输入流
         bos = new BufferedOutputStream(fos);  //通过输出缓冲流包装文件输出流
         int data=0;
         while((data=bis.read())!=-1){
            bos.write(data);
            bos.flush();
         }     
      }catch(Exception e){
         e.printStackTrace();
      }
      if(bos!=null){
         try {
            bos.close();
         } catch (IOException e) {
// TODO Auto-generated catch block
            e.printStackTrace();
         }  
      }
      if(bis!=null){
         try {
            bis.close();
         } catch (IOException e) {
// TODO Auto-generated catch block
            e.printStackTrace();
         }
      }           
   }
}
public class ceshiDemo {
   public static void main(String[] args) { 
         copyFile.copyFile(new File("D:/001.docx"), new File("D:/002.docx"));
   }
}
9.2实现文本文件的复制：
package com.test;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 class copyFile{
   public static void copyFile(File src,File dst){
      FileReader fr = null;
      FileWriter fw = null;                
      BufferedReader br = null;   
      BufferedWriter bw = null;  
      try{
         fr = new FileReader(src);
         fw = new FileWriter(dst);                
         br = new BufferedReader(fr);   
         bw = new BufferedWriter(fw);  
         String len = null;
         while((len = br.readLine())!=null){
            bw.write(len);   //一次写一行
            bw.newLine();   //写完一行后要换行
            bw.flush();     //强制清除缓冲区，将缓冲区中的数据写入到输出流对应的文件
         }     
      }catch(Exception e){
         e.printStackTrace();
      }
      if(bw!=null){
         try {
            bw.close();
         } catch (IOException e) {
// TODO Auto-generated catch block
            e.printStackTrace();
         }  
      }
      if(br!=null){
         try {
            br.close();
         } catch (IOException e) {
// TODO Auto-generated catch block
            e.printStackTrace();
         }
      }           
   }
}
public class ceshiDemo {
   public static void main(String[] args) { 
         copyFile.copyFile(new File("D:/001.txt"), new File("D:/002.txt"));
   }
}
9.3序列化与反序列化
 package com.test;
import java.io.*;
import java.util.*;
/*
要实现序列化的类：
  1.要求此类是可序列化的，实现Serializable接口;
  2.要求类的属性同样实现Serializable接口；
  3.需要加版本序列号,private static final long serialVersionUID = 112355225555l；
  4.不能序列化static和transient修饰的成员变量
 * */
class Student implements Serializable{
   private static final long serialVersionUID = 112355225555l;
   private String name;
   private int age;
   public Student(String name, int age) {
      super();
      this.name = name;
      this.age = age;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
}
public class Demo {
   public static void main(String[] args) throws IOException{ 
//对象的序列化过程，将内存中的对象通过ObjectOutputStream转换成2二进制流，存储在硬盘文件中
     Student stu = new Student("zhang",30);
     ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\\001.txt"));
     oos.writeObject(stu);                                //将对象写入到文件，成为序列化
     oos.close();
       ObjectInputStream iis = new ObjectInputStream(new FileInputStream("d:\\001.txt"));
       try {
      Student stu1=(Student)iis.readObject();                  //将对象从文件中读出来，成为反序列化；
      System.out.println(stu1.getName()+"->"+stu1.getAge());
   } catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
      e.printStackTrace();
   }
   }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。