java io常用类总结

大家好，又见面了，我是你们的朋友全栈君。

读写数据是java开发过程中经常需要做的，本篇文章将我们平时常用的java io处理类做个总结，同时给出相关demo。

可以看得出来，JAVA IO主要有这四个类InputStream、OutputStream、Reader、Writer来处理，要处理字节流的就用InputStream、OutputStream，要处理字符流，就用Reader、Writer，现实中根据需要，我们选择他们的相关子类进行数据的读写。给出类图：

根据处理媒介的不同进行划分

下面给出常用的IO处理demo

/**

 * 项目名称(中文)

 * 项目名称(英文)

 * Copyright (c) 2018 ChinaPay Ltd. All Rights Reserved.

 */

package com.figo.study.test;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.DataInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.InputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.OutputStream;

import java.io.Reader;

import java.io.Serializable;

import java.io.StringWriter;

import java.io.Writer;

/**

 * IO操作总结 IO按读写划分可以分为输入流和输出流 IO，

 * 按处理媒介来划分可以分为字节流和字符流 

 * 另外为了处理不同的数据类型，输入输出流可以层层包装

 * 比如处理文件数据的FileInputStream,FileOutputStream.

 * 另外处理网络的IO一般使用Socket，jdk1.4及以上版本又推出了NIO， NIO non-blocking

 * io非阻塞的开源项目比如MINA,NETTY，本demo讨论io

 * 

 * @author figo

 * @version 1.0 2018-6-12 改订

 * @since 1.0

 */

public class TestIO {

    /**

     * .

     * 

     * @param args

     */

    public static void main(String[] args) {

        // testInputStreamAndOutputStream();

        // testReaderAndWriter();

//        testBufferReaderAndWriter();

        testObjectInputStreamAndObjectOutputStream();

    }

    /**

     * 字节流输入FileInputStream输出FileOutputStream 文件超大有可能会OOM

     */

    public static void testInputStreamAndOutputStream() {

        try {

            // 写入数据

            String hello = new String(“hello world!”);

            byte[] byteArray = hello.getBytes();

            File file = new File(“E:\\学习资料\\java学习\\testIO\\iostream.txt”);

            // 因为是用字节流来写媒介，所以对应的是OutputStream

            // 又因为媒介对象是文件，所以用到子类是FileOutputStream

            OutputStream os = new FileOutputStream(file);

            os.write(byteArray);

            os.close();

            // 读取数据

            byte[] byteArrayNew = new byte[(int) file.length()];

            // 因为是用字节流来读媒介，所以对应的是InputStream

            // 又因为媒介对象是文件，所以用到子类是FileInputStream

            InputStream is = new FileInputStream(file);

            int size = is.read(byteArrayNew);

            System.out.println(“大小:” + size + “;内容:” + new String(byteArray));

            is.close();

        } catch (Exception ex) {

            ex.printStackTrace();

        }

    }

    /**

     * 字符流输入FileReader输出FileWriter 文件超大有可能会OOM

     */

    public static void testReaderAndWriter() {

        try {

            // 写入数据

            String hello = new String(“hello worLd!”);

            File file = new File(

                    “E:\\学习资料\\java学习\\testIO\\readerAndwriter.txt”);

            // 因为是用字符流来读媒介，所以对应的是Writer，又因为媒介对象是文件，所以用到子类是FileWriter

            Writer os = new FileWriter(file);

            os.write(hello);

            os.close();

            // 读取数据

            // 因为是用字符流来读媒介，所以对应的是Reader

            // 又因为媒介对象是文件，所以用到子类是FileReader

            Reader reader = new FileReader(file);

            char[] byteArray = new char[(int) file.length()];

            int size = reader.read(byteArray);

            System.out.println(“大小:” + size + “;内容:” + new String(byteArray));

            reader.close();

        } catch (Exception ex) {

            ex.printStackTrace();

        }

    }

    /**

     * 缓存字符输入BufferedReader和输出BufferedWriter 缓存一定大小字符流后再一次性输入输出

     * 每次一个字符一个字符的读写肯定影响性能的 每次读写缓存大小的数据量，一般不会OOM，批量读写明显会提高效率

     */

