基本IO流

 

 

 

字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想(装饰设计模式)，所以提供了字节缓冲区流
字节缓冲输出流
BufferedOutputStream
字节缓冲输入流
BufferedInputStream

将字节流转换字符流

OutputStreamWriter 字符输出流
public OutputStreamWriter(OutputStream out)
public OutputStreamWriter(OutputStream out,String charsetName)
InputStreamReader 字符输入流
public InputStreamReader(InputStream in)
public InputStreamReader(InputStream in,String charsetName)


OutputStreamWriter写数据方法
public void write(int c)
public void write(char[] cbuf)
public void write(char[] cbuf,int off,int len)
public void write(String str)
public void write(String str,int off,int len)
字符流操作要注意的问题
flush()的作用
flush()和close()的区别


OutputStreamWriter读数据方法
public int read()
public int read(char[] cbuf)

字符缓冲流

BufferedWriter基本用法
BufferedReader基本用法
字符缓冲流复制文本文件
特殊功能
BufferedWriter
void newLine()
BufferedReader
String readLine()
字符缓冲流特殊功能复制文本文件

内存操作流程

操作字节数组
ByteArrayInputStream
ByteArrayOutputStream
操作字符数组
CharArrayReader
CharArrayWrite
操作字符串
StringReader
StringWriter

标准输入输出流

System类中的字段：in，out。
它们各代表了系统标准的输入和输出设备。
默认输入设备是键盘，输出设备是显示器。
System.in的类型是InputStream.
System.out的类型是PrintStream是OutputStream的子类FilterOutputStream 的子类.

1 合并输入流SequenceInputStream

SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，
接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

 * 构造方法：
 *         SequenceInputStream(InputStream s1, InputStream s2):合并两个流对象
 *         SequenceInputStream(Enumeration e):合并多个流对象

2随机访问文件读写RandomAccessFile

 * RandomAccessFile:此类的实例支持对随机访问文件的读取和写入。
 * RandomAccessFile(String name, String mode) 
 * 
 * public long getFilePointer():返回偏移量，以字节为单位
 * public void seek(long pos):设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。

3序列化流ObjectOutputStream和ObjectInputStream

 * 为什么要有序列化流呢?
 *         为了让对象在文件中持久存储，或者在网络中传输。
 * 
 * 序列化流：ObjectOutputStream    
 *         public final void writeObject(Object obj)
 * 反序列化流：ObjectInputStream    (把流数据的对象还原)
 *         public final Object readObject()

4Properties

 * Properties和IO流的结合使用。
 * A:把文本文件中的数据读取到集合中
 *         数据源：文本文件
 *         目的地：集合
 * 
 *         public void load(InputStream inStream)
 *        public void load(Reader reader)
 * B:把集合中的数据存储到文本文件
 *         数据源：集合
 *         目的地：文本文件
 * 
 *         public void store(OutputStream out,String comments)
 *         public void store(Writer writer,String comments)

5File工具

 * Files:操作文件的工具类。提供了大量的方法，简单了解如下方法
 *         public static long copy(Path source, OutputStream out) :复制文件
 *         public static Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption... options):
 *            把集合的数据写到文件。

6 DataInputStream DataOutputStream

和平台无关，用于数据恢复。

存储和恢复数据

PrintWriter 是用来对可读的数据进行格式化。但如果要输出可供另一个“流”恢复的数据，我们可以用 DataOutputStream 写入数据，然后用 DataInputStream 恢复数据。当然，这些流可能是任何形式，在下面的示例中使用的是一个文件，并且对读写都进行了缓冲。注意 DataOutputStream 和 DataInputStream 是面向字节的，因此要使用 InputStream 和 OutputStream 体系的类。

