I/O流的学习（三）---其他流

1.内存操作流

适用于临时存储文件

内存操作输入流:byteArrayInputStream
ByteArrayInputStream(byte[] buf) 

内存操作输出流: byteArrayOutputStream
构造方法:ByteArrayOutputStream() 

内存操作流:一个程序结束后,那么这些程序的变量,就会从内存消失(马上消失的这些数据进行读取写入)

public class ByteStreamDemo {

	public static void main(String[] args) throws IOException {
		
		//创建内存操作输出流对象
		ByteArrayOutputStream baos = new ByteArrayOutputStream() ;
		for(int x = 0 ; x <10 ; x ++) {
			baos.write(("hello"+x).getBytes());
			
		}
		//释放资源
		/**
		 * 源码:
		 *  public void close() throws IOException {
		 *  }
		 */
		//baos.close(); 该流不需要关闭
		
		//从内存中将内从中的数据显到控制台上
		//public byte[] toByteArray():构造一个字符串
		byte[] bys = baos.toByteArray() ;
		
		//创建内存操作输入流对象
		ByteArrayInputStream bais = new ByteArrayInputStream(bys) ;
		
		//一次读取一个字节
		int by = 0 ;
		while((by=bais.read())!=-1) {
			System.out.print((char)by);
		}
                //bais.close();该流不需要关闭
	}
}

2.数据流

针对Java基本类型的数据进行读写操作

数据输入流:DataInputStream

数据输出流:DataOutputStream 

public class DataStream {

	public static void main(String[] args) throws Exception {
		
//		write() ;
		read() ;
	}

	
	//读
	private static void read() throws Exception {
		DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt")) ;
		
		//读
		int i = dis.readInt() ;
		short s = dis.readShort() ;
		byte b = dis.readByte() ;
		double d = dis.readDouble() ;
		float f = dis.readFloat();
		boolean flag = dis.readBoolean() ;
		char ch = dis.readChar() ;
		
		dis.close();
		
		System.out.println(i);
		System.out.println(s);
		System.out.println(b);
		System.out.println(d);
		System.out.println(f);
		System.out.println(flag);
		System.out.println(ch);
	
	}


	//写
	private static void write() throws Exception {
		
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt")) ;
		
		//给流中写入数据
		dos.writeInt(10); 
		dos.writeShort(100);
		dos.writeByte(120);
		dos.writeDouble(13.34);
		dos.writeFloat(12.56F);
		dos.writeBoolean(true);
		dos.writeChar('a');
		
		//关闭资源
		dos.close();
	}
}

3.打印流

字符打印流(针对文本进行操作:PrintWriter)
字节打印流(printStream 和标准输出流有关系 System.out;)  

PrintWriter:属于输出流
1)只能写数据(只能针对目的地文件进行操作),不能读数据(不能针对源文件进行操作)
2)可以针对文件直接进行操作
如果一个类中的构造方法里面有File对象或者String类型数据,这个类可以对文本文件直接操作
FileInputStream
FileOutputStream
FileWriter
FileReader..
PrintWriter
3)自动刷新功能::PrintWriter(OutputStream out/Writer out,boolean autoflush);第二个参数如果是true 表示启动自动刷新功能

4)打印的方法:print(XXX x)/println(XXX  xx)

public class PrintWriterDemo {

	public static void main(String[] args) throws IOException {
		
		//创建一个字符打印流对象
		PrintWriter pw = new PrintWriter(new FileWriter("pw.txt")) ;
		
		//写数据
		/*pw.write("hello");
		pw.write("world");
		pw.write("java");*/
		
		pw.println("hello");//本身自动换行并且向pw.txt文件打印内容
		
		pw.flush(); //本身在构造的时候,就可以启动自动刷新
		
		//关闭流
		pw.close();
	}
}

输出一个文本文件,启动自动刷新功能

public class PrintWriterDemo2 {
	
	public static void main(String[] args) throws IOException {
		
		//创建一个字符打印流对象,启动自动刷新
		PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true) ;
		
		//加入换行
		pw.println("hello"); 
		pw.println("world"); 
		pw.println("java");
		
		//关闭
		pw.close();
	}
}

需求：复制文件

源文件:StringDemo.java --->BufferedReader

目的文件:Copy.java   ----->PrintWriter

public class CopyFileDemo {

	public static void main(String[] args) throws IOException {
		
		//封装文件
		BufferedReader br = new BufferedReader(new FileReader("StringDemo.java")) ;
		PrintWriter pw = new PrintWriter(new FileWriter("Copy.java",true)) ;
		
		//一次读取一行
		String line = null ;
		while((line=br.readLine())!=null) {
			//向打印输出内容
			pw.println(line);
			
		}
		
		//释放资源
		pw.close();
		br.close();
	}
}

