JAVA 内存操作流

JAVA 通过 OutputStream InputStream 实现文件复制功能

package org.iodemo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class Copy {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception { //所有异常抛出
		// TODO Auto-generated method stub
		if (args.length != 2){ //参数不是两个
			System.out.println("输入的参数不正确");
			System.exit(1); //系统退出
		}
		
		if (args[0].equals(args[1])){
			System.out.println("输入的是同一个文件");
			System.exit(1); //系统退出
		}
		
		
		File file1 = new File(args[0]); //找到第一个文件的File 对象
		if (file1.exists()){
			File file2 = new File(args[1]); // 找到目标文件路径
			InputStream input = new FileInputStream(file1); //输入流
			OutputStream output = new FileOutputStream(file2); //输出流
			int temp = 0; 定义一个整数表示接收的内容
			while ((temp = input.read()) != -1 ){ //表示还有内容可以继续读
				output.write(temp); //写入数据
			}
                        System.out.println("文件复制成功");
                       input.close();
			output.close();
		}else{
			System.out.println("文件不存在");
		}
	}

}

内存操作流

在之前讲解FileInputStream 和 FileOutputStream 的时候所有的操作的目标是文件，那么如果现在假设有一些临时的信息要求通过IO操作的话，那么如果将这些临时的信息保存在文件之中则肯定很不合理，因为操作的最后还要把文件再删除掉，所以此时的IO中就提供了一个内存的操作流，通过内存操作流输入和输出的目标是内存。

使用ByteArrayOutputStream 和 ByteArrayInputStream 完成内存的操作流

在内存操作流中所有的输入和输出都是以内存为操作的源头

ByteArrayOutputStream 是用于从内存向程序输出的

ByteArrayInputStream 是用于从程序向内存写入的

ByteArrayInputStream 的构造方法： public ByteArrayInputStream(byte[] buf)

表示把内容向内存之中写入

ByteArrayOutputStream来讲，其基本的作用就是与OutputStream一样，一个个的读取数据。

范例：使用内存操作流，完成一个字符串小写小母变为大写字每的操作

package org.bytearrarydemo;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;

public class ByteArrayDemo01 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str ="helloworld"; //定义字符串，全部由小写字母组成
		ByteArrayInputStream input = new ByteArrayInputStream(str.getBytes());  //内存输入流 将内容存在内存之中
		ByteArrayOutputStream output = new ByteArrayOutputStream();		//内存输出流
		int temp = 0; 
		while ((temp = input.read()) != -1){ //依次读取
			char c = (char)temp; //接收字符
			output.write(Character.toUpperCase(c)); //输出
		}
		String stra = output.toString(); //取出内存输出的内容
		System.out.println(stra);
	}

}

内存操作流现在在Java SE阶段是感觉不出有什么作用，但是在学习Java WEB 中的AJAX技术的时候，会结合XML解析和JavaScript、AJAX完成一些动态效果的使用

String newStr = output.toString(); //取出内存输出的内容

管道流

管道流就是进行两个线程间通讯的。使用PipedOutputStream 和 PipedInputStream 两个类完成。但是，这两个类使用的时候基本上都跟OutputStream 和InputStream类似，唯一区别的的是在于连接管道的操作上。

public void connect(PipedInputStream snk) throws IOException

范例：进行管道流的操作

package org.pipedinputdemo;

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

class Send implements Runnable{ //发送数据的线程
	private PipedOutputStream out = null;
	
	public Send(){
		this.out = new PipedOutputStream();
	}
	
	public PipedOutputStream getPipedOutputStream(){
		return this.out;
	}
	
	public void run(){
		String str = "Hello World"; //要发送的数据
		try {
			this.out.write(str.getBytes()); //发送
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			this.out.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
}

class Recives implements Runnable{ //接收数据的线程
	
	private PipedInputStream input = null;
	
	public Recives(){
		this.input = new PipedInputStream();
	}
	
	public PipedInputStream getPipedInputStream(){
		return this.input;
	}
	
	public void run(){
		byte b[] = new byte[1024]; //接收内容
		int len = 0;
		try {
			len = input.read(b); //内容读取
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			input.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(new String(b,0,len));
	}
}

public class PipedInputDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		Send send = new Send();
		Recives rec = new Recives();
		send.getPipedOutputStream().connect(rec.getPipedInputStream()); //进行管道连接
		new Thread(send).start(); //启动线程
		new Thread(rec).start(); //启动线程
	}

}

打印流

使用OutputStream 可以完成数据的输出，但是现在如果有一个float 型数据好输出吗？

也就是说虽然现在提供了输出流的操作类，但是这个类本身的输出的支持功能并不是十分的强大，所以，如果现在要想进行更方便的输出操作，则可以使用打印流。

打印流分两种：PrintStream、PrintWriter

观察打印流的定义：

public class PrintStream

extends FilterOutputstream

implements Appendable,Closeable

PrintStream 是 OutputStream 的子类，继续观察其构造方法

public PrintStream(OutputStream out)

在此就去中要接收OutputStream 子类的引用

实际上PrintStream 属于装饰。也就是说根据实例化 PrintStream 类对象的不同，输出的位置也不同

package org.printoutputdemo;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

public class PrintOutputDemo {

	/**
	 * @param args
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) throws FileNotFoundException {
		// TODO Auto-generated method stub
		File file = new File ("D:"+File.separator+"demo.txt");
		PrintStream output = new PrintStream(new FileOutputStream(file));
		output.print("Hello");
		output.print(" World");
		output.println("abco");
		output.println(1.0);
		output.close();
	}

}

得出结论，使用打印流输出最为方便，所以建议以后在输出的时候就使用打印流完成

在JDK1.5之后对打印流进行了更新，可以使用格式化输出

public PrintStream printf(String format,Object .... args)

可以设置格式和多个参数

package org.printoutputdemo;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

public class PrintStreamDemo01 {

	/**
	 * @param args
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) throws FileNotFoundException {
		// TODO Auto-generated method stub
		File file = new File ("D:"+File.separator+"demo.txt");
		PrintStream output = new PrintStream(new FileOutputStream(file));
		String name = "张三";
		int age = 20;
		double score =  99.1;
		char sex ='M';
		output.printf("姓名:%s 年龄:%d 分数:%5.2f 性别:%c",name,age,score,sex);
		output.close();
	}

}

在打印流中一定要始终记住以下的原则：根据实例化其子类的不同，完成的打印输出也不同