Java--IO流(其他流)

最新推荐文章于 2024-07-08 22:39:05 发布

MinggeQingchun

最新推荐文章于 2024-07-08 22:39:05 发布

阅读量507

点赞数 1

分类专栏： JavaSE 文章标签： IO流其他流

本文链接：https://blog.csdn.net/MinggeQingchun/article/details/60962993

版权

JavaSE 专栏收录该内容

154 篇文章 38 订阅

订阅专栏

一、序列流(SequenceInputStream)

序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读,

读完一个之后继续读第二个, 以此类推

使用方式

整合两个: SequenceInputStream(InputStream, InputStream)

整合多个: SequenceInputStream(Enumeration)

二、内存输出流(ByteArrayOutputStream)

该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取出所有数据

使用方式

创建对象: new ByteArrayOutputStream()

写出数据: write(int), write(byte[])

获取数据: toByteArray()

三、对象操作流(ObjectOutputStream,ObjectInputStream)

该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是执行了序列化和反序列化的操作.

使用方式

写出: new ObjectOutputStream(OutputStream), writeObject()

读取: new ObjectInputStream(InputStream), readObject()

四、标准输入输出流

System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据

System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据

修改标准输入输出流

修改输入流: System.setIn(InputStream)

修改输出流: System.setOut(PrintStream)

五、随机访问流

RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。

支持对随机访问文件的读取和写入。

read(),write(),seek()

六、数据输入输出流

DataInputStream, DataOutputStream可以按照基本数据类型大小读写数据

例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照Long类型读取, 一次读取8个字节

七、Properties

Properties 类表示了一个持久的属性集。

Properties 可保存在流中或从流中加载。

属性列表中每个键及其对应值都是一个字符串。

package com.lin.otherio;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Properties;
import java.util.Vector;

public class OtherIO {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		/*
		 * 一、序列流(SequenceInputStream)
			  序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 
			  读完一个之后继续读第二个, 以此类推.
			使用方式
			  整合两个: SequenceInputStream(InputStream, InputStream)
			  整合多个: SequenceInputStream(Enumeration)
		   二、内存输出流(ByteArrayOutputStream)
			  该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取出所有数据
			使用方式
				创建对象: new ByteArrayOutputStream()
				写出数据: write(int), write(byte[])
				获取数据: toByteArray()
		   三、对象操作流(ObjectOutputStream,ObjectInputStream)
		      该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是执行了序列化和反序列化的操作.
			使用方式
				写出: new ObjectOutputStream(OutputStream), writeObject()
				读取: new ObjectInputStream(InputStream), readObject()
		   四、标准输入输出流
				System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据
				System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据
 			  修改标准输入输出流
				修改输入流: System.setIn(InputStream)
				修改输出流: System.setOut(PrintStream)
		   五、随机访问流
		      RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。
			  支持对随机访问文件的读取和写入。
			  read(),write(),seek()
		   六、数据输入输出流
				DataInputStream, DataOutputStream可以按照基本数据类型大小读写数据
				例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照Long类型读取, 一次读取8个字节
		   七、Properties
				Properties 类表示了一个持久的属性集。
				Properties 可保存在流中或从流中加载。
				属性列表中每个键及其对应值都是一个字符串。
		 * */
		sequenceStream();//SequenceInputStream序列流(仅有两个输入流)
		sequenceStreamMore();//SequenceInputStream序列流(多个输入流)
		memoryStream();//内存输出流
		objectOutStream();//对象操作流
		objectInStream();//对象操作流
		objectStream();//对象操作流
		printStream();//打印流
//		systemIn();
//		systemInAndOut();
//		keyBorder();//键盘录入
		randomStream();//随机访问流(既读又可写)
		dataStream();
		properties1();
		properties2();
	}

	private static void properties2() throws IOException, IOException {
		System.out.println("================Properties配置文件================");
		Properties p = new Properties();
		p.load(new FileInputStream("config.properties"));
		p.setProperty("tel", "18898568956");
		p.store(new FileOutputStream("config.properties"), null);
		System.out.println(p);
	}

	private static void properties1() {
		System.out.println("================Properties================");
		Properties p = new Properties();
//		p.put("abc", 123);
//		System.out.println(p);
		p.setProperty("name", "三");
		p.setProperty("tel", "13233888956");
		Enumeration<String> e = (Enumeration<String>) p.propertyNames();
		while(e.hasMoreElements()){
			String key = e.nextElement();
			System.out.println(key + "--" + p.getProperty(key));
		}
	}

	private static void dataStream() throws IOException {
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("a.txt"));
		dos.writeInt(997);
		dos.writeInt(998);
		dos.writeInt(999);
		dos.close();
		
		DataInputStream dis = new DataInputStream(new FileInputStream("a.txt"));
		System.out.println(dis.readInt() + " " + dis.readInt() + " " + dis.readInt() + " ");
	}

	private static void randomStream() throws IOException {
		System.out.println("================随机访问流================");
		RandomAccessFile ra = new RandomAccessFile("a.txt", "rw");
		ra.write(97);
		System.out.println(ra.read());
		ra.seek(10);
		ra.write(98);
		ra.close();
	}

	private static void keyBorder() throws IOException {
		System.out.println("================键盘录入================");
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		String line = bf.readLine();
		System.out.println(line);
		bf.close();
	}

	private static void systemInAndOut() throws IOException {
		System.out.println("================标准输入输出================");
		System.setIn(new FileInputStream("a.txt"));
		System.setOut(new PrintStream("b.txt"));
		
		InputStream is = System.in;
		PrintStream ps = System.out;
		int b;
		while((b = is.read()) != -1){
			ps.write(b);
		}
		is.close();
		ps.close();
	}

	private static void systemIn() throws IOException {
		System.out.println("================标准输入流================");
		InputStream is = System.in;
		int x = is.read();
		System.out.println(x);
		is.close();
	}

	private static void printStream() throws FileNotFoundException {
		System.out.println("================打印流================");
		PrintStream ps = System.out;//打印字节流
		ps.println(97);					//其实底层用的是Integer.toString(x),将x转换为数字字符串打印
		ps.println("xxx");
		ps.println(new Person("张三", 23));
		Person p = null;
		ps.println(p);					//如果是null,就返回null,如果不是null,就调用对象的toString()
		
		PrintWriter pw = new PrintWriter(new FileOutputStream("g.txt"), true);//打印字符流
		pw.write(97);
		pw.print("大家好");
		pw.println("你好");				//自动刷出,只针对的是println方法
		pw.close();
	}

	private static void objectStream() throws IOException, IOException, ClassNotFoundException {
		System.out.println("================对象操作流================");
		Person p1 = new Person("张三",18);
		Person p2 = new Person("李四",16);
		Person p3 = new Person("王五",18);
		Person p4 = new Person("赵六",16);
		ArrayList<Person> list = new ArrayList<>();
		list.add(p1);
		list.add(p2);
		list.add(p3);
		list.add(p4);
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("b.txt"));
		oos.writeObject(list);
		oos.close();
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("b.txt"));
		ArrayList<Person> pList = (ArrayList)ois.readObject();
		for (Person person : pList) {
			System.out.println(person);
		}
	}

	private static void objectInStream() throws IOException, ClassNotFoundException {
		System.out.println("================对象操作流读取================");
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("c.txt"));
		Person p1 = (Person)ois.readObject();
		Person p2 = (Person)ois.readObject();
