打印流PrintStream

于 2011-11-07 17:11:00 发布
阅读量102 收藏
点赞数
文章标签： 操作系统 java
本文深入探讨了在信息技术领域中几种关键的流技术，包括打印流、管道流、序列流以及操作数组的流，详细解释了它们的功能、用法及应用场景。重点介绍了PrintStream、PrintWriter的使用方法，管道流的实现过程，序列流的作用，以及操作数组流的特性。此外，还讨论了编码转换的概念和方法，强调了在不同编码环境下进行数据传输的重要性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

打印流PrintStream

PrintStream：

是一个字节打印流，System.out对应的类型就是PrintStream。

它的构造函数函数可以接收三种数据类型的值。

1，字符串路径。

2，File对象。

3，OutputStream。

PrintWriter：

是一个字符打印流。构造函数可以接收四种类型的值。

1，字符串路径。

2，File对象。

对于1，2类型的数据，还可以指定编码表。也就是字符集。

3，OutputStream

4，Writer

对于3，4类型的数据，可以指定自动刷新。

注意：该自动刷新值为true时，只有三个方法可以用：println,printf,format.

view plain copy to clipboard print ?
  1. //如果想要既有自动刷新，又可执行编码。如何完成流对象的包装？
  3. PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),"utf-8"),true);
//如果想要既有自动刷新，又可执行编码。如何完成流对象的包装？ PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),"utf-8"),true);

view plain copy to clipboard print ?
  1. //如果想要提高效率。还要使用打印方法。
  3. PrintWriter pw = new PrintWriter(new BufferdWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),"utf-8")),true);
//如果想要提高效率。还要使用打印方法。 PrintWriter pw = new PrintWriter(new BufferdWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),"utf-8")),true);


view plain copy to clipboard print ?
  1. import java.io.*;
  3. public class PrintStreamTest {
  5. public static void main(String[] args) throws IOException {
  7. System.out.println((byte)1);
  9. wirteFile1();
  11. wirteFile2();
  13. readFile2();
  15. readFile22();
  17. }
  19. public static void wirteFile1() throws IOException{
  21. DataOutputStream dos = new DataOutputStream(new FileOutputStream(new File("res/pst1.txt")));
  23. dos.writeDouble(3.1415926);
  25. dos.close();
  27. }
  29. public static void wirteFile2() throws IOException{
  31. PrintStream ps = new PrintStream(new FileOutputStream(new File("res/pst2.txt")));
  33. ps.print(3.1415926);
  35. ps.print("北京");
  37. ps.close();
  39. }
  41. public static void readFile2() throws IOException {
  43. FileInputStream fis =new FileInputStream("res/pst2.txt");
  45. int len = fis.available();
  47. byte[] buf = new byte[len];
  49. while(fis.read(buf) != -1){
  51. System.out.println(new String(buf));
  53. }
  55. fis.close();
  57. }
  59. public static void readFile22() throws IOException{
  61. BufferedReader br = new BufferedReader( new FileReader("res/pst2.txt"));
  63. String content = null;
  65. while((content = br.readLine()) != null){
  67. System.out.println(content);
  69. }
  71. br.close();
  73. }
  75. }
import java.io.*; public class PrintStreamTest { public static void main(String[] args) throws IOException { System.out.println((byte)1); wirteFile1(); wirteFile2(); readFile2(); readFile22(); } public static void wirteFile1() throws IOException{ DataOutputStream dos = new DataOutputStream(new FileOutputStream(new File("res/pst1.txt"))); dos.writeDouble(3.1415926); dos.close(); } public static void wirteFile2() throws IOException{ PrintStream ps = new PrintStream(new FileOutputStream(new File("res/pst2.txt"))); ps.print(3.1415926); ps.print("北京"); ps.close(); } public static void readFile2() throws IOException { FileInputStream fis =new FileInputStream("res/pst2.txt"); int len = fis.available(); byte[] buf = new byte[len]; while(fis.read(buf) != -1){ System.out.println(new String(buf)); } fis.close(); } public static void readFile22() throws IOException{ BufferedReader br = new BufferedReader( new FileReader("res/pst2.txt")); String content = null; while((content = br.readLine()) != null){ System.out.println(content); } br.close(); } }


管道流

n PipedInputStream

n PipedOutputStream

特点：

读取管道流流和写入管道流可以进行连接。

连接方式：

1，通过两个流对象的构造函数。

2，通过两个对象的connect方法。

通常两个流在使用时，需要加入多线程技术，也就是让读写同时运行。

注意；对于read方法。该方法是阻塞式的，也就是没有数据的情况，该方法会等待。

view plain copy to clipboard print ?
  1. //sender.java
  3. import java.io.*;
  5. import java.util.*;
  7. public class Sender extends Thread {
  9. PipedOutputStream out = new PipedOutputStream();
  11. public PipedOutputStream getOut() {
  13. return out;
  15. }
  17. public void run() {
  19. String str = "Hello,receiver ! I`m sender\n ";
  21. try {
  23. for(int i=0; i<10; i++)
  25. out.write(str.getBytes());
  27. out.close();
  29. } catch (Exception e) {
  31. e.printStackTrace();
  33. }
  35. }
  37. }
  39. //Receiver.java
  41. import java.io.PipedInputStream;
  43. import java.util.*;
  45. public class Receiver extends Thread {
  47. PipedInputStream in = new PipedInputStream();
  49. public PipedInputStream getIn() {
  51. return in;
  53. }
  55. public void run() {
  57. byte[] buf = new byte[1024];
  59. try {
  61. int len = in.read(buf);
  63. System.out.println("the following is from sender:\n "
  65. + new String(buf, 0, len));
  67. in.close();
  69. } catch (Exception e) {
  71. e.printStackTrace();
  73. }
  75. }
  77. }
  79. //TestPiped
  81. import java.io.PipedInputStream;
  83. import java.io.PipedOutputStream;
  85. class TestPiped {
  87. public static void main(String[] args) {
  89. Sender s = new Sender();
  91. Receiver r = new Receiver();
  93. PipedOutputStream out = s.getOut();
  95. PipedInputStream in = r.getIn();
  97. try {
  99. in.connect(out);
  101. s.start();
  103. r.start();
  105. } catch (Exception e) {
  107. e.printStackTrace();
  109. }
  111. }
  113. }
//sender.java import java.io.*; import java.util.*; public class Sender extends Thread { PipedOutputStream out = new PipedOutputStream(); public PipedOutputStream getOut() { return out; } public void run() { String str = "Hello,receiver ! I`m sender\n "; try { for(int i=0; i<10; i++) out.write(str.getBytes()); out.close(); } catch (Exception e) { e.printStackTrace(); } } } //Receiver.java import java.io.PipedInputStream; import java.util.*; public class Receiver extends Thread { PipedInputStream in = new PipedInputStream(); public PipedInputStream getIn() { return in; } public void run() { byte[] buf = new byte[1024]; try { int len = in.read(buf); System.out.println("the following is from sender:\n " + new String(buf, 0, len)); in.close(); } catch (Exception e) { e.printStackTrace(); } } } //TestPiped import java.io.PipedInputStream; import java.io.PipedOutputStream; class TestPiped { public static void main(String[] args) { Sender s = new Sender(); Receiver r = new Receiver(); PipedOutputStream out = s.getOut(); PipedInputStream in = r.getIn(); try { in.connect(out); s.start(); r.start(); } catch (Exception e) { e.printStackTrace(); } } }


序列流，也称为合并流——SequenceInputStream:

特点：可以将多个读取流合并成一个流。这样操作起来很方便。

原理：其实就是将每一个读取流对象存储到一个集合中。最后一个流对象结尾作为这个流的结尾。

两个构造函数：

1，SequenceInputStream(InputStream in1,InputStream in2)

可以将两个读取流合并成一个流。

2，SequenceInputStream(Enumeration<? extends InputStream> en)

可以将枚举中的多个流合并成一个流。

作用：可以用于多个数据的合并。

