Java从入门到删库跑路——文件IO操作学习（2）

三.流类(接1)

1.管道流

管道流主要用于连接两个线程间的通信。管道流也分为字节流( PipedInputStream、PipedOutputStream )与字符流( PipedReader、PipedWriter )两种类型.

一个 PipedInputStream对象必须和一个PipedOutputStream 对象进行连接而产生一个通信管道,PipedOutputStream可以向管道中写入数据，PipedInputStream可以从管道中读取PipedOutputStream写入的数据。如图所示，这两个类主要用来完成线程之间的通信，一个线程的PipedInputStream对象能够从另外一个线程的PipedOutputStream对象中读取数据。

package dataStructure;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipeStreamDemo {
	public static void main(String[] args) {
		try {
			
			Sender sender =new Sender();
			Receiver receiver =new Receiver();
			
			PipedOutputStream out =sender.getOutputStream();//写入
			PipedInputStream in = receiver.getInputStream();//读出
			
			out.connect(in);//将输出发送到输入
			sender.start();
			receiver.start();
			
		} catch (IOException e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
	}

}

class Sender extends Thread{
	private PipedOutputStream out =new PipedOutputStream();
	public PipedOutputStream getOutputStream() {
		return out;
	}
	public void run() {
		String s =new String("收到 ,gg");
		try {
			out.write(s.getBytes());
			out.close();
		} catch (IOException e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
	}
}

class Receiver extends Thread{
	private PipedInputStream in =new PipedInputStream();
	public PipedInputStream getInputStream() {
		return in;
	}
	public void run() {
		String s =null;
		byte[] buf=new byte[1024];
		try {
			int len =in.read(buf);
			s=new String(buf,0,len);
			System.out.println("有内鬼："+s);
			in.close();
		} catch (IOException e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
	}
}

 

2.ByteArrayInputStream与ByteArrayOutputStream

如果程序在运行的过程中要产生一些临时文件，可以采用虚拟文件方式实现，JDK中提供有ByteArrayInpultream和ByeArayOutputStream两个类可以实现类似于内存虚拟文件的功能。

 

3.System.in和System.out

为了支持标准输入输出设备，Java定义了两个特殊的流对象: System.in 和System.out。

System.in对应键盘,属于InputStream类型，程序使用System.in 可以读取从键盘上输入的数据。

System.out对应显示器，属于PrintStream 类型，PrintStream 是OutputStream 的一个子类，程序使用System.out可以将数据输出到显示器上。

键盘可以被当做一个特殊的输入流，显示器可以被当做一个特殊的输出流。

 

4.DatalnputStream与DataOutputStream

DataInputStream与DataOutputStream 提供了与平台无关的数据操作，通常会先通过DataOutputStream按照一定的格式输出，再通过DatalnputStream 按照一定格式读入。由于可以得到java 的各种基本类型甚至字符串，这样对得到的数据便可以方便地进行处理，这在通过协议传输的信息的网络上是非常适用的。

package dataStructure;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataStreamDemo {
	public static void main(String[] args) throws IOException {
		
		//(1)写入端构造一个DataOutputStream,并按照一定的格式写入数据。
		
		//将数据写入某一种载体
		DataOutputStream out =new DataOutputStream(new FileOutputStream("demo.txt"));

		//价格
		double[] prices = {1.99 ,2.99,3.99};
		//数目
		int[] units= {10,20,30};
		//产品名称
		String[] descs = {"a","b","c"};
		
		//向数据过滤流写入主要类型
		for (int i = 0; i < prices.length; i++) {
			
			//写入数据，用tab隔开
			out.writeDouble(prices[i]);
			out.writeChar('\t');
			
			out.writeInt(units[i]);;
			out.writeChar('\t');
			
			out.writeChars(descs[i]);;
			out.writeChar('\n');	//行尾是换行符		
		}
		out.close();
		
		
		//(2)计价程序读入并在标准输出中输出。
		
		//读出数据
		DataInputStream in =new DataInputStream(new FileInputStream("demo.txt"));
		
		double price;
		int unit;
		StringBuffer desc;
		double total =0.0;
		
		try {
			//当文本被全部读出以后会抛出EOFException异常，中断循环
			while (true) {
				price = in.readDouble();
				//跳过tab
				in.readChar();
				unit =in.readInt();
				in.readChar();
				char chr;
				desc =new StringBuffer();
				
				while ((chr = in.readChar())!='\n') {
					desc.append(chr);
				}
				System.out.println("单子： "+"名称"+desc+",\t 数量："+unit+",\t 价格："+price);
				total =total+unit*price;
				
			}
		} catch (EOFException e) {
			// TODO: handle exception
			System.out.println("\n 共需"+total+"元");
		}
		in.close();
	}
	
}

 

5.合并流

采用SequencelnputStream类，可以实现两个文件的合并操作。

package dataStructure;

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

public class SequenceDemo {

	public static void main(String[] args) throws IOException{
		//声明两个文件读入流
		FileInputStream in1 =null,in2= null;
		
		//声明一个序列流
		SequenceInputStream s=null;
		
		FileOutputStream out =null;
		
		try {
			File inputFile1 =new File("D:\\1.txt");
			File inputFile2 =new File("D:\\2.txt");
			
			File outputFile =new File("D:\\12.txt");
			
			in1 =new FileInputStream(inputFile1);
			in2 =new FileInputStream(inputFile2);
			
			s=new SequenceInputStream(in1,in2);
			out= new FileOutputStream(outputFile);
			
			int c;
			while ((c= s.read())!=-1) {
				out.write(c);
			}
			
			in1.close();
			in2.close();
			s.close();
			out.close();
			
			System.out.println("ok...");
			
		} catch (IOException e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		finally {
			if (in1 !=null) {
				try {
					in1.close();
				} catch (IOException e) {
					// TODO: handle exception
					
				}
			}
			if (in2 !=null) {
				try {
					in2.close();
				} catch (IOException e) {
					// TODO: handle exception
					
				}
			}
			if (s !=null) {
				try {
					s.close();
				} catch (IOException e) {
					// TODO: handle exception
					
				}
			}
			if (out !=null) {
				try {
					out.close();
				} catch (IOException e) {
					// TODO: handle exception
					
				}
			}
		}
	}
}