//		Person p3 = (Person)ois.readObject();//java.io.EOFException 文件读取到末尾了出现
		System.out.println(p1);
		System.out.println(p2);
	}

	private static void objectOutStream() throws IOException {
		Person p1 = new Person("张三",18);
		Person p2 = new Person("李四",16);
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("c.txt"));
		oos.writeObject(p1);
		oos.writeObject(p2);
		oos.close();
	}

	private static void memoryStream() throws IOException {
		System.out.println("================内存输出流================");
		FileInputStream fi2 = new FileInputStream("b.txt");
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		int b;
		while((b = fi2.read()) != -1){
			bos.write(b);
		}
//		byte[] by = bos.toByteArray();
//		System.out.println(new String(by));
		System.out.println(bos);
		fi2.close();
	}

	public static void sequenceStreamMore() throws FileNotFoundException, IOException {
		System.out.println("================序列流多个输入流================");
		FileInputStream fi1 = new FileInputStream("a.txt");
		FileInputStream fi2 = new FileInputStream("b.txt");
		FileInputStream fi3 = new FileInputStream("c.txt");
		
		Vector<FileInputStream> v = new Vector<>();
		v.add(fi1);
		v.add(fi2);
		v.add(fi3);
		
		Enumeration<FileInputStream> en = v.elements();
		SequenceInputStream sis = new SequenceInputStream(en);
		FileOutputStream fo = new FileOutputStream("bc.txt");
		int b;
		while((b = sis.read()) != -1){
			fo.write(b);
		}
		sis.close();
		fo.close();
	}

	public static void sequenceStream() throws FileNotFoundException, IOException {
		System.out.println("================序列流两个输入流================");
		FileInputStream fi1 = new FileInputStream("b.txt");
		FileInputStream fi2 = new FileInputStream("c.txt");
		SequenceInputStream si = new SequenceInputStream(fi1, fi2);
		FileOutputStream fo = new FileOutputStream("bc.txt");
		int b;
		while((b = si.read()) != -1){
			fo.write(b);
		}
		si.close();
		fo.close();
	}
}