Java——IO流(四)一些不常见的IO流(内存输出流,随机访问流,序列流等等)

本文详细介绍了Java中不常见的IO流类型，包括序列流用于整合字节输入流，内存输出流实现内存缓冲区写入，对象操作流执行序列化和反序列化，打印流方便输出对象并自动换行，标准输入输出流的修改，以及键盘录入的两种方式。还特别讲解了RandomAccessFile，它结合了输入输出流功能，支持文件的随机访问读写。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.序列流：可以把多个字节输入流整合成一个，从序列流中读取数据时，将从被整合的第一个流开始读，读完一个之后继续第二个
        SequenceInputStream
2.内存输出流：可以向内存中写数据，把内存当作一个缓冲区，写出之后可以一次性获取所有数据
        使用方式：(1)创建对象 new ByteArrayOutputStream()
                (2)写出数据 write(int),write(byte[])
                (3)获取数据 toByteArray()
3.对象操作流：可以将一个对象写出，或者读取一个对象到程序中，也就是执行了序列化和反序列化的操作
        序列化：将对象写到文件上
4.打印流:可以很方便的将对象的toString()结果输出，并且自动加上换行，而且可以使用自动刷出的模式
        System.out就是一个printStream，其默认向控制台输出信息
        使用方式：
                打印 print(),println()
                自动刷出:printWriter(OutputStream out,boolean autoFlush,String encoding)
                打印流只操作数据目的
5.标准的输入输出流
        修改标准输入输出流,如果不关联文件，则可以不用关流
6.两种方式实现键盘录入
        (1)BufferedReader的readline()方法
        (2)Scanner
7.随机访问流
        RandomAccessFile:不属于流，是object类的子类，但融合了InputStream和OutputStream的功能支持随机访问文件的读取和写入。
            read(),write(),seek()
8.数据输入输出流:DataInputStream和DateOutputStream可以按照基本数据类型大小读写数据

package pra_18;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintStream;
import java.io.RandomAccessFile;
import java.io.SequenceInputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Scanner;
import java.util.Vector;

public class J_36 {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		
		//1.序列流整合两个的情况
		FileInputStream fis13=new FileInputStream("a.txt");
		FileInputStream fis23=new FileInputStream("b.txt");
		SequenceInputStream sis=new SequenceInputStream(fis13,fis23);
		FileOutputStream fos=new FileOutputStream("abba.txt");
		int b;
		while((b=sis.read())!=-1){
			fos.write(b);
		}
		sis.close();	//会将构造方法中传入的流对象关闭
		fos.close();
		
			//序列流整合多个的情况
		FileInputStream fis1=new FileInputStream("a.txt");
		FileInputStream fis2=new FileInputStream("b.txt");
		FileInputStream fis3=new FileInputStream("c.txt");
		Vector<FileInputStream> v=new Vector<>();		//创建集合对象
		v.add(fis1);									//将流对象存储进去
		v.add(fis2);
		v.add(fis3);
		Enumeration<FileInputStream> en=v.elements();
		SequenceInputStream sis2=new SequenceInputStream(en);	//将枚举的输入流整合成一个
		FileOutputStream fos4=new FileOutputStream("abcc.txt");
		int c;
		while((c=sis2.read())!=-1){
			fos4.write(c);
		}
		sis2.close();
		fos4.close();
		
		//2.内存输出流
		FileInputStream fis5=new FileInputStream("a.txt");
		ByteArrayOutputStream baos=new ByteArrayOutputStream();	//在内存中创建了可以增长的内存数组
		int d;
		while((d=fis5.read())!=-1){
			baos.write(d);				//将读取到的数据逐个写到内存中
		}
		byte[] arr=baos.toByteArray();	//将缓冲区的数据全部获取出来，并赋值给arr数组
		//System.out.println(baos.toString());		//直接将缓冲区的内容转换为了字符串
		System.out.println(new String(arr));
		fis5.close();
		
		//3.对象操作流
			//对象输出流，写对象，序列化
		Pe2 pe=new Pe2("aa",1);
		Pe2 pe2=new Pe2("bb",2);
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("ada.txt"));
		oos.writeObject(pe);	//对象需要序列化才能写出,需要实现Serializable的接口
		oos.writeObject(pe2);
		oos.close();
			//对象输出流，读对象，反序列化
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("ada.txt"));
		Pe2 pe3=(Pe2)ois.readObject();
		Pe2 pe4=(Pe2)ois.readObject();
		System.out.println(pe3);	//Pe2 [name=aa, age=1]
		System.out.println(pe4);	//Pe2 [name=bb, age=2]
			//对象操作流优化，将对象存储在集合中写出
		Pe2 pe5=new Pe2("cc",3);
		Pe2 pe6=new Pe2("dd",4);
		Pe2 pe7=new Pe2("ee",5);
		Pe2 pe8=new Pe2("ff",6);
		ArrayList<Pe2> al=new ArrayList<>();
		al.add(pe5);
		al.add(pe6);
		al.add(pe7);
		al.add(pe8);
		ObjectOutputStream oos2=new ObjectOutputStream(new FileOutputStream("ada2.txt"));
		oos2.writeObject(al);						//将集合对象一次写入
		oos2.close();
		ObjectInputStream ois2=new ObjectInputStream(new FileInputStream("ada2.txt"));	
		ArrayList<Pe2> al2=(ArrayList<Pe2>)ois2.readObject();		//将集合对象一次读取
		for (Pe2 pe22 : al2) {
			System.out.println(pe22);
		}
		ois2.close();
		
		//5.修改标准输入输出流拷贝图片
		System.setIn(new FileInputStream("5.jpg")); 	//改变标准输入流
		System.setOut(new PrintStream("5_06.jpg")); 		//改变标准输出流
		
		InputStream is=System.in;
		PrintStream ps=System.out;
		byte[] arr2=new byte[1024];
		int len;
		while((len=is.read())!=-1){
			ps.write(arr2,0,len);
		}
		is.close();
		ps.close();
		//6.BufferedReader实现键盘录入
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		String line=br.readLine();
		System.out.println(line);
		br.close();
		
		//7.随机访问流,可以通过seek()方法实现多线程下载
		RandomAccessFile raf=new RandomAccessFile("aaa.txt","rw");
		int x=raf.read();
		System.out.println(x);
		raf.seek(10);				//在指定位置设置指针
		raf.write(8);
		raf.close();
		
		//8.数据输入输出流
		DataOutputStream dos=new DataOutputStream(new FileOutputStream("a.txt"));
		dos.writeInt(1102);
		dos.writeInt(1103);
		dos.writeInt(1104);
		dos.close();
		
		DataInputStream dis=new DataInputStream(new FileInputStream("a.txt"));
		int r=dis.readInt();
		int t=dis.readInt();
		int y=dis.readInt();
		System.out.println(r+" "+t+" "+y);
		dis.close();
	}
}
class Pe2 implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;	//在报错时能尽快知道怎么回事
	private String name;
	private int age;
	public Pe2() {
		super();
		
	}
	public Pe2(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;
	}
	@Override
	public String toString() {
		return "Pe2 [name=" + name + ", age=" + age + "]";
	}
	
}