Java 位流处理3

最新推荐文章于 2024-07-30 09:43:11 发布

shen198623

最新推荐文章于 2024-07-30 09:43:11 发布

阅读量177

点赞数

分类专栏： Java 文章标签： Java C C++ C# Blog

本文链接：https://blog.csdn.net/shen198623/article/details/83286644

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

SequenceInputStream

若要将一个文件分割为数个文件，再将之组合还原为一个文件，最基本的作法是使用数个FileInputStream来打开分割后的文件，然后一个一个文件的读取，并使用同一个 FileOutputStream实例写到同一个文件中。必须要自行判断每一个分割文件的读取是否完毕，如果完毕就读取下一个文件

如果使用java.io.SequenceInputStream就不用这么麻烦，SequenceInputStream可以看作是数个 InputStream对象的组合。当一个InputStream对象的内容读取完毕后，它就会取出下一个InputStream对象，直到所有的 InputStream对象都读取完毕为止

SequenceInputStream的使用示范。可以将指定的文件进行分割，也可以将分割后的文件还原为一个文件

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;

public class SequenceInputStreamDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			switch (args[0].charAt(1)) {
			case 's':
				// args[1]:每个分割文件的大小
				int size = Integer.parseInt(args[1]);
				// args[2]:指定要被分割的文件名称
				seperate(args[2], size);
				break;
			case 'c':
				//args[1]:指定要被组合的文件个数
				int number = Integer.parseInt(args[1]);
				//args[2]:组合后的文件名称
				concatenate(args[2],number);
				break;
			}
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("Using: java UseSequenceStream [-s/-c]"+" (size/number) filename");
			System.out.println("-s: 分割文件\n-c: 组合文件");
		}catch(IOException e)
		{
			e.printStackTrace();
		}
	}

	// 分割文件
	public static void seperate(String filename, int size) throws IOException {

		FileInputStream fileInputStream = new FileInputStream(
				new File(filename));
		byte[] data = new byte[1];
		int count = 0;
		// 还原文件大小及指定分割的大小
		// 决定要分割为几个文件
		if (fileInputStream.available() % size == 0)
			count = fileInputStream.available() / size;
		else
			count = fileInputStream.available() / size + 1;

		for (int i = 0; i < count; i++) {
			int num = 0;
			// 分割的文件加上下划线与编号
			File file = new File(filename + "_" + i);
			BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
					new FileOutputStream(file));

			while (fileInputStream.read(data) != -1) {
				bufferedOutputStream.write(data);

				num++;

				if (num == size) {
					bufferedOutputStream.flush();
					bufferedOutputStream.close();
					break;
				}
			}

			if (num < size) {
				bufferedOutputStream.flush();
				bufferedOutputStream.close();
			}
		}
		System.out.println("分割为" + count + "个文件");
	}

	// 连接文件
	public static void concatenate(String filename, int number)
			throws IOException {
		// 收集文件用的list
		List<InputStream> list = new ArrayList<InputStream>();
		for (int i = 0; i < number; i++) {
			File file = new File(filename + "_" + i);
			list.add(i, new FileInputStream(file));
		}

		final Iterator<InputStream> iterator = list.iterator();

		// SequenceInputStream需要一个Enumeration对象来构建
		Enumeration<InputStream> enumeration = new Enumeration<InputStream>() {
			public boolean hasMoreElements() {
				return iterator.hasNext();
			}

			public InputStream nextElement() {
				return iterator.next();
			}
		};

		// 建立SequenceInputStream
		// 并使用BufferedInputStream
		BufferedInputStream bufInputStream = new BufferedInputStream(
				new SequenceInputStream(enumeration), 8192);

		BufferedOutputStream bufOutputStream = new BufferedOutputStream(
				new FileOutputStream(filename), 8192);
		byte[] data = new byte[1];
		// 读取所有文件数据并写入目的文件
		while (bufInputStream.read(data) != -1) {
			bufOutputStream.write(data);
		}
		bufInputStream.close();
		bufOutputStream.flush();
		bufOutputStream.close();

		System.out.println("组合" + number + "文件OK");
	}
}

分割文件时必须指定-s和分割后的每个文件大小。执行的一个例子如下

java onlyfun.caterpillar.SequenceStreamDemo -s 1048576 test.zip

分割为6个文件

分割后的文件名是原文件名加上下划线与编号，例如test.zip_1、test.zip_2等。合并文件时必须要指定-c、合并的文件数与来源文件名称，例如将之前分割过后的文件合并为一个文件：

java onlyfun.caterpillar.SequenceStreamDemo -c 6 test.zip

