黑马程序员—其他流

序列流

SequenceInputStream
对多个流进行合并：SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

构造方法：
SequenceInputStream(InputStream s1, InputStream s2)
equenceInputStream(Enumeration<? extends InputStream> e)

示例代码：拼接3个文件

import java.io.*;
import java.util.*;
class SequenceDemo 
{
	public static void main(String[] args) throws IOException
	{

		Vector<FileInputStream> v = new Vector<FileInputStream>();
		v.add(new FileInputStream("c:\\1.txt"));
		v.add(new FileInputStream("c:\\2.txt"));
		v.add(new FileInputStream("c:\\3.txt"));
		Enumeration<FileInputStream> en = v.elements();
		SequenceInputStream sis = new SequenceInputStream(en);
		FileOutputStream fos = new FileOutputStream("c:\\4.txt");
		byte[] buf = new byte[1024];
		int len =0;                                                                                                    		while((len=sis.read(buf))!=-1)
		{
			fos.write(buf,0,len);
		}
		fos.close();
		sis.close();
	}
}

对象流

ObjectInputStream与ObjectOutputStream                                                                                                                                                                                                                                      被操作的对象需要实现Serializable （标记接口）;

import java.io.*;
class Person implements Serializable
{
	public static final long serialVersionUID = 42L;
	private String name;
	transient int age;
	static String country = "cn";
	Person(String name,int age,String country)
	{
		this.name = name;
		this.age = age;
		this.country = country;
	}
	public String toString()
	{
		return name+":"+age+":"+country;
	}
}

import java.io.*;

class ObjectStreamDemo 
{
	public static void main(String[] args) throws Exception
	{
		writeObj();
		readObj();
	}
	public static void readObj()throws Exception
	{
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
		Person p = (Person)ois.readObject();
		System.out.println(p);
		ois.close();                                                                                                   	}
	public static void writeObj()throws IOException
	{
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
		oos.writeObject(new Person("lisi",39,"cn"));
		oos.close();                                                                                                  	}
}

RandomAccessFile

随机访问文件，自身具备读写的方法。
通过skipBytes(int x),seek(int x)来达到随机访问。

该类不是算是IO体系中子类，而是直接继承自Object。
但是它是IO包中成员。因为它具备读和写功能。
内部封装了一个数组，而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。
其实完成读写的原理就是内部封装了字节输入流和输出流。
通过构造函数可以看出，该类只能操作文件。
而且操作文件还有模式：只读r，读写rw等。
如果模式为只读 r，不会创建文件，会去读取一个已存在文件，如果该文件不存在，则会出现异常。
如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

示例代码：

class RandomAccessFileDemo 
{
	public static void main(String[] args) throws IOException
	{
		//writeFile();
		//readFile();
	}
	public static void readFile()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","r");
		//调整对象中指针。
		//raf.seek(8*1);
		//跳过指定的字节数
		raf.skipBytes(8);
		byte[] buf = new byte[4];
		raf.read(buf);
		String name = new String(buf);
		int age = raf.readInt();
		System.out.println("name="+name);
		System.out.println("age="+age);
		raf.close();
	}
	public static void writeFile()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
		raf.seek(8*0);
		raf.write("周期".getBytes());
		raf.writeInt(103);
		raf.close();
	}
}

管道流

PipedInputStream和PipedOutputStream
输入输出可以直接进行连接，通过结合线程使用。
可通过构造方法或void connect(PipedOutputStream src)进行连接。

示例代码：

import java.io.*;

class Read implements Runnable
{
	private PipedInputStream in;
	Read(PipedInputStream in)
	{
		this.in = in;
	}
	public void run()
	{
		try
		{
			byte[] buf = new byte[1024];
			int len = in.read(buf);
			String s= new String(buf,0,len);
			System.out.println(s);
			in.close();
		}
		catch (IOException e)
		{
			throw new RuntimeException("管道读取流失败");
		}
	}
}
class Write implements Runnable
{
	private PipedOutputStream out;
	Write(PipedOutputStream out)
	{
		this.out = out;
	}
	public void run()
	{
		try
		{
			out.write("this is piped".getBytes());
			out.close();
		}
		catch (Exception e)
		{
			throw new RuntimeException("管道输出流失败");
		}
	}
}
class  PipedStreamDemo
{
	public static void main(String[] args) throws IOException
	{
		PipedInputStream in = new PipedInputStream();
		PipedOutputStream out = new PipedOutputStream();
		in.connect(out);
		Read r = new Read(in);
		Write w = new Write(out);
		new Thread(r).start();
		new Thread(w).start();
	}
}

操作基本数据类型

DataInputStream与DataOutputStream
可以用于直接操作基本数据类型的数据的流对象

示例代码：

import java.io.*;
class DataStreamDemo 
{
	public static void main(String[] args) throws IOException
	{
		writeData();
		readData();
	}
	public static void readData()throws IOException
	{
		DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
		int num = dis.readInt();
		boolean b = dis.readBoolean();
		double d = dis.readDouble();
		System.out.println("num="+num);
		System.out.println("b="+b);
		System.out.println("d="+d);
		dis.close();
	}
	public static void writeData()throws IOException
	{
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
		dos.writeInt(234);
		dos.writeBoolean(true);
		dos.writeDouble(9887.543);
		dos.close();
	}
}

操作字节数组

ByteArrayInputStream与ByteArrayOutputStream
用于操作字节数组的流对象。
ByteArrayInputStream ：在构造的时候，需要接收数据源。而且数据源是一个字节数组。
ByteArrayOutputStream：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组，这就是数据目的地。
因为这两个流对象都操作的数组，并没有使用系统资源，所以，不用进行close关闭。
流操作规律：
源设备： 键盘 System.in，硬盘 FileStream，内存 ArrayStream。
目的设备：控制台 System.out，硬盘FileStream，内存 ArrayStream。

示例代码：

import java.io.*;
class ByteArrayStream 
{
	public static void main(String[] args) 
	{
		ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFD".getBytes());
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		int by = 0;
		while((by=bis.read())!=-1)
		{
			bos.write(by);
		}
		System.out.println(bos.size());
		System.out.println(bos.toString());
	//	bos.writeTo(new FileOutputStream("a.txt"));
	}
}

操作字符数组CharArrayReader，CharArrayWrite与操作字符串StringReader ，StringWriter使用方法与其类似。