    public static void testBufferReaderAndWriter() {

        try {

            // 写入数据

            String hello = new String(“hello worLd!”);

            File file = new File(

                    “E:\\学习资料\\java学习\\testIO\\bufferReaderAndWriter.txt”);

            // 因为是用字符流来读媒介，所以对应的是Writer，又因为媒介对象是文件，所以用到子类是FileWriter

            Writer os = new FileWriter(file);

            // 外部再包装一层buffer 不设置缓冲大小，默认8k，也可以自己通过这个构造函数指定

            // BufferedWriter(Writer paramWriter, int paramInt)

            BufferedWriter bw = new BufferedWriter(os);

            bw.write(hello);

            // 写一行换一行

            bw.newLine();

            bw.close();

            os.close();

            // 读取数据

            // 因为是用字符流来读媒介，所以对应的是Reader

            // 又因为媒介对象是文件，所以用到子类是FileReader

            Reader reader = new FileReader(file);

            // 外部再包装一层buffer 不设置缓冲大小，默认8k，也可以自己通过这个构造函数指定

            // BufferedReader(Reader paramReader, int paramInt)

            BufferedReader bufferReader = new BufferedReader(reader);

            String tempString = null;

            while ((tempString = bufferReader.readLine()) != null) {

                // 显示行号

                System.out.println(tempString);

            }

            bufferReader.close();

            reader.close();

        } catch (Exception ex) {

            ex.printStackTrace();

        }

    }

    /**

     * 对象读写到文件ObjectInputStream和ObjectOutputStream .

     */

    public static void testObjectInputStreamAndObjectOutputStream() {

        try {

            //定义一个对象

            Student student=new Student();

            student.setName(“abc”);

            student.setSex(“男”);

            student.setGrade(“一年级”);

            student.setAddress(“上海”);

            student.setMobile(“15812345678”);

            //对象写入文件

            FileOutputStream fos=new FileOutputStream(“E:\\学习资料\\java学习\\testIO\\Student.txt”);

            ObjectOutputStream oos=new ObjectOutputStream(fos);

            oos.writeObject(student);

            oos.flush();

            oos.close();

            //从文件读取对象

            FileInputStream fis=new FileInputStream(“E:\\学习资料\\java学习\\testIO\\Student.txt”);

            ObjectInputStream ois=new ObjectInputStream(fis);

            Student studentNew=(Student)ois.readObject();

            System.out.println(studentNew.toString());

            

        } catch (Exception ex) {

            ex.printStackTrace();

        }

    }

    /**

     * 一定记得实现Serializable，否则无法序列化成字节流

     * @author figo

     * .

     */

    public static class Student implements Serializable{

        /**

         * .

         */

        private static final long serialVersionUID = 1L;

        String name;

        String sex;

        String grade;

        String address;

        String mobile;

        public String getName() {

            return name;

        }

        public void setName(String name) {

            this.name = name;

        }

        public String getSex() {

            return sex;

        }

        public void setSex(String sex) {

            this.sex = sex;

        }

        public String getGrade() {

            return grade;

        }

        public void setGrade(String grade) {

            this.grade = grade;

        }

        public String getAddress() {

            return address;

        }

        public void setAddress(String address) {

            this.address = address;

        }

        public String getMobile() {

            return mobile;

        }

        public void setMobile(String mobile) {

            this.mobile = mobile;

        }

        @Override

        public String toString() {

            return “Student [name=” + name + “, sex=” + sex + “, grade=”

                    + grade + “, address=” + address + “, mobile=” + mobile

                    + “]”;

        }

    }

}

 /**
     * 
     * 字符转字节流InputStreamReader和OutputStreamWriter . 
     * 这两个类的好处是可以指定读取和写入的字符编码
     */
    public static void testInputStreamReaderAndOutputStreamWriter() {

        try {

            //写文件
            String filePathAndName = “E:\\学习资料\\java学习\\testIO\\InputStreamReaderWriter.txt”;
            File fileWrite = new File(filePathAndName);
            if (!fileWrite.exists()) {

                fileWrite.createNewFile();
            }
            OutputStreamWriter write = new OutputStreamWriter(new FileOutputStream(fileWrite), “UTF-8”);
            BufferedWriter writer = new BufferedWriter(write);
            String fileContent = “hello,world，你好世界！”;
            writer.write(fileContent);
            writer.close();
            //读文件
            File fileRead = new File(filePathAndName);
            if (fileRead.isFile() && fileRead.exists()) {

                InputStreamReader read = new InputStreamReader(
                        new FileInputStream(fileRead), “UTF-8”);
                BufferedReader reader = new BufferedReader(read);
                String line;
                StringBuffer sringBuffer=new StringBuffer();
                while ((line = reader.readLine()) != null) {

                    //这样也可以指定编码，但是会new很多的String对象
//                  String newLine=new String(line.getBytes(“UTF-8”));
                    sringBuffer.append(line);
                }
                System.out.println(fileContent);
                read.close();
            }

        } catch (Exception ex) {

            ex.printStackTrace();
        }
    }

另外我们在处理文件读写经常用到java.io.File，这个类比较简单，给出常用方法大家看看就会了：

好了，大家可以自己动手试一下。

参考文章

Java IO

https://blog.csdn.net/suifeng3051/article/details/48344587

Java的IO操作—File类

https://www.cnblogs.com/alsf/p/5746480.html