view plain copy to clipboard print ?
  1. //将两个文件拼接为一个流进行依次读取
  3. import java.io.*;
  5. public class DataIODemo1 {
  7. public static void main(String[] args) throws IOException {
  9. FileInputStream fis1 = new FileInputStream("res/a.txt");
  11. FileInputStream fis2 = new FileInputStream("res/number.txt");
  13. SequenceInputStream sis = new SequenceInputStream(fis1, fis2);
  15. int ch;
  17. while((ch = sis.read()) != -1){
  19. System.out.print((char)ch);
  21. }
  23. sis.close();
  25. fis1.close();
  27. fis2.close();
  29. }
  31. }
//将两个文件拼接为一个流进行依次读取 import java.io.*; public class DataIODemo1 { public static void main(String[] args) throws IOException { FileInputStream fis1 = new FileInputStream("res/a.txt"); FileInputStream fis2 = new FileInputStream("res/number.txt"); SequenceInputStream sis = new SequenceInputStream(fis1, fis2); int ch; while((ch = sis.read()) != -1){ System.out.print((char)ch); } sis.close(); fis1.close(); fis2.close(); } }


注意：因为Enumeration是Vector中特有的取出方式。而Vector被ArrayList取代。

所以要使用ArrayList集合效率更高一些。那么如何获取Enumeration呢？

view plain copy to clipboard print ?
  1. ArrayList<FileInputStream > al = new ArrayList<FileInputStream>();
  3. for(int x=1; x<4; x++)
  5. al.add(new FileInputStream(x+".txt"));
  7. //返回按适当顺序在列表的元素上进行迭代的迭代器。
  9. final Iterator<FileInputStream> it = al.iterator();
  11. Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() {
  13. public boolean hasMoreElements() {
  15. return it.hasNext();
  17. }
  19. public FileInputStream nextElement() {
  21. return it.next();
  23. }
  25. };
  27. //多个流就变成了一个流，这就是数据源。
  29. SequenceInputStream sis = new SequenceInputStream(en);
  31. //创建数据目的。
  33. FileOutputStream fos = new FileOutputStream("4.txt");
  35. byte[] buf = new byte[1024*4];
  37. int len = 0;
  39. while((len=sis.read(buf))!=-1)
  41. {
  43. fos.write(buf,0,len);
  45. }
  47. fos.close();
  49. sis.close();
  51. //如果要一个对文件数据切割。
  53. 一个读取对应多了输出。
  55. FileInputStream fis = new FileInputStream("1.mp3");
  57. FileOutputStream fos = null;
  59. byte[] buf = new byte[1024*1024];//是一个1m的缓冲区。
  61. int len = 0;
  63. int count = 1;
  65. while((len=fis.read(buf))!=-1)
  67. {
  69. fos = new FileOutputStream((count++)+".part");
  71. fos.write(buf,0,len);
  73. fos.close();
  75. }
  77. fis.close();
  79. //这样就是将1.mp3文件切割成多个碎片文件。
ArrayList<FileInputStream > al = new ArrayList<FileInputStream>(); for(int x=1; x<4; x++) al.add(new FileInputStream(x+".txt")); //返回按适当顺序在列表的元素上进行迭代的迭代器。 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("4.txt"); byte[] buf = new byte[1024*4]; int len = 0; while((len=sis.read(buf))!=-1) { fos.write(buf,0,len); } fos.close(); sis.close(); //如果要一个对文件数据切割。 一个读取对应多了输出。 FileInputStream fis = new FileInputStream("1.mp3"); FileOutputStream fos = null; byte[] buf = new byte[1024*1024];//是一个1m的缓冲区。 int len = 0; int count = 1; while((len=fis.read(buf))!=-1) { fos = new FileOutputStream((count++)+".part"); fos.write(buf,0,len); fos.close(); } fis.close(); //这样就是将1.mp3文件切割成多个碎片文件。


想要合并使用SequenceInputStream即可。

对于切割后，合并是需要的一些源文件的信息。

可以通过配置文件进行存储。该配置可以通过键=值的形式存在。

