IO系统

IO种类：文件、控制台、网络连接

---

1.字节流

1.1InputStream子类简单说明：

• ByteArrayInputStream：包含一个内部缓冲区，该缓冲区中包含从流中读取的字节

• FileInputStream：从文件系统的某个文件中获得输入字节，可以通过String、File或FileDescriptor 作为数据源使用

• FilterInputStream：包含其他一些输入流，可将这些流作为基本数据源‘’

• ObjectInputStream：与FileInputStream一起使用时，为应用程序提供对象图形的持久存储；用于恢复序列化的对象

• PipedInputStream：管道输入流应该连接到管道输出流，提供要写到管道输出流的所有字节。通常，数据由某个线程从管道输入流读取，并由其他线程将其写入到相应的管道输出流

• SequenceInputStream：其他输入流的逻辑串联，从输入流的有序集合开始，从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，以此类推，直到到达包含的最后一个输入流的文件末尾位置

• StringBufferInputStream：（已过时，不能将字符转换成字节，从字符串创建流的首选方法通过SringReader类进行创建）为应用程序创建输入流，流中数据由字符串内容提供

1.1.1FilterInputStream主要子类简单说明：

• BufferedInputStream：为输入流添加功能，包括缓冲输入等，每次读取先在缓冲区中读取

• DataInputStream：数据输入流，读取基本类型数据以及String对象，跨平台

• DeflaterInputStream：为实现压缩数据实现输入流过滤器

• InflaterInputStream：解压缩

1.2OutputStream子类简单说明：

• ByteArrayOutputStream：在内存中创建一个缓冲区，发送给流的所有数据都会置入这个缓冲区（byte[]数组），缓冲区随着数据的写入不断增长

• FileOutputStream：将数据写入File或FileDescriptor的输出流

• FilterOutputStream：过滤输出流，提供一些额外功能

• ObjectOutputStream：将java对象的基本数据类型和图形写入OutputStream，实现对象持久化

• PipedOutputStream：管道输出流

1.2.1FilterOutputStream子类简单说明：

• BufferedOutputStream：实现缓冲的输出流

• DataOutputStream：数据输出流

• DeflatOutputStream：压缩数据输出流过滤器

• InflatOutputStream：解压缩数据输出流过滤器

• PrintStream：格式化输出，比如输出到缓冲台

2.字符流

2.1Reader子类说明：

• BufferReader：实现缓冲的字符输入流

• FiletrReader：读取已过滤的字符流的抽象类

• InputStreamReader：字节流与字符流之间的桥梁

  • FileReader：读取字符文件的便捷类

• PipedReader：管道输入流

• StringReader：源为字符串的输入流

2.2Writer子类说明：

• BufferedWriter：实现缓冲的字符输出流

• FilterWriter：写入已过滤的字符流的抽象类

• OutputStreamWriter：字符流与字节流的桥梁

• PipedWriter：管道输出流

• PrintWriter：向文本输出流打印对象的格式化表示形式

• StringWriter：源为字符串的输出流

3.RandomAcessFile：

包含了已知长度记录的文件，以便我们能用seek()从一条记录移至另一条，然后读取和修改记录，各记录长度并不一定相同，只要知道它们有多大位于文件何处即可。

不属于InputStream或OutputStream分层结构的一部分，与其他IO类型有完全不同的行为，我们可以在一个文件里向前或向后移动，搜索，标记位置等；类似InputStream和OutputStream的联合使用。

4.File：

既代表一个特定文件的名字，也代表目录内一系列文件的名字。

目录列表器：观看一个目录列表，可以有俩种方式。
1.不含参数情况下调用list()–得到完整的列表
2.目录过滤器–对显示进行限制

