Java I/O(二)其他常用的输入输出流PrintStream等、标准流重定向
四、FilterOutputStream、PrintStream
PrintStream是继承自FilterStream类的，例如标准输出流System.out就是著名的PrintStream类对象。相比较于FileOutputStream，有以下三个有点：
(1)输出类型灵活，可以是int、float、char，还包括char []和String类型，格式也比较多变
(2)成员方法大多不抛异常
(3)可以选择是否需要采用自动强制输出特性。
PrintStream类构造函数常用的有四个，参数可以是(1)OutputStream及其子类，当然包括FileOutputStream类;(2)File类；(3)String文件名；(4)OutputStream类型加autoflush,没有这个参数默认为false。这个参数的意义在于强制调用flush方法，即往PrintStream里写入数据都会立即调用flush()函数。
输出的API方法主要有以下几种：
void write(int b)方法可以b的低8位组成的1字节写入文件
void append(char c)
void print(X x)参数可以是int、double、String、char[]等
void println(X x)参数同上，但是会有换行
void println()只换行
void PrintStream format(String Format,Object …args)
void PrintStream printf(String Format,Object …args)按相应格式输出
——————上述都是写入方法——————
void flush () 强制输出
void close () 关闭流
package filter; import java.io.FileNotFoundException; import java.io.IOException; import java.io.PrintStream; public class Pstream { public static void main(String [] args) { /*PrintStream*/ byte [] o="floyd".getBytes(); try { PrintStream ps=new PrintStream("G:\\home\\dir\\test.txt"); ps.write(o); ps.println(); ps.println("int"); ps.format("%S", "are you OK?"); ps.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch(IOException e) { e.printStackTrace(); } /**/ } }
文件test.txt内容为：
floyd
int
ARE YOU OK?
这里还是想学习一下format相关知识(注：printf()函数和format()功能完全一致)：
%[参数索引$][字符集类型][宽度][.精度]变换类型
中括号内是可有可无内容，也即只有%和变换类型是必须的，如上面程序中的例子便是，参数索引$容易理解，是选择第几个来替代这个地方，如2$就是第2个参数,举个例子
ps.format("%2$S", "are you OK?","Yes, I am fine.");
将上文中程序代码改为这个，输出就会变为YES, I AM FINE.但是没有的话就会默认是第一个。
宽度指得是最少输出字符数(不是最多哦)，格式需要是大于0的十进制整数，例如
ps.format("%2$20S", "are you OK?","Yes, I am fine.");
最少要输出20个字符，但是只有15个，那么怎么办呢？看一下文件立马清楚，就是在左端补齐空格，以上为例就会补齐5个空格：
.精度表示转换精度，也是大于0的十进制整数，：
ps.format("%2$20.3S", "are you OK?","Yes, I am fine.");
可以看出只输出前3位，但是若是浮点类型，会变成保留小数点后3位。但是用在int上就会报错，其余类型暂时还没试过。MARK
还有最后一项字符集类型,具体所指意涵我不是很清楚，但是我觉得应该是指转换符，例如：
ps.format("%2$+20.3f", 100.0/3,-10000.0/6);
例如这里我用的是+，代表要分正负，最终结果
当然转换符还有很多
来源：https://kgd1120.iteye.com/blog/1293633
五、DataOutputStream DataInputStream
称为数据输入输出流，学过PrintStream之后，在看数据的输入输出流就会亲切很多，因为它们主要功能很相似，都是为了提供仰视灵活的输入 or 输出。当然也有一些不同。
DataOutputStream与PrintStream的相同点：都是为了解决FileOutputStream的一些局限性，这两个能够提供更丰富的输出(写入)功能.
不同点：(1)构造函数不同 DataOutputStream的构造函数只有一个：DataOutputStream(OutputStream out)，而PrintStream有很多。
(2)PrintStream能够使用format的输出形式，而DataOutpuStream没有。
(3)异常处理机制不同 等
API使用大都很简单，但是注意DataInputStream要和DataOutputStream配套使用，因为在文件中可能不是你真正的写入内容：
public static void main(String []args) { try { PrintStream ps=new PrintStream("G:\\home\\dir\\data.txt"); //文件不存在也没事，会自动创建一个，这就是输出流的特性,但是没有路径可不行啊！ DataOutputStream dos=new DataOutputStream(ps); //也可以以PrintStream对象位参数 dos.writeInt(456); DataInputStream dis=new DataInputStream(new FileInputStream("G:\\home\\dir\\data.txt")); System.out.println(dis.readInt()); //注意配套使用 } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }
左中程序读得了int数据456并成功输出，但是打开文件来看，却是乱码：
但是注意到一个方法writeUTF()比较与众不同，使用起来倒是没什么困难：
public static void main(String []args) { try { PrintStream ps=new PrintStream("G:\\home\\dir\\data.txt"); DataOutputStream dos=new DataOutputStream(ps); String s="Wuyiming"; dos.writeUTF(s); DataInputStream dis=new DataInputStream(new FileInputStream("G:\\home\\dir\\data.txt")); System.out.println(dis.readUTF()); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }
查看文件内容：
补：抛去代码不讲，倒是想看一看关于UTF等编码的事情。有时间另开一篇(拖延ing......)
六、BufferedInputStream和BufferedOutputStream
称为缓冲输入输出流,和PrintStream、DataOutputStream同样属于FilteOutrStream的子类(针对输出来说)，它是为了解决FileOutputStream另一些问题，即效率问题。通过设置缓冲区进行交互来提升效率
先从两者的构造函数讲起，输入输出都有两个构造函数：
public BufferedOutputStream(OutputStream out) //默认缓冲大小位
public BufferedOutputStream(OutputStream out,int size) //指定缓冲大小
BufferedOutputStream在使用方面和OutputStream完全相同，只是重写了一些方法。下面讨论一下关于缓冲区的问题：
package filter; import java.io.BufferedOutputStream; import java.io.DataOutputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.PrintStream; public class BufferedStream { public static void main(String [] args) { FileOutputStream ps; try { byte []b= {50,50,51,52,53,54,55,56}; ps = new FileOutputStream("\\data.txt"); BufferedOutputStream bos=new BufferedOutputStream(ps,6); bos.write(120); bos.write(b,0,3); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } }
从程序中可以看出指定缓冲区大小为6，而写入了4个字节,小于缓冲区长度，因此文件中不会写入任何东西，但是加入flush()或者close()方法，会强制输出在缓冲区的内容到文件中。如果写入的长度大于或者等于6呢？将代码中的改为：
bos.write(-200);
bos.write(b,0,5);
文件中仍没任何输出，可见等于和小于的效果是一样的，都不会自动输出，但若是：
bos.write(-200);
bos.write(b,0,6);
文件中会写入”8223456“，只要写入的内容大于缓冲区大小，就会强制从缓冲区输出。
看到一段flush()方法讲解，觉得不错，复制过来：
FileOutPutStream继承outputStream,并不提供flush()方法的重写所以无论内容多少write都会将二进制流直接传递给底层操作系统的I/O,flush无效果而Buffered系列的输入输出流函数单从Buffered这个单词就可以看出他们是使用缓冲区的,应用程序每次IO都要和设备进行通信，效率很低，因此缓冲区为了提高效率，当写入设备时，先写入缓冲区，等到缓冲区有足够多的数据时，就整体写入设备。
原文：https://blog.csdn.net/aa8568849/article/details/52974619
补：
关于BufferedInputStream其实也是加了缓冲的FileInputStream类，本没什么可讲的，但是前面的FileInputStream由于健忘少讲了几个API，就在这里补一下，就相当于学习ByteArrayOutputStream和ByteArrayInputStream类了，但是很少有对缓冲输入流讨论关于缓冲区大小的影响，我也先在此不表，主要讨论available()、mark()、marksupport()、reset()、skip()等方法的使用。
顺便详细回顾(其实前面没好好学，手动尴尬)write()和read()的使用方法。
write()方法共有三种，分别是：void write(int i)；void write(byte []b)；void write(byte []b，int off，int len)。
也就是说未经修饰的流只支持这几种数据类型的写方法，整数类型并不是真正的写入这个整数，而是这个整数对应的编码。下面代码是以整数为参数示例，
public static void main(String []args) { try { FileOutputStream fos=new FileOutputStream("\\test.txt"); int a=65; fos.write(a); fos.close(); //以字节读出，然后以字符型输出 FileInputStream fis=new FileInputStream("\\test.txt"); int i=fis.read(); while(i!=-1) { byte b=(byte) i; System.out.print((char)b); i=fis.read(); } fis.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }
文件显示‘A’，输出也是‘A’。
再来参数为byte[]，
byte []b1= {-50,-28};
fos.write(b1);
fos.close();
有趣的是在文件中写入的是汉字“武”，字符输出输出为两个乱码：
输入输出应该是完全一致，那么问题就牵涉到文件是如何显示的了。(现在还不懂)
最后参数是byte数组。但是可以指定开始位置和长度：
byte [] b2= {65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80};//对应ABCDEFGHIJKLMNOP fos.write(b2,5,5); fos.close();
输出和文件一致，均为“FGHIJ”，由此可见开始位置为5意思就是从b2[5]开始(即第6个元素)，往后5个元素结束。
read()同样有三种：int read()；int read(byte []b)；int read(byte [] b，int off，int len)。
上面的程序使用的方法就是无参的方法，简单的与write(int )一一对应。直接来看参数为byte数组，作用是将内容读出文件到数组中，
FileOutputStream fos=new FileOutputStream("\\test.txt"); byte [] b2= {65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80};//对应ABCDEFGHIJKLMNOP fos.write(b2); fos.close(); FileInputStream fis=new FileInputStream("\\test.txt"); byte []b3=new byte[4]; byte []b4=new byte[5]; fis.read(b3); //读出前4个 fis.read(b4); //继续读5个 for(byte r:b4) System.out.print((char)r); //输出EFGHI,注意是继续接着读，直到流关闭。 fis.close();
最后3个参数的版本：
byte []b5=new byte[4]; byte []b6=new byte[5]; fis.read(b5,2,2); // ‘ ’ ‘ ’ ‘A' 'B' fis.read(b6,1,3); // ' ' 'C' 'D' 'E' ' ' for(byte r:b6) System.out.println((char)r); fis.close();
第二参数是指写入到数组中从第几个开始,例如b5是2就是从b5[2]开始(第三个元素，这里是下标)，b6是从b6[3]开始。第三个参数是读的长度，b5是2，就读两个字节，同样的b6是3个字节。
来看一下其他方法的使用情况：
public static void main(String [] args) { try { /*BufferedOutputStream*/ BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("\\test.txt")); byte [] b2= {65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80};//对应ABCDEFGHIJKLMNOP bos.write(b2); bos.close(); /*BufferedInputStream*/ BufferedInputStream bis=new BufferedInputStream(new FileInputStream("\\test.txt")); byte []b7=new byte[4]; byte []b8=new byte[4]; byte []b9=new byte[4]; System.out.println(bis.available()); //共16个 bis.read(b7); //读取ABCD System.out.println(bis.available()); //16-4=12 if(!bis.markSupported()) { System.out.println("mark not support"); } bis.mark(0); //参数无实际意义，在E处标记 bis.skip(5); //跳过5个，从E跳到J bis.read(b8); //读取JKLM bis.reset(); //回到E处 bis.read(b9); //读取EFGH for(byte r:b7) System.out.print((char)r); System.out.println(); for(byte r:b8) System.out.print((char)r); System.out.println(); for(byte r:b9) System.out.print((char)r); bis.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }
输出：
16
12
ABCD
JKLM
EFGH
注意只有BufferedInputStream和ByteArrayInputStream这两种类才支持marksupported()方法，之前用FileInputStream类一直报mark not support！available()输出剩余可读数，原有16个字母，读了4个字母到b7后，只剩12个。mark()和reset()配对使用，做标记和返回标记位置。skip(int n)跳过n个字节。
七 标准流重定向
标准流一共有三种，分别是标准输入流System.in，标准输出流System.out，标准错误流System.err
| 属性 | 类型 | 变量 | 说明 |
| static | java.io.BufferedInputStream | System.in | 标准输入流 |
| static | java.io.PrintStream | System.out | 标准输出流 |
| static | java.io.PrintStream | System.err | 标准错误流 |
那么什么是重定向呢？比如要想与用户交互，获得其输入，一般情况是使用Scanner类进行输入，这就很简单了，下面举一个例子：
public static void main(String []args) { Scanner sc=new Scanner (System.in); String s=sc.nextLine(); System.out.println(s); }
你输什么回车之后就打印什么字符串。但是需要人工手动输入，这样有时间会很麻烦，我们有时间想直接从文件中读取，这时间就需要将文件输入流重定向至标准输入流，需要使用到System的成员方法setIn(InputStream in)。
public static void main(String []args) { InputStream is; try { is = new BufferedInputStream(new FileInputStream("\\test.txt")); System.setIn(is); //使用System.in读取就等于从is中读取 Scanner sc=new Scanner (System.in); String s=sc.next(); System.out.println(s); sc.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
上面代码的功能就是将test.txt文件中的内容输出到控制台上。
再来一段重定向标准输出流的
public static void main(String []args) { try { int []A= {1,2,3,4}; PrintStream out = System.out; PrintStream ps1=new PrintStream("\\log.txt"); PrintStream ps2 = new PrintStream("\\text.txt"); System.out.println(A[0]); System.setOut(ps1); System.out.println(A[1]); System.setOut(ps2); System.out.println(A[2]); System.setOut(out); System.out.println(A[3]); } catch (FileNotFoundException e) { e.printStackTrace(); } }
上面代码的流程介绍一下，先是打印A[0]，没有任何操作下，System.out会默认打印到控制台上。然后冲重定向至文件log,txt中，接下来的System.out会将A[1]写入(打印到)文件log.txt中。又重定向至text.txt，同样的A[2]会写入该文件中。最后再重定向回标准输出流，会在控制台打印A[3]。
控制台。
log.txt
text.txt