然后通过Properties对象进行数据的加载和获取。

操作数组的流对象

1、操作字节数组

u ByteArrayInputStream

u ByteArrayOutputStream

toByteArray();

toString();

writeTo(OutputStream);

2、操作字符数组。

u CharArrayReader

u CharArrayWriter

3、操作字符串

u StringReader，

u StringWriter。

对于这些流，源是内存。目的也是内存。

而且这些流并未调用系统资源。使用的就是内存中的数组。

所以这些在使用的时候不需要close。

操作数组的读取流在构造是，必须要明确一个数据源。所以要传入相对应的数组。

对于操作数组的写入流，在构造函数可以使用空参数。因为它内置了一个可变长度数组作为缓冲区。

这几个流的出现其实就是通过流的读写思想在操作数组。

复合类型数据（比如：姓名、年龄、籍贯、性别等等）

ByteArrayOutputStream bos = new ByteArrayOutputStream();

DataOutputStream dos = new DataOutputStream (bos);

dos.writeUTF(..);

dos.writeInt(..);

dos.writeBoolean(..);

...

byte[] result = bos.toByteArray();

编码转换

在io中涉及到编码转换的流是转换流和打印流。

但是打印流只有输出。

在转换流中是可以指定编码表的。

默认情况下，都是本机默认的码表GBK. 这个编码表怎么来的？

System.out.println(System.getProperty("file.encoding"));

常见码表：

ascii:美国标准信息交换码。使用的是1个字节的7位来表示该表中的字符。

ISO8859-1:拉丁码表。使用1个字节来表示。

GB2312:简体中文码表。

GBK：简体中文码表，比GB2312融入更多的中文文件和符号。

unicode:国际标准码表。都用两个字节表示一个字符。

UTF-8：对unicode进行优化，每一个字节都加入了标识头。

编码转换：

字符串 -->字节数组 ：编码。通过getBytes(charset);

字节数组-->字符串 ： 解码。通过String类的构造函数完成。String(byte[],charset);

如果编对了，解错了，有可能还有救！

view plain copy to clipboard print ?
  1. import java.io.IOException;
  3. import java.io.UnsupportedEncodingException;
  5. public class CodeTest {
  7. public static void main(String[] args) throws IOException {
  9. String s = "你好";
  11. // 编码。
  13. byte[] b = s.getBytes("GBK");
  15. System.out.println(new String(b, "GBK"));
  17. // 解码。
  19. String s1 = new String(b, "iso8859-1");
  21. System.out.println(s1);// ????
  23. // 想要还原。
  25. /*
  27. * 对s1先进行一次解码码表的编码。获取原字节数据。 然后在对原字节数据进行指定编码表的解码。
  29. */
  31. byte[] b1 = s1.getBytes("iso8859-1");
  33. System.out.println(new String(b1, "GBK"));
  35. }
  37. }
import java.io.IOException; import java.io.UnsupportedEncodingException; public class CodeTest { public static void main(String[] args) throws IOException { String s = "你好"; // 编码。 byte[] b = s.getBytes("GBK"); System.out.println(new String(b, "GBK")); // 解码。 String s1 = new String(b, "iso8859-1"); System.out.println(s1);// ???? // 想要还原。 /* * 对s1先进行一次解码码表的编码。获取原字节数据。 然后在对原字节数据进行指定编码表的解码。 */ byte[] b1 = s1.getBytes("iso8859-1"); System.out.println(new String(b1, "GBK")); } }


这种情况在tomcat服务器会出现。

因为tomcat服务器默认是iso8859-1的编码表。

所以客户端通过浏览器向服务前通过get提交方式提交中文数据时，

服务端获取到会使用ISO8859-1进行中文数据的解码。会出现乱码。

这时就必须要对获取的数据进行iso8859-1编码。然后在按照页面指定的编码表进行解码。即可

而对于post提交，这种方法也通用。但是post有更好的解决方式。

request.setCharacterEncoding("utf-8");即可。

所以建立客户端提交使用post提交方式。

iteye_9378
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值