package com.zd.java.io;import java.io.File;import java.io.FilenameFilter;/** * 列出目录列表，不含参数情况下调用list会获得file对象包含的完整列表 * 若对列表进行限制，需要采用目录过滤器 *  * 利用内部类创建精简的类，以解决一些复杂问题 * Created by ZD on 2017/10/11. */public class DirList3 {    public static void main(final String[] args){        File path = new File(".");        String[] list;        if (args.length == 0){            list = path.list();        }else {            list = path.list(new FilenameFilter() {//目录过滤器                @Override                public boolean accept(File dir, String name) {//list()方法需要回调accept()方法                    String f = new File(name).getName();                    return f.indexOf(args[0]) != -1;                }            });            for (int i = 0; i < list.length; i++){                System.out.println(list[i]);            }        }    }}

File类不仅仅是对现有目录路径、文件或文件组的一个表示；也可用file对象新建一个目录，甚至创建一个完整的目录路径；也可用它了解文件的属性，检查一个file对象到底代表一个文件还是一个目录；以及删除一个文件。

5.IO字节流的典型应用：

尽管库内存在大量IO流内，可通过多种方式组合到一起，但实际上只有几种方式才会经常用到。

package com.zd.java.io;import com.zd.java.io.quick.InFile;import com.zd.java.io.quick.OutFile;import com.zd.java.io.quick.PrintFile;import java.io.*;/** * IO字节流配置的创建与使用 * Created by ZD on 2017/10/11. */public class IOStreamDemo {    public static void main(String[] args){        try {            //1.Buffered input file--缓冲的输入文件            //打开文件FileInputStream，缓冲处理BufferedInputStream，格式化输入DataInputStream            DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream("test.out"));            String s,s2 = new String();//s2聚集完整的文件内容，包括换行，换行在readline中被去掉            while ((s = in.readLine()) != null){                s2 += s + "\n";            }            in.close();            //2.Input from memory--从内存输入            //s2已包含完整文件内容            StringBufferInputStream in2 = new StringBufferInputStream(s2);//字符串缓冲输入流            int c;            while ((c = in2.read()) != -1){//使用read()依次读取每个字符，read()将下一个字节返回为int，需要造型                System.out.println((char) c);            }            //3.formatted memory input-格式化内存输入            //使用DataInputStream重新封装            try{                DataInputStream in3 = new DataInputStream(new StringBufferInputStream(s2));                while (true){                    System.out.println((char)in3.readByte());//readByte()每次读取一个字符，所有制均有效                }            }catch (EOFException e){                System.out.println("end of stream encountered");            }            //4.line numbering & file output-行的编号与文件输出            //LineNumberInputStream跟踪输入行的编号            try{                LineNumberInputStream li = new LineNumberInputStream(new StringBufferInputStream(s2));                DataInputStream in4 = new DataInputStream(li);                //格式化写入一个文件，FileOutputStream-连接文件，BufferedOutputStream-输出缓冲流，PrintStream--格式化输出                PrintStream out1 = new PrintStream(new BufferedOutputStream(new FileOutputStream("IODemo.out")));                while((s = in4.readLine()) != null){                    out1.println("line "+li.getLineNumber());                }                out1.close();            }catch (EOFException e){                System.out.println("end of stream encountered");            }            //5.Storing & recovering data--保存与恢复数据            //PrintStream--格式化数据，按人习惯阅读，但为输出数据，以便另一个数据流恢复，使用DataOutputStream写入数据            //并用DataInputStream恢复数据            try{                DataOutputStream out2 = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("Data.txt")));                out2.writeBytes("here is the value of pi:\n");                out2.writeDouble(3.14159);                out2.close();                DataInputStream in5 = new DataInputStream(new BufferedInputStream(new FileInputStream("Data.txt")));                System.out.println(in5.readLine());                System.out.println(in5.readDouble());            }catch (EOFException e){                System.out.println("end of stream encountered");            }            //6.reading/writing random access files--读写随机访问文件            //RandomAccessFile            RandomAccessFile rf = new RandomAccessFile("rtest.dat","rw");            for (int i = 0; i < 10; i++){                rf.writeDouble(i*1.414);            }            rf.close();            rf = new RandomAccessFile("rtest.dat","rw");            rf.seek(5*8);            rf.writeDouble(47.0001);            rf.close();            rf = new RandomAccessFile("rtest.dat","r");            for (int i = 0; i < 10; i++) {                System.out.println("Value " + i + ":" + rf.readDouble());            }            rf.close();            //7.file input shorthand--快速文件输入            //减少创建文件时重复InputStream等操作            InFile in6 = new InFile(args[0]);            String s3 = new String();            System.out.println("first line in file:"+            in6.readLine());            in6.close();            //8.formatted file output shorthand--快速输出格式化恩建            PrintFile out3 = new PrintFile("Data2.txt");            out3.print("test of printFile");            out3.close();            //9.data file output shorthand--快速输出数据文件            OutFile out4 = new OutFile("Data3.txt");            out4.writeBytes("test of outData file\n\r");            out4.writeChars("test of outdata file\n\r");            out4.close();        } catch (FileNotFoundException e) {            System.out.println("file not found:"+args[0]);            e.printStackTrace();        } catch (IOException e) {            System.out.println("io exception");            e.printStackTrace();        }    }}

6.StreamTokenizer：

StreamTokenizer随同InputStream工作

用于将任何InputStream分割为一系列“记号”(token),这些记号实际上是一些断断续续的文本块，
中间用我们选择的任何东西分割，例如：我们的记号可以是单词，中间用空白以及标点符号分割

7.StringTokenizer

与StreamTokenizer功能相似

每次返回字串内的一个记号，这些记号是由制表符、空格以及新行分割的连续字符；如果进行简单的
操作可以使用StringTokenier，复杂的需要使用StreamTokenier

8.IO字符流：

字节流只支持8位字节流，不能很好控制16为字符，因此在原有库的基础上扩展了字符流，几乎所有字节流都有对应的字符流，一般情况下，尝试性选择字符流类，若代码不能通过编译，则换回字节流。

下面为字节流和字符流的对应关系：

通过filter（过滤器）修改数据流的行为，下表是字节流过滤器和字符流过滤器各类的对应关系：

使用字符流实现：

package com.zd.java.io.newio;import java.io.*;import java.nio.Buffer;/** * 使用字符流内实现 * Created by ZD on 2017/10/12. */public class NewIODemo {    public static void main(String[] args){        try {            //1.reading input by lines            BufferedReader in = new BufferedReader(new FileReader("test.out"));            String s,s2 = new String();            while ((s = in.readLine()) != null){                s2 += s + "\n";            }            in.close();            //2.input from memory            StringReader in2 = new StringReader(s2);            int c;            while ((c = in2.read()) != -1){                System.out.println((char)c);            }            //3.formatted memory input            //must use deprecated class            try{                DataInputStream in3 = new DataInputStream(new StringBufferInputStream(s2));                while (true){                    System.out.println((char)in3.readByte());                }            }catch (EOFException e){                System.out.println("end of stream0");            }            //4.line numbering & file output            try {                LineNumberReader li = new LineNumberReader(new StringReader(s2));                BufferedReader in4 = new BufferedReader(li);                PrintWriter out1 = new PrintWriter(new FileWriter("IODemo.out"));                while ((s = in4.readLine()) != null){                    out1.print("Line "+li.getLineNumber() + s);                }                out1.close();            }catch (EOFException e){                System.out.println("end of stream");            }            //5.storing & recovering data            try {                DataOutputStream out2 = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("Data.txt")));                out2.writeDouble(3.14159);                out2.writeBytes("that was pi");                out2.close();                DataInputStream in5 = new DataInputStream(new BufferedInputStream(new FileInputStream("Data.txt")));                BufferedReader in5br = new BufferedReader(new InputStreamReader(in5));                System.out.println(in5.readDouble());                System.out.println(in5br.readLine());            }catch (EOFException e){                System.out.println("end of stream");            }        } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }    }}

9.重定向：

重定向标准输入、输出以及错误IO流·，如果在屏幕上生成大量输出，不方便

package com.zd.java.io.newio.redirect;import java.io.*;/** *重定向输出 * Created by ZD on 2017/10/12. */public class Redirecting {    public static void main(String[] args){        try {            BufferedInputStream in = new BufferedInputStream(new FileInputStream("Data.txt"));            PrintStream out = new PrintStream(new BufferedOutputStream(new FileOutputStream("test1.out")));            System.setIn(in);            System.setOut(out);//重定向输出文件            System.setErr(out);            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));            String s;            while ((s = br.readLine())!=null){                System.out.println(s);                out.close();            }        } catch (FileNotFoundException e) {            System.out.println("未找到文件");            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }    }}

10.压缩：

下表显示的是压缩类功能：

10.1使用GZIP进行简单压缩

GZIP接口适用于的那个数据流压缩

package com.zd.java.io.newio.compress;import java.io.*;import java.util.zip.GZIPOutputStream;/** * 用GZIP进行压缩 * 只有单个数据流需要压缩，此为最适当的选择 * Created by ZD on 2017/10/12. */public class GZIPCompress {    public static void main(String[] args){        try {          BufferedReader in = new BufferedReader(new FileReader("pom.xml"));            BufferedOutputStream out = new BufferedOutputStream(new GZIPOutputStream(new FileOutputStream("test.gz")));            System.out.println("writing file");            int c;            while ((c = in.read())!=-1){                out.write(c);            }            in.close();            out.close();            System.out.println("reading file");            BufferedReader in2 = new BufferedReader(new InputStreamReader(new FileInputStream("test.gz")));            String s;            while ((s = in2.readLine()) != null){                System.out.println(s);            }        } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }    }}

10.2使用ZIP进行多文件保存：

package com.zd.java.io.newio.compress;import java.io.*;import java.util.zip.GZIPOutputStream;/** * 用GZIP进行压缩 * 只有单个数据流需要压缩，此为最适当的选择 * Created by ZD on 2017/10/12. */public class GZIPCompress {    public static void main(String[] args){        try {          BufferedReader in = new BufferedReader(new FileReader("pom.xml"));            BufferedOutputStream out = new BufferedOutputStream(new GZIPOutputStream(new FileOutputStream("test.gz")));            System.out.println("writing file");            int c;            while ((c = in.read())!=-1){                out.write(c);            }            in.close();            out.close();            System.out.println("reading file");            BufferedReader in2 = new BufferedReader(new InputStreamReader(new FileInputStream("test.gz")));            String s;            while ((s = in2.readLine()) != null){                System.out.println(s);            }        } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }    }}

10.3jar保存

 jar文件是跨平台的，在jar文件之前，web浏览器必须重复多次请求web服务器，以便下载完构成一个程序片的所有文件，除此以外每个文件都是为经压缩的，将所有这些文件合并到一个jar文件里以后，只需向远程服务器发出一次请求即可，由于采用压缩技术，可以在更短时间里获得全部数据，ar文件是由一系列采用zip压缩格式的文件构成，同时还有一个详情单