奋斗黑马程序员----Java之其他流概述（一）

----------android培训、java培训、期待与您交流！ ----------

/**
* Java其他流概述一：
* 1,PrintWriter
* 2,SequenceInputStream(合并流)
* 3,切割、合并文件
*/

/** 1 ：PrintWriter
*
* public class PrintWriter extends Writer
*    向文本输出流打印对象的格式化表示形式。此类实现在 PrintStream 中的所有 print
* 方法。它不包含用于写入原始字节的方法，对于这些字节，程序应该使用未编码的字节流
* 进行写入。
*    与 PrintStream 类不同，如果启用了自动刷新，则只有在调用 println、printf 或
* format 的其中一个方法时才可能完成此操作，而不是每当正好输出换行符时才完成。这
* 些方法使用平台自有的行分隔符概念，而不是换行符。
*    此类中的方法不会抛出 I/O 异常，尽管其某些构造方法可能抛出异常。客户端可能会
* 查询调用 checkError() 是否出现错误。
*
* public class PrintStream extends FilterOutputStream implements Appendable, Closeable
*    PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。
* 它还提供其他两项功能。与其他输出流不同，PrintStream 永远不会抛出 IOException；
* 而是，异常情况仅设置可通过 checkError 方法测试的内部标志。另外，为了自动刷新，
* 可以创建一个 PrintStream；这意味着可在写入 byte 数组之后自动调用 flush 方法，可
* 调用其中一个 println 方法，或写入一个换行符或字节 ('\n')。
*    PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符
* 而不是写入字节的情况下，应该使用 PrintWriter 类。
*
* 打印流：PrintWriter（字符）与PrintStream（字节）
* 该流提供了打印方法，可以将各种数据类型的数据都原样打印。
* PrintStream:字节打印流
* 	凡是能和流相关的流对象都比较重要。
* 	构造函数可以接受的参数类型：
* 	1，File对象，File
* 	2，字符串路径，String
*  3，字节输出流，OutputStream
*
** PrintWriter：字符打印流（用的较多）
* 	构造函数可以接受的参数类型：
* 	1，File对象，File
* 	2，字符串路径，String
*  3，字节输出流，OutputStream
*  4，字符输出流：Writer
*/
import java.io.*;
public class PrintStreamDemo {
public static void main(String[] args) throws IOException
{
//从键盘录入。要记住。
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

/*
* PrintWriter(OutputStream out) 根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter。
*
* PrintWriter(OutputStream out, boolean autoFlush) 通过现有的 OutputStream 创建新的 PrintWriter。
*
* PrintWriter(String fileName) 创建具有指定文件名称且不带自动行刷新的新 PrintWriter。
*/

//PrintWriter out = new PrintWriter(System.out,true);	//这是输出到流中了，可以刷新。
//PrintWriter out = new PrintWriter("abc.txt");	//如果这样写，后面的写入无法刷新，则意味着只有关闭输入才能一次写入数据
//PrintWriter out = new PrintWriter(new FileWriter("abc.txt"),true);	//这样就可以刷新了。但还想提高效率
PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("abc.txt")),true);
String line = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
//out.write(line.toUpperCase()); //由于PrintWriter本身自带的有println方法（能自动换行）
out.println(line.toUpperCase());
/**
* 当PrintWriter的参数中有true时，则默认的打印println，printf，format都是自己带有刷新的，不用从新写flush。
*/
//out.flush();
}
out.close();
bufr.close();
}
}

/** 2 ：合并流
* 16:31--16:44
* public class SequenceInputStream extends InputStream 表示其他输入流的逻辑串联。
*    它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从
* 第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。(可合并多个流)
*
* SequenceInputStream(Enumeration<? extends InputStream> e)
*    通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型
* 为 InputStream 对象的 Enumeration 型参数。
*
* SequenceInputStream(InputStream s1, InputStream s2)
*    通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个
*    参数，先读取 s1，然后读取 s2），以提供从此 SequenceInputStream 读取的字节。
*
* 	SequenceInputStream 可将多个流合并成一个流。
* 需求：讲目录下的三个txt文件变成一个。
*/
import java.io.*;
import java.util.*;
public class SequenceDemo {
public static void main(String[] args) throws IOException
{
Vector<FileInputStream> vt = new Vector<FileInputStream>();
//将多个流合并成一个流。开始
vt.add(new FileInputStream("1.txt"));
vt.add(new FileInputStream("2.txt"));
vt.add(new FileInputStream("3.txt"));
//将多个流合并成一个流。结束。

/**
* public class Vector<E>extends AbstractList<E> implements List<E>,
* RandomAccess, Cloneable, SerializableVector
*   Vector类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索
* 引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应
* 创建 Vector 后进行添加或移除项的操作。
*
*   Enumeration<E> elements() 返回此向量的组件的枚举。
*
*
* public interface Enumeration<E>
*    实现 Enumeration 接口的对象，它生成一系列元素，一次生成一个。
* 连续调用 nextElement 方法将返回一系列的连续元素。
* 例如，要输出 Vector<E> v 的所有元素，可使用以下方法：
for (Enumeration<E> e = v.elements(); e.hasMoreElements();)
System.out.println(e.nextElement());
*
*    这些方法主要通过向量的元素、哈希表的键以及哈希表中的值进行枚举。
* 枚举也用于将输入流指定到 SequenceInputStream 中。
*
*    boolean hasMoreElements() 测试此枚举是否包含更多的元素。
*
*    E nextElement() 如果此枚举对象至少还有一个可提供的元素，则返回此枚
* 举的下一个元素。
*/
Enumeration<FileInputStream> en = vt.elements();
SequenceInputStream sis = new SequenceInputStream(en);	//参数是Enumeration,集合中存在的。

FileOutputStream fos = new FileOutputStream("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();
}
}

/** 3 :切割文件和合并文件
*/
import java.io.*;
import java.util.*;
public class SplitFile {
public static void main(String[] args) throws IOException
{
//splitFile();
merger();
}
/**
* 分割文件
* @throws IOException
*/
public static void splitFile() throws IOException
{
FileInputStream fis = new FileInputStream("G:\\不屑.mp3");

FileOutputStream fos = null;
byte[] buf = new byte[1024*1024];
int len = 0;
int count = 1;
while((len=fis.read(buf))!=-1)
{
fos = new FileOutputStream("G:\\splitFile\\buxie"+count+++".part"); //碎片文件。
fos.write(buf,0,len);
fos.close();
}
if(fos!=null)
fos.close();
fis.close();

}

/**
* 合并文件
* @throws IOException
*/
public static void merger() throws IOException
{
//vector的效率低
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
for(int x=1;x<=7;x++)
{
al.add(new FileInputStream("G:\\splitFile\\buxie"+x+".part"));

}
final Iterator<FileInputStream> it = al.iterator();
Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()
{
public boolean hasMoreElements()
{
return it.hasNext();
}
public FileInputStream nextElement()
{
return it.next();
}
};
SequenceInputStream sis = new SequenceInputStream(en);

FileOutputStream fos = new FileOutputStream("G:\\splitFile\\aa.mp3");
byte[] buf = new byte[1024];
int len = 0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}