组合6个文件 OK!!

PrintStream

之前所介绍过的OutputStream对象，都是直接将内存中的数据原封不变地写至目的地(例如一个文件)。举个例子来说，如果将int类型1使用之前介绍的 OutputStream对象输出至文件，则文件中所存储的是int类型1在内存中的值

import java.io.File;
import java.io.FileOutputStream;

public class StreamTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try
		{
		FileOutputStream file = new FileOutputStream(new File("d:\\test.txt"));
		file.write(1);
		file.close();
		}catch(Exception e)
		{
			e.printStackTrace();
		}
	}

}

执行范例后会产生一个 test.txt文件，打开文件之后，不会看到显示1，而可能看到一个怪异的符号。由于使用write()方法，这会将1在内存中的值的低字节 0000001写入文件中，而纯文件文件在显示文件内容时，会以操作系统的默认编码显示对应的字符。如果使用文字编辑软件(像vi或UltraEdit) 观看test.txt的十六进制表示，其结果会显示 01(十六进制表示)，

有时所想要存储的结果是数据转换为字符之后的结果，例如程序的执行结果是3.14159，您会希望使用3.14159等字符来存储，也就是俗称的存储为纯文本文件。这样当使用简单的纯文字编辑器观看时，就可以直接看到以3.14159等字符显示的画面。在范例14.12中，若想使用纯文本文件看到 test.txt的显示结果是1，则必须先将内存中的整数1，也就是二进制00000000 00000000 00000000 00000001转换为对应的1字符编码，也就是0x31(十进制表示为49)并加以存储。

使用java.io.PrintStream可以自动进行字符转换的动作，默认会使用操作系统的编码来处理对应的字符转换动作

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

public class PrintStreamDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			PrintStream printStream = new PrintStream(new FileOutputStream(
					new File("D:\\abc.txt")));
			printStream.print(1);
			printStream.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

执行程序之后使用纯文字编辑器打开test.txt，其内容会是显示字符1了。print()或println()接受int、char、String、double等数据类型，println()会在输出之后加上换行字符，而print()则不会

ByteArrayInputStream和ByteArrayOutputStream

流的来源或目的地不一定是文件，也可以是内存中的一个空间，例如一个位数组。java.io.ByteArrayInputStream、java.io.ByteArrayOutputStream即是将位数组当作流输入来源、输出目的地的类

ByteArrayInputStream可以将一个数组当作流输入的来源，而ByteArrayOutputStream则可以将一个位数组当作流输出的目的地。在这里举一个简单的文件位编辑程序作为例子，您可以打开一个简单的文本文件，其中有简单的A、B、C、D、E、F、G等字符，在读取文件之后，可以直接以程序来指定文件中位的位置来修改所指定的字符。作法是将文件读入数组中，指定数组索引修改元素，然后重新将数组存回文件

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class ByteArrayStreamDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			File file = new File(args[0]);
			BufferedInputStream bufferedInputStream = new BufferedInputStream(
					new FileInputStream(file));
			ByteArrayOutputStream arrayOutputStream = new ByteArrayOutputStream();
			byte[] bytes = new byte[1];
			// 将文件内容写入位数组流

			while (bufferedInputStream.read(bytes) != -1) {
				arrayOutputStream.write(bytes);
			}

			arrayOutputStream.close();
			bufferedInputStream.close();

			// 以字符方式显示数组内容

			bytes = arrayOutputStream.toByteArray();
			for (int i = 0; i < bytes.length; i++) {
				System.out.println((char) bytes[i]);
			}

			System.out.println();

			// 让用户输入位置与字符修改数组内容
			Scanner scanner = new Scanner(System.in);

			System.out.println("输入修改位置：");
			int pos = scanner.nextInt();

			System.out.println("输入修改字符：");
			// 修改数组中的对应字符
			bytes[pos - 1] = (byte) scanner.next().charAt(0);

			// 将位数组内容存回文件
			ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(
					bytes);
			BufferedOutputStream bufOutputStream = new BufferedOutputStream(
					new FileOutputStream(file));

			byte[] tmp = new byte[1];

			while (byteArrayInputStream.read(tmp) != -1)
				bufOutputStream.write(tmp);

			byteArrayInputStream.close();
			bufOutputStream.flush();
			bufOutputStream.close();

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

执行结果：

java onlyfun.caterpillar.ByteArrayStreamDemo test.txt

ABCDEFG

输入修改位置：3

输入修改字符：X

源文件地址:http://hi.baidu.com/mdbing/blog/item/3c737a59356d922f2834f0fb.html