Java IO使用总结

最近在写Android网络操作的时候突然发现竟然不知道怎么写IO操作了。于是找了一下印象笔记，居然没有收藏过关于IO相关的笔记，那么索性就自己总结一下吧。

字节流

ByteArrayInputStream & ByteArrayOutputStream

ByteArrayInputStream ： 把字节数组转化为输入流，。
ByteArrayOutputStream：把内容写入到内部字节数组缓存中，其实就是包含了一个“byte buf[]”数组的OutputStream。当写操作完成之后，可以访问缓存数组的一个备份。

实例：

   public static void testByteArrayStream() {
        String sourceString = "This is a test about ByteArrayOutputStream " +
                "and ByteArrayInputStream";

        try {
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            outputStream.write(sourceString.getBytes());

            byte[] sourceBytes = outputStream.toByteArray();
            ByteArrayInputStream inputStream = new ByteArrayInputStream(sourceBytes);

            // 方法一：一次读取一个字节，只适合占用一个字节的字符串。
            int ch = -1;
            while ((ch = inputStream.read()) != -1) {
                System.out.print((char) ch);
            }
            System.out.println("\n");

            // 方法二：一次读取一个固定长度的数组。
            /*byte[] buffer = new byte[10]; while (inputStream.read(buffer) != -1) { System.out.println(new String(buffer)); }*/

            inputStream.close();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

FileInputStream & FileOutputStream

BufferedInputStream & BufferedOutputStream

FileInputStream 和FileOutputStream是专门用来读写字节文件。由于没有缓存，最好使用BufferedInputStream 和BufferedOutputStream来封装使用它们。所以把他们放在了一起。

对的InputStream和OutputStream的一个封装，提供一个buffer来缓存input和output，BufferedInputStream 会自动读取固定长度的字符流到buffer中，每次read先从buffer中读取；BufferedOutputStream会把write的字节先放到buffer中，如果超过设置长度才会执行写操作。
这算是以空间来换取时间。

实例：

    public static void testFileInputStream() {
        File from = new File("a.gif");
        File to = new File("b.gif");
        if (from.exists()) {
            FileInputStream fileInputStream = null;
            BufferedInputStream bufferedInputStream = null;
            FileOutputStream fileOutputStream = null;
            BufferedOutputStream bufferedOutputStream = null;

            try {
                fileInputStream = new FileInputStream(from);
                bufferedInputStream = new BufferedInputStream(fileInputStream);

                fileOutputStream = new FileOutputStream(to);
                bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

                byte[] buffer = new byte[1024];

                while (bufferedInputStream.read(buffer) != -1) {
                    bufferedOutputStream.write(buffer);
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (bufferedInputStream != null) {
                        bufferedInputStream.close();
                    }
                    if (bufferedOutputStream != null) {
                        bufferedInputStream.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } else {
            System.err.println(from.getName() + " 文件不存在！");
        }
    }

DataInputStream & DataOutputStream

提供读写java的基本数据类型。如writeBoolean(),writeUTF()，writeChar，writeByte()，writeDouble()等和对应的read方法。

实例：

        BufferedOutputStream bufferedOutputStream = null;
        BufferedInputStream bufferedInputStream = null;
        DataOutputStream dataOutputStream = null;
        DataInputStream dataInputStream = null;

        try {
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(new File("out.txt")));
            dataOutputStream = new DataOutputStream(bufferedOutputStream);

            dataOutputStream.writeShort(1);
            dataOutputStream.writeChar(',');
            dataOutputStream.writeInt(20);
            dataOutputStream.writeBoolean(false);
            dataOutputStream.writeChar(',');
            dataOutputStream.writeUTF("Test哦！");

            dataOutputStream.flush();

            bufferedInputStream = new BufferedInputStream(new FileInputStream(new File("out.txt")));
            dataInputStream = new DataInputStream(bufferedInputStream);
            short out1 = dataInputStream.readShort();
            char out2 = dataInputStream.readChar();
            int out3 = dataInputStream.readInt();
            boolean out4 = dataInputStream.readBoolean();
            char out5 = dataInputStream.readChar();
            String out6 = dataInputStream.readUTF();

            System.out.println("Result" + out1 + out2 + out3 + out4 + out5 + out6);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedOutputStream != null) {
                    bufferedOutputStream.close();
                }

                if (bufferedInputStream != null) {
                    bufferedInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

ObjectInputStream & ObjectOutputStream

读写实现了Serializable接口的对象的字节流。

实例：

        ObjectInputStream objectInputStream = null;
        ObjectOutputStream objectOutputStream = null;

        try {
            objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("out.txt")));
            objectOutputStream.writeUTF("ObjectStream:");

            Employee employee = new Employee();
            employee.setName("TOM");
            employee.setAge(22);
            employee.setAddress("China");
            employee.setPhoneNumber("987766666");
            objectOutputStream.writeObject(employee);

            objectInputStream = new ObjectInputStream(new FileInputStream(new File("out.txt")));
            String out1 = objectInputStream.readUTF();
            Object out2 = (Employee) objectInputStream.readObject();
            System.out.println(out1 + out2);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                objectInputStream.close();
                objectOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

字符流

CharArrayReader & CharArrayWriter

CharArrayReader ：把字符数组作为一个输入流
CharArrayWriter： CharArrayWriter里面包含一个字符数组来当做缓存，写操作就是把内容写入到缓存中。当写操作完成之后，可以访问缓存数组的一个备份。

实例：

        String sourceString = "This is a test about ByteArrayOutputStream and ByteArrayInputStream";

        CharArrayReader charArrayReader = null;
        CharArrayWriter charArrayWriter = null;

        charArrayWriter = new CharArrayWriter();
        try {
            // 把sourceString写入到CharArrayWriter的缓存数组中
            charArrayWriter.write(sourceString);
        } catch (IOException e) {
            e.printStackTrace();
        }

        String sourceWriter = charArrayWriter.toString();
        // 把sourceWriter字符串转化为输入流
        charArrayReader = new CharArrayReader(sourceWriter.toCharArray());

        StringBuilder stringBuilder = new StringBuilder();

        // 方法一：一次读取一个字符
    /* int ch = -1; try { while ((ch = charArrayReader.read()) != -1) { stringBuilder.append((char) ch); } System.out.println("Read one Char: " + stringBuilder.toString()); } catch (IOException e) { e.printStackTrace(); } finally { charArrayReader.close(); }*/

        // 方法二：一次读取一个字符数组
        char[] chars = new char[10];
        int count;
        try {
            while ((count = charArrayReader.read(chars)) != -1) {
                stringBuilder.append(String.copyValueOf(chars, 0, count));
            }
            System.out.println("Read char array: " + stringBuilder.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            charArrayReader.close();
        }

FileReader & FileWriter

已字符流的形式读写文件。
如果读写操作比较频繁，需要使用BufferedReader和 BufferedWriter来包装使用。

实例：

        FileReader fileReader = null;
        FileWriter fileWriter = null;

        try {
            fileReader = new FileReader(new File("out.txt"));
            fileWriter = new FileWriter(new File("out2.txt"));

            // 读写不频繁的时候，直接使用
            char[] buffer = new char[1024];
            while (fileReader.read(buffer) != -1) {
                fileWriter.write(buffer);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileReader != null) {
                    fileReader.close();
                }

                if (fileWriter != null) {
                    fileWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

BufferedReader & BufferedWriter

自带Buffer的Reader和Write。如果读写操作比较频繁的话，可以使用这两个类。

实例：

       FileReader fileReader = null;
        FileWriter fileWriter = null;

        try {
            fileReader = new FileReader(new File("out.txt"));
            fileWriter = new FileWriter(new File("out2.txt"));

            BufferedReader bufferedReader = new BufferedReader(fileReader);
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

            String buffer;
            while ((buffer = bufferedReader.readLine()) != null) {
                bufferedWriter.write(buffer);
                bufferedWriter.write('\n');
            }

            bufferedWriter.close();
            bufferedReader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {

                if (fileReader != null) {
                    fileReader.close();

                }

                if (fileWriter != null) {
                    fileWriter.close();
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }

StringReader & StringWriter

StringReader：把String转化为一个流。
StringWriter：带有StringBuffer的Write。

实例：

        String sourceString = "This is a test about ByteArrayOutputStream and ByteArrayInputStream";

        StringReader stringReader = null;
        StringWriter stringWriter = null;

        stringReader = new StringReader(sourceString);
        stringWriter = new StringWriter();

        char[] buffer = new char[1024];
        try {
            while (stringReader.read(buffer) != -1) {
                stringWriter.write(buffer);
            }
            System.out.println(stringWriter.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }

        stringReader.close();
        try {
            stringWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }