SequenceInputStream,ObjectInput/OutputStream

import java.io.*;
public class OtherStream
{
public static void main (String args[]) throws Exception{
byteArrayStreamMethod();
}

//——————————————————————————————————
public static void byteArrayStreamMethod() throws Exception{
ByteArrayInputStream bis = new ByteArrayInputStream("abcedf".getBytes());

ByteArrayOutputStream bos = new ByteArrayOutputStream();

int ch = 0;

while((ch=bis.read())!=-1){
bos.write(ch);
}

System.out.println(bos.toString());
}

//---------------------------------------------------
//dataStream流
public static void dataStreamMethod() throws Exception{
writeData();
readData();
}

public static void readData() throws IOException {

DataInputStream dis = new DataInputStream(new FileInputStream("q://data.txt"));

String str = dis.readUTF();

System.out.println(str);
}


public static void writeData() throws IOException {

DataOutputStream dos = new DataOutputStream(new FileOutputStream("q://data.txt"));

dos.writeUTF("你好");

dos.close();


}


//-------------------------------------------------------------------------
//-----------------------------------------------------------
/*
* RandomAccessFile
* 一看这个类名字，纠结。不是io体系中的子类。
* 
* 特点：
* 1，该对象即能读，又能写。
* 2，该对象内部维护了一个byte数组，并通过指针可以操作数组中的元素，
* 3，可以通过getFilePointer方法获取指针的位置，和通过seek方法设置指针的位置。
* 4，其实该对象就是将字节输入流和输出流进行了封装。 
* 5，该对象的源或者目的只能是文件。通过构造函数就可以看出。 
*/
public static void randomAccessFileMethod() throws Exception{
// writeFile();
readFile();
// randomWrite();
}


public static void randomWrite() throws IOException{
RandomAccessFile raf = new RandomAccessFile("q://ranacc.txt", "rw");

//往指定位置写入数据。
raf.seek(3*8);

raf.write("哈哈".getBytes());
raf.writeInt(108);

raf.close();
}


public static void readFile() throws IOException {

RandomAccessFile raf = new RandomAccessFile("q://ranacc.txt", "r");

//通过seek设置指针的位置。
raf.seek(1*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);

System.out.println("pos:"+raf.getFilePointer());

raf.close();


}


//使用RandomAccessFile对象写入一些人员信息，比如姓名和年龄。
public static void writeFile() throws IOException{
/*
* 如果文件不存在，则创建，如果文件存在，不创建
* 
*/
RandomAccessFile raf = new RandomAccessFile("q://ranacc.txt","rw");

raf.write("张三".getBytes());
raf.writeInt(97);
raf.write("小强".getBytes());
raf.writeInt(99);
//
raf.close();
}

//--------------------------------------------------------------------

//PipedStream管道流演示
public static void pipedStreamMethod() throws Exception{
PipedInputStream input = new PipedInputStream();
PipedOutputStream output = new PipedOutputStream();

input.connect(output);

new Thread(new Input(input)).start();
new Thread(new Output(output)).start();
}
}


class Input implements Runnable{

private PipedInputStream in;
Input(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="+s);
in.close();
} catch (Exception e) {
// TODO: handle exception
}

}
}


class Output implements Runnable{
private PipedOutputStream out;
Output(PipedOutputStream out){
this.out = out;
}
public void run(){

try {
Thread.sleep(5000);
out.write("hi，管道来了！".getBytes());
} catch (Exception e) {
// TODO: handle exception
}
}
}

————————————————————————————————————————————————————————————————

package cn.itcast.io.p1.splitfile;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;


/*
 * 文件切割器。
 * 
 * 
 * 
 * 
 */


public class SplitFileDemo {


private static final int SIZE = 1024 * 1024;


/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {


File file = new File("c:\\aa.mp3");


splitFile_2(file);
}


private static void splitFile_2(File file) throws IOException {


// 用读取流关联源文件。
FileInputStream fis = new FileInputStream(file);


// 定义一个1M的缓冲区。
byte[] buf = new byte[SIZE];


// 创建目的。
FileOutputStream fos = null;


int len = 0;
int count = 1;


/*
* 切割文件时，必须记录住被切割文件的名称，以及切割出来碎片文件的个数。 以方便于合并。
* 这个信息为了进行描述，使用键值对的方式。用到了properties对象
* 
*/
Properties prop  = new Properties();




File dir = new File("c:\\partfiles");
if (!dir.exists())
dir.mkdirs();


while ((len = fis.read(buf)) != -1) {


fos = new FileOutputStream(new File(dir, (count++) + ".part"));
fos.write(buf, 0, len);
fos.close();
}

//将被切割文件的信息保存到prop集合中。
prop.setProperty("partcount", count+"");
prop.setProperty("filename", file.getName());



fos = new FileOutputStream(new File(dir,count+".properties"));

//将prop集合中的数据存储到文件中。 
prop.store(fos, "save file info");


fos.close();
fis.close();


}


public static void splitFile(File file) throws IOException {


// 用读取流关联源文件。
FileInputStream fis = new FileInputStream(file);


// 定义一个1M的缓冲区。
byte[] buf = new byte[SIZE];


// 创建目的。
FileOutputStream fos = null;


int len = 0;
int count = 1;


File dir = new File("c:\\partfiles");
if (!dir.exists())
dir.mkdirs();


while ((len = fis.read(buf)) != -1) {


fos = new FileOutputStream(new File(dir, (count++) + ".part"));
fos.write(buf, 0, len);
}


fos.close();
fis.close();


}


}

package cn.itcast.io.p1.splitfile;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Properties;


public class MergeFile {


/**
* @param args
* @throws IOException 
*/
public static void main(String[] args) throws IOException {


File dir = new File("c:\\partfiles");

mergeFile_2(dir);
}

public static void mergeFile_2(File dir) throws IOException {

/*
* 获取指定目录下的配置文件对象。
*/
File[] files = dir.listFiles(new SuffixFilter(".properties"));

if(files.length!=1)
throw new RuntimeException(dir+",该目录下没有properties扩展名的文件或者不唯一");
//记录配置文件对象。
File confile = files[0];



//获取该文件中的信息================================================。

Properties prop = new Properties();
FileInputStream fis = new FileInputStream(confile);

prop.load(fis);

String filename = prop.getProperty("filename");
int count = Integer.parseInt(prop.getProperty("partcount"));




//获取该目录下的所有碎片文件。 ==============================================
File[] partFiles = dir.listFiles(new SuffixFilter(".part"));

if(partFiles.length!=(count-1)){
throw new RuntimeException(" 碎片文件不符合要求，个数不对!应该"+count+"个");
}



//将碎片文件和流对象关联 并存储到集合中。 
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int x=0; x<partFiles.length; x++){

al.add(new FileInputStream(partFiles[x]));
}



//将多个流合并成一个序列流。 
Enumeration<FileInputStream> en = Collections.enumeration(al);
SequenceInputStream sis = new SequenceInputStream(en);

FileOutputStream fos = new FileOutputStream(new File(dir,filename));

byte[] buf = new byte[1024];

int len = 0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}

fos.close();
sis.close();






}


public static void mergeFile(File dir) throws IOException{


ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();

for(int x=1; x<=3 ;x++){
al.add(new FileInputStream(new File(dir,x+".part")));
}

Enumeration<FileInputStream> en = Collections.enumeration(al);
SequenceInputStream sis = new SequenceInputStream(en);

FileOutputStream fos = new FileOutputStream(new File(dir,"1.bmp"));

byte[] buf = new byte[1024];

int len = 0;
while((len=sis.read(buf))!=-1){
fos.write(buf,0,len);
}

fos.close();
sis.close();

}


}

package cn.itcast.io.p1.splitfile;


import java.io.File;
import java.io.FilenameFilter;


public class SuffixFilter implements FilenameFilter {


private String suffix;

public SuffixFilter(String suffix) {
super();
this.suffix = suffix;
}


@Override
public boolean accept(File dir, String name) {


return name.endsWith(suffix);
}


}