一直对IO流记不清楚,从别的地方转过来。
看下图:
流的概念和作用
学习Java IO,不得不提到的就是JavaIO流。
流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。
IO流的分类
根据处理数据类型的不同分为:字符流和字节流
根据数据流向不同分为:输入流和输出流
字符流和字节流
字符流的由来: 因为数据编码的不同,而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时,去查了指定的码表。
字节流和字符流的区别:
(1)读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。
(2)处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能处理字符类型的数据。
(3)字节流在操作的时候本身是不会用到缓冲区的,是文件本身的直接操作的;而字符流在操作的时候下后是会用到缓冲区的,是通过缓冲区来操作文件,我们将在下面验证这一点。
结论:优先选用字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的,包括图片等内容。但是字符只是在内存中才会形成的,所以在开发中,字节流使用广泛。
输入流和输出流
对输入流只能进行读操作,对输出流只能进行写操作,程序中需要根据待传输数据的不同特性而使用不同的流。
Java IO流对象
1. 输入字节流InputStream
定义和结构说明:
InputStream 是所有的输入字节流的父类,它是一个抽象类。
ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流,它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。PipedInputStream 是从与其它线程共用的管道中读取数据。
ObjectInputStream 和所有FilterInputStream的子类都是装饰流(装饰器模式的主角)。意思是FileInputStream类可以通过一个String路径名创建一个对象,FileInputStream(String name)。而DataInputStream必须装饰一个类才能返回一个对象,DataInputStream(InputStream in)。
【案例 】读取文件内容
1 /** 2 * 字节流 3 * 读文件内容 4 * */ 5 import java.io.*; 6 class hello{ 7 public static void main(String[] args) throws IOException { 8 String fileName="D:"+File.separator+"hello.txt"; 9 File f=new File(fileName); 10 InputStream in=new FileInputStream(f); 11 byte[] b=new byte[1024]; 12 in.read(b); 13 in.close(); 14 System.out.println(new String(b)); 15 } 16 }
注意:该示例中由于b字节数组长度为1024,如果文件较小,则会有大量填充空格。我们可以利用in.read(b);的返回值来设计程序,如下案例:
【案例】读取文件内容
1 /** 2 * 字节流 3 * 读文件内容 4 * */ 5 import java.io.*; 6 class hello{ 7 public static void main(String[] args) throws IOException { 8 String fileName="D:"+File.separator+"hello.txt"; 9 File f=new File(fileName); 10 InputStream in=new FileInputStream(f); 11 byte[] b=new byte[1024]; 12 int len=in.read(b); 13 in.close(); 14 System.out.println("读入长度为:"+len); 15 System.out.println(new String(b,0,len)); 16 } 17 }
注意:观察上面的例子可以看出,我们预先申请了一个指定大小的空间,但是有时候这个空间可能太小,有时候可能太大,我们需要准确的大小,这样节省空间,那么我们可以这样做:
【案例】读取文件内容
1 /** 2 * 字节流 3 * 读文件内容,节省空间 4 * */ 5 import java.io.*; 6 class hello{ 7 public static void main(String[] args) throws IOException { 8 String fileName="D:"+File.separator+"hello.txt"; 9 File f=new File(fileName); 10 InputStream in=new FileInputStream(f); 11 byte[] b=new byte[(int)f.length()]; 12 in.read(b); 13 System.out.println("文件长度为:"+f.length()); 14 in.close(); 15 System.out.println(new String(b)); 16 } 17 }
【案例】逐字节读
1 /** 2 * 字节流 3 * 读文件内容,节省空间 4 * */ 5 import java.io.*; 6 class hello{ 7 public static void main(String[] args) throws IOException { 8 String fileName="D:"+File.separator+"hello.txt"; 9 File f=new File(fileName); 10 InputStream in=new FileInputStream(f); 11 byte[] b=new byte[(int)f.length()]; 12 for (int i = 0; i < b.length; i++) { 13 b[i]=(byte)in.read(); 14 } 15 in.close(); 16 System.out.println(new String(b)); 17 } 18 }
注意:上面的几个例子都是在知道文件的内容多大,然后才展开的,有时候我们不知道文件有多大,这种情况下,我们需要判断是否独到文件的末尾。
【案例】字节流读取文件
1 /** 2 * 字节流 3 *读文件 4 * */ 5 import java.io.*; 6 class hello{ 7 public static void main(String[] args) throws IOException { 8 String fileName="D:"+File.separator+"hello.txt"; 9 File f=new File(fileName); 10 InputStream in=new FileInputStream(f); 11 byte[] b=new byte[1024]; 12 int count =0; 13 int temp=0; 14 while((temp=in.read())!=(-1)){ 15 b[count++]=(byte)temp; 16 } 17 in.close(); 18 System.out.println(new String(b)); 19 } 20 }
注意:当读到文件末尾的时候会返回-1.正常情况下是不会返回-1的。
【案例】DataInputStream类
1 import java.io.DataInputStream; 2 import java.io.File; 3 import java.io.FileInputStream; 4 import java.io.IOException; 5 6 public class DataOutputStreamDemo{ 7 public static void main(String[] args) throws IOException{ 8 File file = new File("d:" + File.separator +"hello.txt"); 9 DataInputStream input = new DataInputStream(new FileInputStream(file)); 10 char[] ch = new char[10]; 11 int count = 0; 12 char temp; 13 while((temp = input.readChar()) != 'C'){ 14 ch[count++] = temp; 15 } 16 System.out.println(ch); 17 } 18 }
【案例】PushBackInputStream回退流操作
1 import java.io.ByteArrayInputStream; 2 import java.io.IOException; 3 import java.io.PushbackInputStream; 4 5 /** 6 * 回退流操作 7 * */ 8 public class PushBackInputStreamDemo{ 9 public static void main(String[] args) throwsIOException{ 10 String str = "hello,rollenholt"; 11 PushbackInputStream push = null; 12 ByteArrayInputStream bat = null; 13 bat = new ByteArrayInputStream(str.getBytes()); 14 push = new PushbackInputStream(bat); 15 int temp = 0; 16 while((temp = push.read()) != -1){ 17 if(temp == ','){ 18 push.unread(temp); 19 temp = push.read(); 20 System.out.print("(回退" +(char) temp + ") "); 21 }else{ 22 System.out.print((char) temp); 23 } 24 } 25 } 26 }
2. 输出字节流OutputStream
定义和结构说明:
IO 中输出字节流的继承图可见上图,可以看出:
OutputStream 是所有的输出字节流的父类,它是一个抽象类。
ByteArrayOutputStream、FileOutputStream是两种基本的介质流,它们分别向Byte 数组、和本地文件中写入数据。PipedOutputStream 是向与其它线程共用的管道中写入数据,
ObjectOutputStream 和所有FilterOutputStream的子类都是装饰流。具体例子跟InputStream是对应的。
实例操作演示:
【案例】向文件中写入字符串
1 /** 2 * 字节流 3 * 向文件中写入字符串 4 * */ 5 import java.io.*; 6 class hello{ 7 public static void main(String[] args) throws IOException { 8 String fileName="D:"+File.separator+"hello.txt"; 9 File f=new File(fileName); 10 OutputStream out =new FileOutputStream(f); 11 String str="Hello World"; 12 byte[] b=str.getBytes(); 13 out.write(b); 14 out.close(); 15 } 16 }
你也可以一个字节一个字节的写入文件:
【案例】逐字节写入文件
1 /** 2 * 字节流 3 * 向文件中一个字节一个字节的写入字符串 4 * */ 5 import java.io.*; 6 class hello{ 7 public static void main(String[] args) throws IOException { 8 String fileName="D:"+File.separator+"hello.txt"; 9 File f=new File(fileName); 10 OutputStream out =new FileOutputStream(f); 11 String str="Hello World!!"; 12 byte[] b=str.getBytes(); 13 for (int i = 0; i < b.length; i++) { 14 out.write(b[i]); 15 } 16 out.close(); 17 } 18 }
【案例】向文件中追加新内容
1 /** 2 * 字节流 3 * 向文件中追加新内容: 4 * */ 5 import java.io.*; 6 class hello{ 7 public static void main(String[] args) throws IOException { 8 String fileName="D:"+File.separator+"hello.txt"; 9 File f=new File(fileName); 10 OutputStream out =new FileOutputStream(f,true);//true表示追加模式,否则为覆盖 11 String str="Rollen"; 12 //String str=" Rollen"; 可以换行 13 byte[] b=str.getBytes(); 14 for (int i = 0; i < b.length; i++) { 15 out.write(b[i]); 16 } 17 out.close(); 18 } 19 }
【案例】复制文件
1 /** 2 * 文件的复制 3 * */ 4 import java.io.*; 5 class hello{ 6 public static void main(String[] args) throws IOException { 7 if(args.length!=2){ 8 System.out.println("命令行参数输入有误,请检查"); 9 System.exit(1); 10 } 11 File file1=new File(args[0]); 12 File file2=new File(args[1]); 13 14 if(!file1.exists()){ 15 System.out.println("被复制的文件不存在"); 16 System.exit(1); 17 } 18 InputStream input=new FileInputStream(file1); 19 OutputStream output=new FileOutputStream(file2); 20 if((input!=null)&&(output!=null)){ 21 int temp=0; 22 while((temp=input.read())!=(-1)){ 23 output.write(temp); 24 } 25 } 26 input.close(); 27 output.close(); 28 } 29 }
【案例】使用内存操作流将一个大写字母转化为小写字母
1 /** 2 * 使用内存操作流将一个大写字母转化为小写字母 3 * */ 4 import java.io.*; 5 class hello{ 6 public static void main(String[] args) throws IOException { 7 String str="ROLLENHOLT"; 8 ByteArrayInputStream input=new ByteArrayInputStream(str.getBytes()); 9 ByteArrayOutputStream output=new ByteArrayOutputStream(); 10 int temp=0; 11 while((temp=input.read())!=-1){ 12 char ch=(char)temp; 13 output.write(Character.toLowerCase(ch)); 14 } 15 String outStr=output.toString(); 16 input.close(); 17 output.close(); 18 System.out.println(outStr); 19 } 20 }
【案例】验证管道流:进程间通信
1 /** 2 * 验证管道流 3 * */ 4 import java.io.*; 5 6 /** 7 * 消息发送类 8 * */ 9 class Send implements Runnable{ 10 private PipedOutputStream out=null; 11 public Send() { 12 out=new PipedOutputStream(); 13 } 14 public PipedOutputStream getOut(){ 15 return this.out; 16 } 17 public void run(){ 18 String message="hello , Rollen"; 19 try{ 20 out.write(message.getBytes()); 21 }catch (Exception e) { 22 e.printStackTrace(); 23 }try{ 24 out.close(); 25 }catch (Exception e) { 26 e.printStackTrace(); 27 } 28 } 29 } 30 31 /** 32 * 接受消息类 33 * */ 34 class Recive implements Runnable{ 35 private PipedInputStream input=null; 36 public Recive(){ 37 this.input=new PipedInputStream(); 38 } 39 public PipedInputStream getInput(){ 40 return this.input; 41 } 42 public void run(){ 43 byte[] b=new byte[1000]; 44 int len=0; 45 try{ 46 len=this.input.read(b); 47 }catch (Exception e) { 48 e.printStackTrace(); 49 }try{ 50 input.close(); 51 }catch (Exception e) { 52 e.printStackTrace(); 53 } 54 System.out.println("接受的内容为 "+(new String(b,0,len))); 55 } 56 } 57 /** 58 * 测试类 59 * */ 60 class hello{ 61 public static void main(String[] args) throws IOException { 62 Send send=new Send(); 63 Recive recive=new Recive(); 64 try{ 65 //管道连接 66 send.getOut().connect(recive.getInput()); 67 }catch (Exception e) { 68 e.printStackTrace(); 69 } 70 new Thread(send).start(); 71 new Thread(recive).start(); 72 } 73 }
【案例】DataOutputStream类示例
1 import java.io.DataOutputStream; 2 import java.io.File; 3 import java.io.FileOutputStream; 4 import java.io.IOException; 5 public class DataOutputStreamDemo{ 6 public static void main(String[] args) throws IOException{ 7 File file = new File("d:" + File.separator +"hello.txt"); 8 char[] ch = { 'A', 'B', 'C' }; 9 DataOutputStream out = null; 10 out = new DataOutputStream(new FileOutputStream(file)); 11 for(char temp : ch){ 12 out.writeChar(temp); 13 } 14 out.close(); 15 } 16 }
【案例】ZipOutputStream类
先看一下ZipOutputStream类的继承关系
java.lang.Object
java.io.OutputStream
java.io.FilterOutputStream
java.util.zip.DeflaterOutputStream
java.util.zip.ZipOutputStream
1 import java.io.File; 2 import java.io.FileInputStream; 3 import java.io.FileOutputStream; 4 import java.io.IOException; 5 import java.io.InputStream; 6 import java.util.zip.ZipEntry; 7 import java.util.zip.ZipOutputStream; 8 9 public class ZipOutputStreamDemo1{ 10 public static void main(String[] args) throws IOException{ 11 File file = new File("d:" + File.separator +"hello.txt"); 12 File zipFile = new File("d:" + File.separator +"hello.zip"); 13 InputStream input = new FileInputStream(file); 14 ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream( 15 zipFile)); 16 zipOut.putNextEntry(new ZipEntry(file.getName())); 17 // 设置注释 18 zipOut.setComment("hello"); 19 int temp = 0; 20 while((temp = input.read()) != -1){ 21 zipOut.write(temp); 22 } 23 input.close(); 24 zipOut.close(); 25 } 26 }
【案例】ZipOutputStream类压缩多个文件
1 import java.io.File; 2 import java.io.FileInputStream; 3 import java.io.FileOutputStream; 4 import java.io.IOException; 5 import java.io.InputStream; 6 import java.util.zip.ZipEntry; 7 import java.util.zip.ZipOutputStream; 8 9 /** 10 * 一次性压缩多个文件 11 * */ 12 public class ZipOutputStreamDemo2{ 13 public static void main(String[] args) throws IOException{ 14 // 要被压缩的文件夹 15 File file = new File("d:" + File.separator +"temp"); 16 File zipFile = new File("d:" + File.separator + "zipFile.zip"); 17 InputStream input = null; 18 ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream( 19 zipFile)); 20 zipOut.setComment("hello"); 21 if(file.isDirectory()){ 22 File[] files = file.listFiles(); 23 for(int i = 0; i < files.length; ++i){ 24 input = newFileInputStream(files[i]); 25 zipOut.putNextEntry(newZipEntry(file.getName() 26 + File.separator +files[i].getName())); 27 int temp = 0; 28 while((temp = input.read()) !=-1){ 29 zipOut.write(temp); 30 } 31 input.close(); 32 } 33 } 34 zipOut.close(); 35 } 36 }
【案例】ZipFile类展示
1 import java.io.File; 2 import java.io.IOException; 3 import java.util.zip.ZipFile; 4 5 /** 6 *ZipFile演示 7 * */ 8 public class ZipFileDemo{ 9 public static void main(String[] args) throws IOException{ 10 File file = new File("d:" + File.separator +"hello.zip"); 11 ZipFile zipFile = new ZipFile(file); 12 System.out.println("压缩文件的名称为:" + zipFile.getName()); 13 } 14 }
【案例】解压缩文件(压缩文件中只有一个文件的情况)
1 import java.io.File; 2 import java.io.FileOutputStream; 3 import java.io.IOException; 4 import java.io.InputStream; 5 import java.io.OutputStream; 6 import java.util.zip.ZipEntry; 7 import java.util.zip.ZipFile; 8 9 /** 10 * 解压缩文件(压缩文件中只有一个文件的情况) 11 * */ 12 public class ZipFileDemo2{ 13 public static void main(String[] args) throws IOException{ 14 File file = new File("d:" + File.separator +"hello.zip"); 15 File outFile = new File("d:" + File.separator +"unZipFile.txt"); 16 ZipFile zipFile = new ZipFile(file); 17 ZipEntry entry =zipFile.getEntry("hello.txt"); 18 InputStream input = zipFile.getInputStream(entry); 19 OutputStream output = new FileOutputStream(outFile); 20 int temp = 0; 21 while((temp = input.read()) != -1){ 22 output.write(temp); 23 } 24 input.close(); 25 output.close(); 26 } 27 }
【案例】ZipInputStream类解压缩一个压缩文件中包含多个文件的情况
1 import java.io.File; 2 import java.io.FileInputStream; 3 import java.io.FileOutputStream; 4 import java.io.IOException; 5 import java.io.InputStream; 6 import java.io.OutputStream; 7 import java.util.zip.ZipEntry; 8 import java.util.zip.ZipFile; 9 import java.util.zip.ZipInputStream; 10 11 /** 12 * 解压缩一个压缩文件中包含多个文件的情况 13 * */ 14 public class ZipFileDemo3{ 15 public static void main(String[] args) throws IOException{ 16 File file = new File("d:" +File.separator + "zipFile.zip"); 17 File outFile = null; 18 ZipFile zipFile = new ZipFile(file); 19 ZipInputStream zipInput = new ZipInputStream(new FileInputStream(file)); 20 ZipEntry entry = null; 21 InputStream input = null; 22 OutputStream output = null; 23 while((entry = zipInput.getNextEntry()) != null){ 24 System.out.println("解压缩" + entry.getName() + "文件"); 25 outFile = new File("d:" + File.separator + entry.getName()); 26 if(!outFile.getParentFile().exists()){ 27 outFile.getParentFile().mkdir(); 28 } 29 if(!outFile.exists()){ 30 outFile.createNewFile(); 31 } 32 input = zipFile.getInputStream(entry); 33 output = new FileOutputStream(outFile); 34 int temp = 0; 35 while((temp = input.read()) != -1){ 36 output.write(temp); 37 } 38 input.close(); 39 output.close(); 40 } 41 } 42 }
3.几个特殊的输入流类分析
LineNumberInputStream
主要完成从流中读取数据时,会得到相应的行号,至于什么时候分行、在哪里分行是由改类主动确定的,并不是在原始中有这样一个行号。在输出部分没有对应的部分,我们完全可以自己建立一个LineNumberOutputStream,在最初写入时会有一个基准的行号,以后每次遇到换行时会在下一行添加一个行号,看起来也是可以的。好像更不入流了。
PushbackInputStream
其功能是查看最后一个字节,不满意就放入缓冲区。主要用在编译器的语法、词法分析部分。输出部分的BufferedOutputStream 几乎实现相近的功能。
StringBufferInputStream
已经被Deprecated,本身就不应该出现在InputStream部分,主要因为String 应该属于字符流的范围。已经被废弃了,当然输出部分也没有必要需要它了!还允许它存在只是为了保持版本的向下兼容而已。
SequenceInputStream
可以认为是一个工具类,将两个或者多个输入流当成一个输入流依次读取。完全可以从IO 包中去除,还完全不影响IO 包的结构,却让其更“纯洁”――纯洁的Decorator 模式。
【案例】将两个文本文件合并为另外一个文本文件
1 import java.io.File; 2 import java.io.FileInputStream; 3 import java.io.FileOutputStream; 4 import java.io.IOException; 5 import java.io.InputStream; 6 import java.io.OutputStream; 7 import java.io.SequenceInputStream; 8 9 /** 10 * 将两个文本文件合并为另外一个文本文件 11 * */ 12 public class SequenceInputStreamDemo{ 13 public static voidmain(String[] args) throws IOException{ 14 File file1 = newFile("d:" + File.separator + "hello1.txt"); 15 File file2 = newFile("d:" + File.separator + "hello2.txt"); 16 File file3 = newFile("d:" + File.separator + "hello.txt"); 17 InputStream input1 =new FileInputStream(file1); 18 InputStream input2 =new FileInputStream(file2); 19 OutputStream output =new FileOutputStream(file3); 20 // 合并流 21 SequenceInputStreamsis = new SequenceInputStream(input1, input2); 22 int temp = 0; 23 while((temp =sis.read()) != -1){ 24 output.write(temp); 25 } 26 input1.close(); 27 input2.close(); 28 output.close(); 29 sis.close(); 30 } 31 }
PrintStream
也可以认为是一个辅助工具。主要可以向其他输出流,或者FileInputStream 写入数据,本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以踢出IO 包!System.err和System.out 就是PrintStream 的实例!
【案例】使用PrintStream进行输出
1 /** 2 * 使用PrintStream进行输出 3 * */ 4 import java.io.*; 5 6 class hello { 7 public static void main(String[] args) throws IOException { 8 PrintStream print = new PrintStream(new FileOutputStream(newFile("d:" 9 + File.separator +"hello.txt"))); 10 print.println(true); 11 print.println("Rollen"); 12 print.close(); 13 } 14 }
【案例】使用PrintStream进行格式化输出
1 /** 2 * 使用PrintStream进行输出 3 * 并进行格式化 4 * */ 5 import java.io.*; 6 class hello { 7 public static void main(String[] args) throws IOException { 8 PrintStream print = new PrintStream(new FileOutputStream(newFile("d:" 9 + File.separator +"hello.txt"))); 10 String name="Rollen"; 11 int age=20; 12 print.printf("姓名:%s. 年龄:%d.",name,age); 13 print.close(); 14 } 15 }
【案例】使用OutputStream向屏幕上输出内容
1 /** 2 * 使用OutputStream向屏幕上输出内容 3 * */ 4 import java.io.*; 5 class hello { 6 public static void main(String[] args) throws IOException { 7 OutputStream out=System.out; 8 try{ 9 out.write("hello".getBytes()); 10 }catch (Exception e) { 11 e.printStackTrace(); 12 } 13 try{ 14 out.close(); 15 }catch (Exception e) { 16 e.printStackTrace(); 17 } 18 } 19 }
【案例】输入输出重定向
1 import java.io.File; 2 import java.io.FileNotFoundException; 3 import java.io.FileOutputStream; 4 import java.io.PrintStream; 5 6 /** 7 * 为System.out.println()重定向输出 8 * */ 9 public class systemDemo{ 10 public static void main(String[] args){ 11 // 此刻直接输出到屏幕 12 System.out.println("hello"); 13 File file = new File("d:" + File.separator +"hello.txt"); 14 try{ 15 System.setOut(new PrintStream(new FileOutputStream(file))); 16 }catch(FileNotFoundException e){ 17 e.printStackTrace(); 18 } 19 System.out.println("这些内容在文件中才能看到哦!"); 20 } 21 }
【案例】使用System.err重定向
1 import java.io.File; 2 import java.io.FileNotFoundException; 3 import java.io.FileOutputStream; 4 import java.io.PrintStream; 5 6 /** 7 *System.err重定向这个例子也提示我们可以使用这种方法保存错误信息 8 * */ 9 public class systemErr{ 10 public static void main(String[] args){ 11 File file = new File("d:" + File.separator +"hello.txt"); 12 System.err.println("这些在控制台输出"); 13 try{ 14 System.setErr(new PrintStream(new FileOutputStream(file))); 15 }catch(FileNotFoundException e){ 16 e.printStackTrace(); 17 } 18 System.err.println("这些在文件中才能看到哦!"); 19 } 20 }
【案例】System.in重定向
1 import java.io.File; 2 import java.io.FileInputStream; 3 import java.io.FileNotFoundException; 4 import java.io.IOException; 5 /** 6 *System.in重定向 7 * */ 8 public class systemIn{ 9 public static void main(String[] args){ 10 File file = new File("d:" + File.separator +"hello.txt"); 11 if(!file.exists()){ 12 return; 13 }else{ 14 try{ 15 System.setIn(newFileInputStream(file)); 16 }catch(FileNotFoundException e){ 17 e.printStackTrace(); 18 } 19 byte[] bytes = new byte[1024]; 20 int len = 0; 21 try{ 22 len = System.in.read(bytes); 23 }catch(IOException e){ 24 e.printStackTrace(); 25 } 26 System.out.println("读入的内容为:" + new String(bytes, 0, len)); 27 } 28 } 29 }
4.字符输入流Reader
定义和说明:
在上面的继承关系图中可以看出:
Reader 是所有的输入字符流的父类,它是一个抽象类。
CharReader、StringReader是两种基本的介质流,它们分别将Char 数组、String中读取数据。PipedReader 是从与其它线程共用的管道中读取数据。
BufferedReader 很明显就是一个装饰器,它和其子类负责装饰其它Reader 对象。
FilterReader 是所有自定义具体装饰流的父类,其子类PushbackReader 对Reader 对象进行装饰,会增加一个行号。
InputStreamReader 是一个连接字节流和字符流的桥梁,它将字节流转变为字符流。FileReader可以说是一个达到此功能、常用的工具类,在其源代码中明显使用了将FileInputStream 转变为Reader 的方法。我们可以从这个类中得到一定的技巧。Reader 中各个类的用途和使用方法基本和InputStream 中的类使用一致。后面会有Reader 与InputStream 的对应关系。
实例操作演示:
【案例】从文件中读取内容
1 /** 2 * 字符流 3 * 从文件中读出内容 4 * */ 5 import java.io.*; 6 class hello{ 7 public static void main(String[] args) throws IOException { 8 String fileName="D:"+File.separator+"hello.txt"; 9 File f=new File(fileName); 10 char[] ch=new char[100]; 11 Reader read=new FileReader(f); 12 int count=read.read(ch); 13 read.close(); 14 System.out.println("读入的长度为:"+count); 15 System.out.println("内容为"+new String(ch,0,count)); 16 } 17 }
注意:当然最好采用循环读取的方式,因为我们有时候不知道文件到底有多大。
【案例】以循环方式从文件中读取内容
1 /** 2 * 字符流 3 * 从文件中读出内容 4 * */ 5 import java.io.*; 6 class hello{ 7 public static void main(String[] args) throws IOException { 8 String fileName="D:"+File.separator+"hello.txt"; 9 File f=new File(fileName); 10 char[] ch=new char[100]; 11 Reader read=new FileReader(f); 12 int temp=0; 13 int count=0; 14 while((temp=read.read())!=(-1)){ 15 ch[count++]=(char)temp; 16 } 17 read.close(); 18 System.out.println("内容为"+new String(ch,0,count)); 19 } 20 }
【案例】BufferedReader 的小例子
注意:BufferedReader 只能接受字符流的缓冲区,因为每一个中文需要占据两个字节,所以需要将System.in这个字节输入流变为字符输入流,采用:
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
下面是一个实例:
1 import java.io.BufferedReader; 2 import java.io.IOException; 3 import java.io.InputStreamReader; 4 5 /** 6 * 使用缓冲区从键盘上读入内容 7 * */ 8 public class BufferedReaderDemo{ 9 public static void main(String[] args){ 10 BufferedReader buf = new BufferedReader( 11 newInputStreamReader(System.in)); 12 String str = null; 13 System.out.println("请输入内容"); 14 try{ 15 str = buf.readLine(); 16 }catch(IOException e){ 17 e.printStackTrace(); 18 } 19 System.out.println("你输入的内容是:" + str); 20 } 21 }
【案例】Scanner类实例
1 import java.util.Scanner; 2 /** 3 *Scanner的小例子,从键盘读数据 4 * */ 5 public class ScannerDemo{ 6 publicstatic void main(String[] args){ 7 Scanner sca = new Scanner(System.in); 8 // 读一个整数 9 int temp = sca.nextInt(); 10 System.out.println(temp); 11 //读取浮点数 12 float flo=sca.nextFloat(); 13 System.out.println(flo); 14 //读取字符 15 //...等等的,都是一些太基础的,就不师范了。 16 } 17 }
【案例】Scanner类从文件中读出内容
1 import java.io.File; 2 import java.io.FileNotFoundException; 3 import java.util.Scanner; 4 5 /** 6 *Scanner的小例子,从文件中读内容 7 * */ 8 public class ScannerDemo{ 9 public static void main(String[] args){ 10 11 File file = new File("d:" + File.separator +"hello.txt"); 12 Scanner sca = null; 13 try{ 14 sca = new Scanner(file); 15 }catch(FileNotFoundException e){ 16 e.printStackTrace(); 17 } 18 String str = sca.next(); 19 System.out.println("从文件中读取的内容是:" + str); 20 } 21 }
5.字符输出流Writer
定义和说明:
在上面的关系图中可以看出:
Writer 是所有的输出字符流的父类,它是一个抽象类。
CharArrayWriter、StringWriter 是两种基本的介质流,它们分别向Char 数组、String 中写入数据。
PipedWriter 是向与其它线程共用的管道中写入数据,
BufferedWriter 是一个装饰器为Writer 提供缓冲功能。
PrintWriter 和PrintStream 极其类似,功能和使用也非常相似。
OutputStreamWriter 是OutputStream 到Writer 转换的桥梁,它的子类FileWriter 其实就是一个实现此功能的具体类(具体可以研究一SourceCode)。功能和使用和OutputStream 极其类似,后面会有它们的对应图。
实例操作演示:
【案例】向文件中写入数据
1 /** 2 * 字符流 3 * 写入数据 4 * */ 5 import java.io.*; 6 class hello{ 7 public static void main(String[] args) throws IOException { 8 String fileName="D:"+File.separator+"hello.txt"; 9 File f=new File(fileName); 10 Writer out =new FileWriter(f); 11 String str="hello"; 12 out.write(str); 13 out.close(); 14 } 15 }
注意:这个例子上之前的例子没什么区别,只是你可以直接输入字符串,而不需要你将字符串转化为字节数组。当你如果想问文件中追加内容的时候,可以使用将上面的声明out的哪一行换为:
Writer out =new FileWriter(f,true);
这样,当你运行程序的时候,会发现文件内容变为:hellohello如果想在文件中换行的话,需要使用“ ”比如将str变为String str=" hello";这样文件追加的str的内容就会换行了。
6.字符流与字节流转换
转换流的特点:
(1)其是字符流和字节流之间的桥梁
(2)可对读取到的字节数据经过指定编码转换成字符
(3)可对读取到的字符数据经过指定编码转换成字节
何时使用转换流?
当字节和字符之间有转换动作时;
流操作的数据需要编码或解码时。
注意:字节流转换为字符流只针对文本,假如操作的是图片等信息,从字节流转换成字符流,会造成数据损坏。
具体的对象体现:
InputStreamReader:字节到字符的桥梁
OutputStreamWriter:字符到字节的桥梁
这两个流对象是字符体系中的成员,它们有转换作用,本身又是字符流,所以在构造的时候需要传入字节流对象进来。
字节流和字符流转换实例:
【案例】将字节输出流转化为字符输出流
1 /** 2 * 将字节输出流转化为字符输出流 3 * */ 4 import java.io.*; 5 class hello{ 6 public static void main(String[] args) throws IOException { 7 String fileName= "d:"+File.separator+"hello.txt"; 8 File file=new File(fileName); 9 Writer out=new OutputStreamWriter(new FileOutputStream(file)); 10 out.write("hello"); 11 out.close(); 12 } 13 }
【案例】将字节输入流转换为字符输入流
1 /** 2 * 将字节输入流变为字符输入流 3 * */ 4 import java.io.*; 5 class hello{ 6 public static void main(String[] args) throws IOException { 7 String fileName= "d:"+File.separator+"hello.txt"; 8 File file=new File(fileName); 9 Reader read=new InputStreamReader(new FileInputStream(file)); 10 char[] b=new char[100]; 11 int len=read.read(b); 12 System.out.println(new String(b,0,len)); 13 read.close(); 14 } 15 }