4.标准的输入输出流

InputStream in = System.in 
PrintStream out = Syste.out ;

jdk5以后,Java--->Scanner(InputStream in)

键盘录入
1)Scanner

2)BufferedReader里面包装字符转换输入流,包装System.in

public class SystemInDemo {
	
	public static void main(String[] args) throws IOException {
		
		//标准输入流
		//分布走
		//创建输入流对象
		/*InputStream in = System.in ;
		
		//使用这个类最终可不可实现一次读取一行?readLine()
		//想要实现一次读取一行,使用BufferedReader
		//构造BufferedReader流对象
		//BufferedReader br = new BufferedReader(in) ;  //不能直接将字节流使用BufferedReader进行包装
		//构造一个字符转换输入流对象
		InputStreamReader isr = new InputStreamReader(in) ;
		BufferedReader br = new BufferedReader(isr) ;*/
		
		//另一种键盘录入的方式:使用流的方式
		//Java的装饰者模式
		BufferedReader br = new BufferedReader(
				new InputStreamReader(
						System.in)) ;
		
		System.out.println("请输入一个字符串:");
		String line = br.readLine() ;
		System.out.println("您输入的字符串是:"+line);
		
		System.out.println("请输入一个整数:");
		String str = br.readLine() ;
		
		int num = Integer.parseInt(str) ;
		System.out.println("输入的整数是:"+num);
	}
}

标准输出流
PrintStream ps = System.out ; 

使用BufferedWriter 去包装System.out

public class SystemOutDemo {

	public static void main(String[] args) throws IOException {
		System.out.println("我爱高圆圆");
		
		System.out.println("-------------");
		PrintStream ps = System.out ;
		//PrintStream的功能
		//public void println(String x)
		ps.println("我爱高圆圆");
		
		ps.println();
		//ps.print() ;没有该功能
		System.out.println("---------------------------");
		
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out)) ;
		
		bw.write("hello");
		bw.newLine();
		bw.write("world");
		bw.newLine();
		bw.write("java");
		bw.newLine();
		bw.flush();
		
		bw.close();
	}
}

5.合并流

SequenceInputStream 表示其他输入流的逻辑串联(合并流)

构造方法
public SequenceInputStream(InputStream s1, InputStream s2)
复制文件
a.txt----->b.txt
c.txt----->d.txt

现在的需求:
a.txt+b.txt--->c.txt

StringDemo.java+SystemInDemo.java---->Copy.java

public class SequenceInputStreamDemo {
	
	public static void main(String[] args) throws IOException {
		
		//封装源文件
		InputStream in1 = new FileInputStream("StringDemo.java") ;
		InputStream in2 = new FileInputStream("SystemInDemo.java") ;
		
		//创建合并流对象
		SequenceInputStream sis = new SequenceInputStream(in1, in2) ;
		//创建一个字节缓冲输入流对象
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("Copy.java"));
		
		//原来怎么读写,现在依然这样读写
		byte[] bys = new byte[1024] ;
		int len = 0 ;
		while((len=sis.read(bys))!=-1) {
			bos.write(bys, 0, len);
			bos.flush(); //读图片文件的时候
		}
		
		//关闭资源
		sis.close();
		bos.close();
		
	}
}

sequenceInputStream另一种构造方式
public SequenceInputStream(Enumeration e) 

将多个输入流对象进行合并

a.txt+b.txt+c.txt--->d.txt

public class SequenceInputStreamDemo2 {
	
	public static void main(String[] args) throws IOException {
		//StringDemo.java+SystemInDemo.java+PrintWriterDemo.java--->Copy.java文件中
		
		//定义一个集合Vector
		Vector<InputStream> v  = new Vector<InputStream>() ;
		//使用InputStream封装文件
		InputStream s1 = new FileInputStream("StringDemo.java") ;
		InputStream s2 = new FileInputStream("SystemInDemo.java") ;
		InputStream s3 = new FileInputStream("PrintWriterDemo.java") ;
		
		//将流对象添加到集合中
		v.add(s1) ;
		v.add(s2) ;
		v.add(s3) ;
		
		//特有功能
		Enumeration<InputStream> en = v.elements() ;
		
		//创建合并输入流对象
		SequenceInputStream sis = new SequenceInputStream(en) ;
		//创建字节缓冲输出流对象
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Copy.java")) ;
		
		//一次读取一个字节数组
		byte[] bys = new byte[1024] ;
		int len = 0 ;
		while((len=sis.read(bys))!=-1) {
			bos.write(bys, 0, len);
			bos.flush();
		}
		
		//关闭资源
		bos.close();
		sis.close();
	}
}