Java--IO流(其他流)

╰+哭是因爲堅強的太久メ 2023-10-17 11:29 9阅读 0赞

一、序列流(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();
    	}
    }