public class StoringAndRecoveringData {
    public static void main(String[] args) {
        try (
                DataOutputStream out = new DataOutputStream(
                        new BufferedOutputStream(
                                new FileOutputStream("Data.txt")))
        ) {
            out.writeDouble(3.14159);
            out.writeUTF("That was pi");
            out.writeDouble(1.41413);
            out.writeUTF("Square root of 2");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        try (
                DataInputStream in = new DataInputStream(
                        new BufferedInputStream(
                                new FileInputStream("Data.txt")))
        ) {
            System.out.println(in.readDouble());
            // Only readUTF() will recover the
            // Java-UTF String properly:
            System.out.println(in.readUTF());
            System.out.println(in.readDouble());
            System.out.println(in.readUTF());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

7文本文件输出快捷方式

public class FileOutputShortcut {
    static String file = "FileOutputShortcut.dat";

    public static void main(String[] args) {
        try (
                BufferedReader in = new BufferedReader(
                        new StringReader(BufferedInputFile.read(
                                "FileOutputShortcut.java")));
                // Here's the shortcut:文件输出流快捷写入
                PrintWriter out = new PrintWriter(file)
        ) {
            in.lines().forEach(out::println);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
/*        try {
            System.out.println(BufferedInputFile.read(file));
        } catch (IOException e) {
            e.printStackTrace();
        }*/
    }


}


class BufferedInputFile {
    // Throw exceptions to console:
    public static String
    read(String filename) throws IOException {
        // Reading input by lines: 读文本，FileReader -->BufferedReader-->一行一行地读
        BufferedReader in = new BufferedReader(
                new FileReader(filename));
        String s;
        StringBuilder sb = new StringBuilder();
        while((s = in.readLine())!= null)
            sb.append(s + "
");
        in.close();
        return sb.toString();
    }
/*    public static void main(String[] args)
            throws IOException {
        System.out.print(read("BufferedInputFile.java"));
    }*/
} /* (Execute to see output) *///:~

8 基本文件的输出

FileWriter 对象用于向文件写入数据。实际使用时，我们通常会用 BufferedWriter 将其包装起来以增加缓冲的功能（可以试试移除此包装来感受一下它对性能的影响——缓冲往往能显著地增加 I/O 操作的性能）。在本例中，为了提供格式化功能，它又被装饰成了 PrintWriter。按照这种方式创建的数据文件可作为普通文本文件来读取。

import java.io.*;

public class BasicFileOutput {
    static String file = "BasicFileOutput.dat";

    public static void main(String[] args) {
        try (
            BufferedReader in = new BufferedReader(
                new StringReader(
                     BufferedInputFile.read(
                         "BasicFileOutput.java")));
                PrintWriter out = new PrintWriter(
                    new BufferedWriter(new FileWriter(file)))
        ) {
            in.lines().forEach(out::println);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        // Show the stored file:
        System.out.println(BufferedInputFile.read(file));
    }
}

9一个字节一个字节地读

ByteArrayInputStream： ByteArrayInputStream 必须接收一个字节数组，所以这里我们调用了 String.getBytes() 方法。
所产生的的 ByteArrayInputStream 是一个适合传递给 DataInputStream 的 InputStream。

public class FormattedMemoryInput {
    public static void main(String[] args) {
        try (
                DataInputStream in = new DataInputStream(
                        new ByteArrayInputStream(
                                BufferedInputFile.read(
                                        "dos.txt")
                                        .getBytes()))
        ) {
            while (true)
                System.out.write((char) in.readByte());
        } catch (EOFException e) {
            System.out.println("
End of stream");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

如果我们用 readByte() 从 DataInputStream 一次一个字节地读取字符，那么任何字节的值都是合法结果，因此返回值不能用来检测输入是否结束。取而代之的是，我们可以使用 available() 方法得到剩余可用字符的数量。下面例子演示了怎么一次一个字节地读取文件。

import java.io.*;

public class TestEOF {
    public static void main(String[] args) {
        try (
            DataInputStream in = new DataInputStream(
                new BufferedInputStream(
                    new FileInputStream("TestEOF.java")))
        ) {
            while (in.available() != 0)
                System.out.write(in.readByte());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

10格式化内存输入

要读取格式化数据，我们可以使用 DataInputStream，它是一个面向字节的 I/O 类（不是面向字符的）。这样我们就必须使用 InputStream 类而不是 Reader 类。我们可以使用 InputStream 以字节形式读取任何数据（比如一个文件），但这里使用的是字符串。

            DataInputStream in = new DataInputStream(
                new ByteArrayInputStream(
                    BufferedInputFile.read(
                        "FormattedMemoryInput.java")
                            .getBytes()))

11缓冲输入文件

如果想要打开一个文件进行字符输入，我们可以使用一个 FileInputReader 对象，然后传入一个 String 或者 File 对象作为文件名。为了提高速度，我们希望对那个文件进行缓冲，那么我们可以将所产生的引用传递给一个 BufferedReader 构造器。BufferedReader 提供了 line() 方法，它会产生一个 Stream<String> 对象：

class BufferedInputFile1 {
    public static String read(String filename) {
        try (BufferedReader in = new BufferedReader(
                new FileReader(filename))) {
//            return in.lines()
//                    .collect(Collectors.joining("
"));

            Collector<CharSequence, ?, String> joining = Collectors.joining("
");
            Stream<String> lines = in.lines();
            return lines.collect(joining);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        System.out.print(
                read("FileOutputShortcut.java"));
    }
}