IO(Input Output)流
- IO流用来处理设备之间的数据传输
- Java对数据的操作时通过流的方式
- Java用于操作流的对象都在IO包中
- 流按操作数据分为两种: 字节流和字符流
- 流按类型分为: 输入流, 输出流
IO流常用基类
- 字节流的抽象基类对象: InputStream, OutputStream
- 字符流的抽象基类对象: Reader, Writer
注:有这四个类派生出来的子类名称都是由其父类名作为子类名的后缀.
如: InputStream 的子类 FileInputStream
如: Reade r的子类 FileReader
完整的流家族
输入流与输出流的层次结构
Reader 和 Writer 的层次结构
FileReader和FileWriter流
创建一个 FileWriter 对象,该文件会在指定目录下创建.
如果同名则覆盖, 除非构造方法第二个参数append 为 true; 由此可得默认为false.
/** * * @param str * String to be written * * @throws IOException */ public static void createFile(String str) throws IOException{ //在D盘下创建abc.txt. 如果同名则覆盖,除非构造方法第二个参数append为true; File file = new File("D:" + File.separator + "abc.txt"); FileWriter fw = new FileWriter(file, false); fw.write(str); fw.flush(); //关闭流对象,之前会flash一次缓冲中的数据. fw.close(); //与flush的区别: flush刷新后流可以继续使用,close却将流关闭,不可再写入 }
IO异常的标准处理方式一(以FileWriter为例)
String fileName = "D:" + File.separatorChar + "abc.txt"; FileWriter fw = null; try { fw = new FileWriter(fileName); fw.write("balabala..."); fw.flush(); } catch (IOException e) { //检查异常转为非检查异常 throw new RuntimeException("产生IO异常"); } finally { if (fw != null) try { fw.close(); } catch (IOException e) { throw new RuntimeException("流关闭异常"); } }
IO异常的标准处理方式二(SE 7 try-with-resources方式)
String fileName = "D:" + File.separatorChar + "abc.txt"; try (FileWriter fw = new FileWriter(fileName)) { fw.write("balabala..."); fw.flush(); } catch (IOException e) { //检查异常转为非检查异常 throw new RuntimeException("产生IO异常"); }
使用FileReader读取文本文件方式一
int ch = 0; while((ch=fr.read())!=-1){ //relevant operation }
使用FileReader读取文本文件方式二(较方法一好,推荐使用)
int len= 0; char[] buf = new char[1024]; while((len=fr.read(buf))!=-1){ //relevant operation }
拷贝文件(建议使用方式二)
//relevant operation --> fileWriter.write(buf,0,len);
字符流的缓冲流BufferedReader与BufferedWriter
- 提高了对数据的读写效率
- 对应类:BufferedReader和BufferedWriter
- 缓冲区要结合流才可以使用
- 在流的基础上对流的功能进行了增强
BufferedWriter
- 为提高字符写入流的效率,只要将需要提高效率的流对象作为参数传递到BufferedWriter的构造方法.
- BufferedWriter有自己特有的readLine()方法, 这是不包含行结束符的
- 如果需要每次换行则bfr.newLine(), 并且还要flush()一下.最后不要忘记close流.
//我的理解是BufferedWriter和BufferedReader都是基于原流,且衷于原流.提供了每行的写与读,而不参杂多余的行终止符.所以要每次自己换行.
BufferedReader
读取数据
String line = null; while((line=bfr.readLine())!=null){ //relevant operation }
使用BufferedWriter, BufferedReader拷贝文件关键代码
String line = null; while((line=bfr.readLine())!=null){ bfr.write(line); bfr.newLine(); bfr.flush(); }
牵扯到装饰设计模式
- 当先要对已有对象进行功能增强时,可以定义类,将已有对象传入,基于已有的功能,并提供加强功能.
- 装饰类通常会通过构造方法接收被装饰的对象,并基于被装饰的对象的功能,提供更强的功能.
- 装饰模式比继承要灵活,避免了继承体系臃肿.而且降低了类与类之间的关系,装饰类因为增强已有对象,具备的功能和已有的是相同的,只不过提供了更强功能.所以装饰类和比装饰类通常是都属于一个体系中.
LineNumberReader
BufferedReader()的子类,只是多了标号而已.
通过setLineNumber设置初始行号, 和输出可以getLineNumber获取每行的行号
字节流FileOutputStream和FileInputStream
可以进行二进制形式进行图片, 音乐等文件的读写.
//拷贝一个图片 public static void copyFile() throws IOException{ InputStream fis = new FileInputStream("D:\\source.jpg" ); OutputStream fos = new FileOutputStream("D:\\dst.jpg" ); int len = 0; byte[] buf = new byte[1024]; while((len=fis.read(buf))!=-1){ fos.write(buf, 0, len); } fis.close();
拷贝一首歌(使用字节流的Buffered缓冲区)
InputStream inputStream = new BufferedInputStream( new FileInputStream("D:" + File.separator + "刘涛 - 说不出口.mp3")); OutputStream outputStream = new BufferedOutputStream( new FileOutputStream("D:" + File.separator + "刘某 - 就不要说.mp3"));
键盘录入(InputStreamReader和OutputStreamWriter转换流)
System.out: 对应的是标准输入设备,控制台
System.in: 对应的是标准输出设备,键盘
练习: 通过键盘录入,当输入一行数据后将改行数据进行打印,如果录入的数据是over,那么停止录入.
//方法一: 传统思考 //要点记住回车的处理方式: ASCII码 13 '\r', 10 '\n' public static void method1() throws IOException{ final InputStream in = System.in; int character ; final StringBuilder stringBuilder = new StringBuilder(); while(true){ character = in.read(); switch (character) { case '\r': break; case '\n': final String result = stringBuilder.toString(); if("over".equals(result)){ return; } //StringBuilder的清空方式 stringBuilder.delete(0, stringBuilder.length()); break; default: stringBuilder.append((char)character); break; } } } //方法二: InputStreamReader转换流,将字节流转成字符流的桥梁,然后经缓冲包装提高效率 public static void method2() throws IOException{ final InputStream in = System.in; final BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(in)); String line = null; while ((line = bufferedReader.readLine()) != null) { if("over".equals(line)){ break; } } } //方法三: Scanner [5.0] public static void method3(String[] args) throws IOException { final InputStream in = System.in; String line = null; final Scanner scanner = new Scanner(in); while(scanner.hasNextLine()){ line = scanner.nextLine(); if("over".equals(line)){ break; } } }
OutputStreamWriter转换流
和InputStreamReader类似,是字符流通向字节流的桥梁.只是包装System.out在缓冲后.
OutputStream os = System.out; OutputStreamWriter outputStreamWriter = new OutputStreamWriter(os); outputStreamWriter.write("cba"); outputStreamWriter.flush(); outputStreamWriter.close();
流操作规律
- 明确源和目的
- 是否是纯文本(字节流 和 字符流的选取), 具体使用哪个对象
- 是否需要提高效率而加入缓冲
这其中涉及到的OutputStream(OutputStream out, String charsetName)就是字符转字节的桥梁,并可以指定自定义编码,例如"UTF-8",这也是转换流出现的原因.
改变标准输入输出设备
System的setIn()方法 重新分配“标准”输入流。否则标准输入流一般都是键盘InputStream.
System的setOut()方法 重新分配“标准”输出流。否则标准输入流一般都是键盘PrintStream.
可以利用这两个已关联的流进行相关操作
打印流 PrintStream和PrintWriter
该流提供了打印方法,可以将各种类型的数据原样打印.
PrintStream
PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。它还提供其他两项功能。与其他输出流不同，PrintStream 永远不会抛出 IOException；而是，异常情况仅设置可通过 checkError 方法测试的内部标志。另外，为了自动刷新，可以创建一个 PrintStream；这意味着可在写入 byte 数组之后自动调用 flush 方法，可调用其中一个 println 方法，或写入一个换行符或字节 ('\n')。
PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
PrintWriter
- 增加了字符输出流Writer
// 设置自动刷新 PrintWriter pw = new PrintWriter(System.out, true); String line = null; BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in)); while ((line = bfr.readLine()) != null) { // 这样写比用BufferedWriter更简洁.PrintWriter更适合打印各种数据. pw.println(line); }
序列流SequenceInputStream(**表示其他输入流的逻辑串联,没有对应的输出流)
练习: 文件的分割与合并
//切割只用字节流,而不是字符流 public static void split() throws IOException{ FileInputStream fis = new FileInputStream("d:\\123.pdf" ); FileOutputStream fos = null; int len = 0; //1M=1024KB=1024*1024字节 存储 byte[] buf = new byte[1024*1024]; int i=0; while((len=fis.read(buf))!=-1){ fos = new FileOutputStream("d:\\" +(++i)+ ".part"); fos.write(buf, 0, len); fos.flush(); fos.close();; } fis.close(); } //文件合并 public static void meger() throws IOException{ Vector<FileInputStream> v = new Vector<FileInputStream> (); for(int i=1;i<4;i++) v.add( new FileInputStream("d:\\" + i+".part")); SequenceInputStream sis = new SequenceInputStream(v.elements()); FileOutputStream fos = new FileOutputStream("d:\\kk.pdf" ); int len = 0; byte[] buf = new byte[1024]; while((len=sis.read(buf))!=-1){ fos.write(buf, 0, len); } sis.close(); fos.close(); }
操作对象的ObjectInputStream与ObjectOutputStream
- 被操作的对象需要实现Serializable(标记接口)
- 可序列化类可以通过声明名为 "serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID
ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;
这样生成新的类不会改变UID,而不是使用系统生成的UID.
- 另外非静态成员变量可以transient修饰不被序列化,同样类(static)变量也不会序列化.
管道流PipedInputStram和PipedOutputStream
- 输入输出可以直接连接,结合线程使用
PipedInputStream,接收InputStream对象
用于与另一输出管道相连, 读取写入到输出管道中的数据,用于程序中线程的通信
PipedOutputStream, 可以将管道输出流连接到管道输入流来创建通信管道。管道输出流是管道的发送端。通常，数据由某个线程写入 PipedOutputStream 对象，并由其他线程从连接的 PipedInputStream 读取。
public class DemoPipedStream { public static void main(String[] args) throws IOException { //建立管道读入流 PipedInputStream pis = new PipedInputStream(); //建立管道输出流并与读入流关联,也可以写成connect PipedOutputStream pos = new PipedOutputStream(pis); new Thread(new Write(pos)).start(); new Thread(new Read(pis)).start(); } } class Read implements Runnable{ private PipedInputStream pis; public Read(PipedInputStream pis){ this.pis = pis; } @Override public void run(){ byte[] buf = new byte[200]; try{ System.out.println("---读取流开始获取信息"); int len = pis.read(buf); System.out.println("--"+new String(buf,0,len)); System.out.println("---读取流读取流信息完毕"); }catch(IOException e){ throw new RuntimeException("流读取异常"); } finally{ if(pis!=null) try{pis.close();} catch(IOException e){ throw new RuntimeException("流关闭异常"); } } } } class Write implements Runnable{ private PipedOutputStream pos; public Write(PipedOutputStream pos){ this.pos = pos; } public void run(){ try { System.out.println("写入流开始写入流信息,持续3S"); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } pos.write("Hello PipedStram".getBytes()); System.out.println("写入流开始写入完毕"); } catch (IOException e) { throw new RuntimeException("流写入异常"); } finally{ if(pos!=null) try{pos.close();} catch(IOException e){ throw new RuntimeException("流关闭异常"); } } } }
RandomAccessFile
可以在文件中的任何位置查找或写入数据。磁盘文件都是随机访问的，但是从网络而来的数据流却不是。你可以打开一个随机访问文件，只用于读入或者同
时用于读写.
构造器的第二个参数来指定这个选项。
- “ r”表示只读模式；
- “ rw”表示读 / 写模式；
- “ rws”表示每次更新时，都对数据和元数据的写磁盘操作进行同步的读 / 写模式；
- “ rwd”表示每次更新时，只对数据的写磁盘操作进行同步的读 / 写模式
//调整对象中指针 seek(long pos) //尝试跳过输入的 n 个字节以丢弃跳过的字节。 skipBytes()
操作基本数据类型
以二进制格式读写基本Java类型
DataInputStream与DataOutputstream
操作字节数组
ByteArrayInputStream与ByteArrayOutputStream
操作字符数组
CharArrayReader与CharArrayWriter
操作字符串
StringReader与StringWriter
总结:
以二进制格式写出数据，需要使用 DataOutputStream。
以文本格式写出数据，需要使用 PrintWriter。
PrintWriter printWriter = new PrintWriter("setting.dat", "UTF-8");
字符集
在过去，国际化字符集已经得到了处理，但是处理得很不系统，散布在 Java 类库的各处。在 Java SE 1.4 中引入的 java.nio 包用 Charset 类统一了对字符集的转换（注意 s 是小写的）。
//获取Charset实例 Charset.defaultCharset(); //默认字符集 Charset charset = Charset.forName("UTF-8");//静态获取指定字符集 //Returns a set containing this charset's aliases. for(String alias: charset.aliases()){ System.out.println(alias); } //编码Java字符串 ByteBuffer bytBuffer = charset.encode("自古中秋月最明, 凉风届候夜弥清"); byte[] bytes = bytBuffer.array(); //要想解码字节序列，需要有字节缓冲区 CharBuffer cbuf = charset.decode(bytBuffer); System.out.println(cbuf.toString());
字符编码
//"你好"-->"??"是GBK变utf-8 ; -->"浣犲ソ"是utf-8变GBK
编一次解一次即可.
关闭流
总体可以认为是“先开后关”原则，原因是 IO 流的打开顺序是固定且层层依托的。
然后是closeable关闭的优化
如果new FileOutputStream, 然后上级目录不存在会抛出FileNotFoundException异常, 所以需要先行创建上层文件夹。
