Java基础-IO

java io

本文详细介绍讲述了java io的相关内容，主要涉及文件，网络数据流，内存缓冲等的输入输出，版本要求jdk1.8。

概述

java的io包主要关注数据源的读取和输出到目标媒介。示意图如下

常用的源数据和目标媒介如下：

• files
• pipes
• network connections
• in-memory buffers (e.g. arrays)
• system.in, system.out, system.error

流从概念上说一个连续的数据流，既可以从流中读取数据，也可以往流中写入数据。主要分为字节流和字符流，字节流指以字节为单位进行读写，字符流指以字符为单位进行读写。
一个程序需要inputstream或者reader从数据源读取数据，需要outputstream或者writer将数据写入到目标媒介中。示意图如下：

stream特征和分类

java io针对不同的业务场景，不同的功能，设计了不同的类，各类用途如下：

• file access
• network access
• internal memory buffer access
• inter-thread communication (pipes)
• buffering
• filtering
• parsing
• reading and writing text (readers / writers)
• reading and writing primitive data (long, int etc.)
• reading and writing objects

通过输入、输出、基于字节或者字符、以及其他比如缓冲、解析之类的特定用途可以将java io流进行如下划分：

	byte based		character based
	input	output	input	output
basic	inputstream	outputstream	reader inputstreamreader	writer outputstreamwriter
arrays	bytearrayinputstream	bytearrayoutputstream	chararrayreader	chararraywriter
files	fileinputstream randomaccessfile	fileoutputstream randomaccessfile	filereader	filewriter
pipes	pipedinputstream	pipedoutputstream	pipedreader	pipedwriter
buffering	bufferedinputstream	bufferedoutputstream	bufferedreader	bufferedwriter
filtering	filterinputstream	filteroutputstream	filterreader	filterwriter
parsing	pushbackinputstream streamtokenizer		pushbackreader linenumberreader
strings			stringreader	stringwriter
data	datainputstream	dataoutputstream
data - formatted		printstream		printwriter
objects	objectinputstream	objectoutputstream
utilities	sequenceinputstream

file类

在讨论stream的具体使用前，我们先看看io库里面的file类。
java文件类以抽象的方式代表文件名和目录路径名。该类主要用于文件和目录的创建、文件的查找和文件的删除等，但file对象却不能直接访问文件内容本身，要查看内容，则需要使用io流。
通过以下构造方法创建一个file对象。

• 通过给定的父抽象路径名和子路径名字符串创建一个新的file实例。

    file(file parent, string child);

• 通过将给定路径名字符串转换成抽象路径名来创建一个新 file 实例。

    file(string pathname) 

• 根据 parent 路径名字符串和 child 路径名字符串创建一个新 file 实例。

    file(string parent, string child) 

• 通过将给定的 file: uri 转换成一个抽象路径名来创建一个新的 file 实例。

    file(uri uri) 

由于其方法均比较简单，不再罗列，具体见。一个具体的实例如下：

package com.molyeo.java.io;

import org.slf4j.logger;
import org.slf4j.loggerfactory;

import java.io.file;
import java.io.ioexception;
import java.util.arrays;

/**
 * created by zhangkh on 2018/7/19.
 */
public class filedemo {
    static logger logger = loggerfactory.getlogger(filedemo.class.getname());

    public static void main(string[] args) throws ioexception {
        file path = new file(".");
        if (path.isdirectory()) {
            logger.info("root: directory is {}", path.getabsolutepath());
            string[] list = path.list();
            arrays.sort(list, string.case_insensitive_order);
            for (string diritem : list) {
                file file = new file(path, diritem);
                if (file.isdirectory()) {
                    logger.info("child: {} is a directory", diritem);
                } else {
                    logger.info("child: {} is a file", diritem);
                }
            }
        } else {
            logger.info("root is not a directory");
        }
    }
}

查看当前项目，按照字典顺序排序后，再判断其子路径是文件还是目录，并输出相关结果。

18/07/19 17:35:12 info io.filedemo: root: directory is d:\workspace_spark\sparkinaction\.
18/07/19 17:35:12 info io.filedemo: child: .idea is a directory
18/07/19 17:35:12 info io.filedemo: child: data is a directory
18/07/19 17:35:12 info io.filedemo: child: libs is a directory
18/07/19 17:35:12 info io.filedemo: child: out is a directory
18/07/19 17:35:12 info io.filedemo: child: pom.xml is a file
18/07/19 17:35:12 info io.filedemo: child: spark-warehouse is a directory
18/07/19 17:35:12 info io.filedemo: child: sparkinaction.iml is a file
18/07/19 17:35:12 info io.filedemo: child: src is a directory
18/07/19 17:35:12 info io.filedemo: child: target is a directory

inputstream和outputstream

全局类图

在前面表格中，罗列了java io中的流，可以看到相对复杂。我们先看字节流的层次关系。
整体的层次关系如下：

在上面的层次图中，为简便区分，用蓝色表示接口，红色表示抽象类，绿色表示类。
jdk1.8中，主要通过5个接口来定义区别不同的流，分别是closeable,flushable,readable,appendable。其中closeable的父类autocloseable接口主要是用于基于try-with-resource的异常处理。
inputstream实现closeable接口,而closeable的父类autocloseable接口主要是用于基于try-with-resource的异常处理，在后续的示例代码中将会说明。

inputstream类图

具体看inputstream的类图如下：

inputstream实现closeable接口，并有五个子类，而其子类filterinputstream作为装饰功能类，类图如下：

输入流使用基本流程

我们先看一个从文件读取的实例，以了解io流的使用流程。
我们将上文判断当前项目下的文件是file还是directory的例子改写一下，改写读取当前项目文件夹为data并且以data开头的文件，并输出文件内容：

package com.molyeo.java.io;

import org.slf4j.logger;
import org.slf4j.loggerfactory;

import java.io.*;

/**
 * created by zhangkh on 2018/7/20.
 */
public class bytebasedstream {
    static logger logger = loggerfactory.getlogger(bytebasedstream.class.getname());

    public static void main(string[] args) throws ioexception {
        file path = new file(".");
        if (path.isdirectory()) {
            logger.info("root: directory is {}", path.getabsolutepath());
            string[] list;

            list = path.list(new dirfilter("d.*"));
            logger.info("file after first filter:");

            for (string diritem : list) {
                file file = new file(path, diritem);
                if (file.isdirectory()) {
                    logger.info("child: {} is a directory", diritem);
                    string[] childlist = file.list(new dirfilter("data*.txt"));
                    logger.info("file after second filter");
                    for (string childitem : childlist) {

                        file childfile = new file(file, childitem);
                        if (childfile.isfile()) {
                            logger.info("secondary child: {} is a file", childitem);
                            logger.info("start read file {}", childfile.getcanonicalpath());
                            read(childfile);
                        }
                    }
                } else {
                    logger.info("child: {} is a file", diritem);
                }

            }


        } else {
            logger.info("root is not a directory");
        }

    }

    public static void read(file file) throws ioexception {
        inputstream inputstream = null;
        try {
            inputstream = new fileinputstream(file);
            int bytedata = inputstream.read();
            while (bytedata != -1) {
                logger.info("bytedata={}, char result={}", bytedata, (char) bytedata);
                bytedata = inputstream.read();
            }
        } catch (filenotfoundexception e) {
            e.printstacktrace();
        } catch (ioexception e) {
            e.printstacktrace();
        } finally {
            if (inputstream != null) {
                inputstream.close();
            }
        }
    }
}

其中data.txt文件内容为hadoop,程序运行日志如下：

18/08/04 22:19:58 info io.bytebasedstream: root: directory is d:\workspace_spark\sparkinaction\.
18/08/04 22:19:58 info io.bytebasedstream: file after first filter:
18/08/04 22:19:58 info io.bytebasedstream: child: data is a directory
18/08/04 22:19:58 info io.bytebasedstream: file after second filter
18/08/04 22:19:58 info io.bytebasedstream: secondary child: data.txt is a file
18/08/04 22:19:58 info io.bytebasedstream: start read file d:\workspace_spark\sparkinaction\data\data.txt
18/08/04 22:19:58 info io.bytebasedstream: bytedata=72, char result=h
18/08/04 22:19:58 info io.bytebasedstream: bytedata=97, char result=a
18/08/04 22:19:58 info io.bytebasedstream: bytedata=100, char result=d
18/08/04 22:19:58 info io.bytebasedstream: bytedata=111, char result=o
18/08/04 22:19:58 info io.bytebasedstream: bytedata=111, char result=o
18/08/04 22:19:58 info io.bytebasedstream: bytedata=112, char result=p

read()
自定义的read方法输入文件，然后我们构造fileinputstream实例，通过循环调用read()方法从fileinputstream流中读取一个字节的内容。

int bytedata=inputstream.read();

数据读取后可以将返回的int类型转换成char类型。

char achar = (char) data;

如果到达流末尾时，read方法返回-1。此时则可以关闭流。
read(byte[])

inputstream包含了2个从inputstream中读取数据并将数据存储到缓冲数组中的read()方法，他们分别是：

int read(byte[])
int read(byte, int offset, int length)

一次性读取一个字节数组的方式，比一次性读取一个字节的方式快的多，所以，尽可能使用这两个方法代替read()方法。
read(byte[])方法会尝试读取与给定字节数组容量一样大的字节数，返回值说明了已经读取过的字节数。如果inputstream内可读的数据不足以填满字节数组，那么数组剩余的部分将包含本次读取之前的数据。记得检查有多少数据实际被写入到了字节数组中。
read(byte, int offset, int length)方法同样将数据读取到字节数组中，不同的是，该方法从数组的offset位置开始，并且最多将length个字节写入到数组中。同样地，read(byte, int offset, int length)方法返回一个int变量，告诉你已经有多少字节已经被写入到字节数组中，所以请记得在读取数据前检查上一次调用read(byte, int offset, int length)的返回值。

这两个方法都会在读取到达到流末尾时返回-1。

io流异常处理

在读取文件的那个例子中，我们看read方法真实有效的代码知识try中的一部分，而实际我们写了很多异常处理的模板方法。

public static void read(file file) throws ioexception {
    inputstream inputstream = null;
    try {
        inputstream = new fileinputstream(file);
        int bytedata = inputstream.read();
        while (bytedata != -1) {
            logger.info("bytedata={}, char result={}", bytedata, (char) bytedata);
            bytedata = inputstream.read();
        }
    } catch (filenotfoundexception e) {
        e.printstacktrace();
    } catch (ioexception e) {
        e.printstacktrace();
    } finally {
        if (inputstream != null) {
            inputstream.close();
        }
    }
}

在这段代码*有4个地方可能会抛出异常，分别是new fileinputstream(file)，inputstream.read()，inputstream.read()，inputstream.close()。
想象一下，从try块内部抛出异常。然后finally执行该块，而从finally块抛出的异常如果我们不捕获的话，将在调用堆栈中向上传播。
try-catch-finally结构显示的关闭流显得单调乏味，并且异常捕获模板代码众多，看着一点都不优雅。在java7后可以使用try-with-resource结构来处理，示例如下：

public static void read1(file file) throws ioexception{
    try(inputstream inputstream=new fileinputstream(file)){
        int bytedata = inputstream.read();
        while (bytedata != -1) {
            logger.info("bytedata={}, char result={}", bytedata, (char) bytedata);
            bytedata = inputstream.read();
        }
    }
}

我们在read1方法中实现了和read方法一样的功能，但代码显得简洁明了。其中在try()括号内创建了fileinputstream这个资源，当程序执行离开try{}块时，该资源将会自动关闭。如果try()括号内有多个资源，资源将按与括号内创建/列出顺序相反的顺序关闭。
io流中，资源之所以会自动关闭，是因为io流(包括inputstream,outputstream,reader,writer)均实现了autoclosable接口，具体可参考全局类图。我们也可以将自定义类实现autoclosable接口，然后
与try-with-resource结构一起使用。

filterinputstream

filterinputstream主要有4个子类，可以用来修改inputstream的内部行为。

4个字类添加的功能如下：

类名	功能
datainputstream	与dataoutputstream配合使用，以一种"可携带的方式(portable fashion)"从流里读取基础类型
bufferedinputstream	从缓冲区读取，而不是每次要用数据的时候都要进行物理读取
linenumberinputstream	跟踪输入流的行号；有getlinenumber( )和setlinenumber(int)方法
pushbackinputstream	有一个"弹压单字节"的缓冲区，这样你就能把最后读到的那个字节再压回去。

我们用bufferedinputstream给fileinputstream方法添加缓存区，改写后的read方法如下：

public static void readwithbuffer(file file) throws ioexception{
    try(fileinputstream fileinputstream=new fileinputstream(file);
        bufferedinputstream input=new bufferedinputstream(fileinputstream);
    ){
        int bytedata = input.read();
        while (bytedata != -1) {
            logger.info("bytedata={}, char result={}", bytedata, (char) bytedata);
            bytedata = input.read();
        }
    }
}

outputstream类图

outputstream的层次关系如下:

outputstream实现closeable和flushable接口,其装饰功能子类filteroutputstream，类图如下：

输出流基本使用流程

输出流往往和某些数据的目标媒介相关联，比如文件，网络连接，管道等，如下将字符串apache写入当前项目data目录下的output.txt文件

package com.molyeo.java.io;
    
import org.slf4j.logger;
import org.slf4j.loggerfactory;

import java.io.*;

/**
 * created by zhangkh on 2018/8/5.
 */
public class bytedbasedoutputstream {
    static logger logger = loggerfactory.getlogger(bytebasedinputstream.class.getname());

    public static void main(string[] args) throws ioexception {
        file path = new file(".");
        file file = new file(path, "data/output.txt");
        logger.info(file.getabsolutepath());
        write(file, "apache");
    }

    public static void write(file file, string content) throws ioexception {
        try (fileoutputstream output = new fileoutputstream(file)) {
            byte[] bytesarray = content.getbytes();
            for (int i = 0; i < bytesarray.length; i++) {
                output.write(bytesarray[i]);
                logger.info("bytedata={}, char result={}", bytesarray[i], (char) bytesarray[i]);
            }
            output.flush();
        }
    }

}

程序输出如下:

18/08/05 13:00:23 info io.bytedbasedoutputstream: d:\workspace_spark\sparkinaction\.\data\output.txt
18/08/05 13:00:23 info io.bytedbasedoutputstream: bytedata=97, char result=a
18/08/05 13:00:23 info io.bytedbasedoutputstream: bytedata=112, char result=p
18/08/05 13:00:23 info io.bytedbasedoutputstream: bytedata=97, char result=a
18/08/05 13:00:23 info io.bytedbasedoutputstream: bytedata=99, char result=c
18/08/05 13:00:23 info io.bytedbasedoutputstream: bytedata=104, char result=h
18/08/05 13:00:23 info io.bytedbasedoutputstream: bytedata=101, char result=e

outputstream常用方法如下。

write(byte[])
outputstream同样包含了将字节数据中全部或者部分数据写入到输出流中的方法，分别是write(byte[])和write(byte[], int offset, int length)。
write(byte[])把字节数组中所有数据写入到输出流中。
write(byte[], int offset, int length)把字节数据中从offset位置开始，length个字节的数据写入到输出流。

flush()
outputstream的flush()方法将所有写入到outputstream的数据冲刷到相应的目标媒介中。比如，如果输出流是fileoutputstream，那么写入到其中的数据可能并没有真正写入到磁盘中。即使所有数据都写入到了fileoutputstream，这些数据还是有可能保留在内存的缓冲区中。通过调用flush()方法，可以把缓冲区内的数据刷新到磁盘(或者网络，以及其他任何形式的目标媒介)中。

close()
当你结束数据写入时，需要关闭outputstream。通过调用close()可以达到这一点。因为outputstream的各种write()方法可能会抛出io异常，所以你需要把调用close()的关闭操作方在finally块中执行。如果使用基于try-with-resource的异常处理程序则由于实现了autocloseable接口，不用显示关闭。

filteroutputstream

filteroutputstream主要有3个子类，可以用来修改outputstream的内部行为。

3个字类添加的功能如下：

类名	功能
dataoutputstream	与datainputstream配合使用，可以用可携带的方式往流里写基本类型
bufferedoutputstream	写入缓冲区，而不是每次往流里写数据，都要进行物理操作
printstream	负责生成带格式的输出。dataoutputstrem负责数据的存储，而printstream负责数据的显示。

我们用bufferedoutputstream给fileoutputstream方法添加缓存区，改写后的write方法如下：

public static void writewithbuffer(file file, string content) throws ioexception {
    try (fileoutputstream fileoutputstream = new fileoutputstream(file);
        bufferedoutputstream output=new bufferedoutputstream(fileoutputstream)
    ) {
        byte[] bytesarray = content.getbytes();
        for (int i = 0; i < bytesarray.length; i++) {
            output.write(bytesarray[i]);
            logger.info("bytedata={}, char result={}", bytesarray[i], (char) bytesarray[i]);
        }
        output.flush();
    }
}

reader和writer

reader类图

reader类图如下,reader实现readable和closeable接口，根据不同的功能有众多的子类。

子类必须实现的方法只有 read() 和 close()

read()

public int read() throws ioexception

用于读取单个字符。在字符可用、发生 i/o 错误或者已到达流的末尾前，此方法一直阻塞。用于支持高效的单字符输入的子类应重写此方法。

返回：作为整数读取的字符，范围在 0 到 65535 之间 ( 0x00-0xffff)，如果已到达流的末尾，则返回 -1

read(char[] cbuf,int off,int len)

public abstract int read(char[] cbuf,int off,int len) throws ioexception

将字符读入数组的某一部分。在某个输入可用、发生 i/o 错误或者到达流的末尾前，此方法一直阻塞。

参数：  
    cbuf - 目标缓冲区
    off - 开始存储字符处的偏移量
    len - 要读取的最多字符数
返回：
  读取的字符数，如果已到达流的末尾，则返回 -1
抛出：
   ioexception - 如果发生 i/o 错误

输入字符流使用流程

这里我们还是读取当前项目data目录下的data.txt文件，示例代码如下：

package com.molyeo.java.io;

import org.slf4j.logger;
import org.slf4j.loggerfactory;

import java.io.*;

/**
 * created by zhangkh on 2018/8/5.
 */
public class characterbasedreader {
    static logger logger = loggerfactory.getlogger(characterbasedreader.class.getname());

    public static void main(string[] args) throws ioexception {
        file path = new file(".");
        if (path.isdirectory()) {
            logger.info("root: directory is {}", path.getabsolutepath());
            string[] list;

            list = path.list(new dirfilter("d.*"));
            logger.info("file after first filter:");

            for (string diritem : list) {
                file file = new file(path, diritem);
                if (file.isdirectory()) {
                    logger.info("child: {} is a directory", diritem);
                    string[] childlist = file.list(new dirfilter("data*.txt"));
                    logger.info("file after second filter");
                    for (string childitem : childlist) {

                        file childfile = new file(file, childitem);
                        if (childfile.isfile()) {
                            logger.info("secondary child: {} is a file", childitem);
                            logger.info("start read file {}", childfile.getcanonicalpath());
                            read(childfile);
                        }
                    }
                } else {
                    logger.info("child: {} is a file", diritem);
                }

            }


        } else {
            logger.info("root is not a directory");
        }

    }
    public static void read(file file) throws ioexception{
        try(filereader reader=new filereader(file)){
            int bytedata = reader.read();
            while (bytedata != -1) {
                logger.info("bytedata={}, char result={}", bytedata, (char) bytedata);
                bytedata = reader.read();
            }
        }
    }
}

输出结果如下：

18/08/05 18:45:15 info io.characterbasedreader: root: directory is d:\workspace_spark\sparkinaction\.
18/08/05 18:45:15 info io.characterbasedreader: file after first filter:
18/08/05 18:45:15 info io.characterbasedreader: child: data is a directory
18/08/05 18:45:15 info io.characterbasedreader: file after second filter
18/08/05 18:45:15 info io.characterbasedreader: secondary child: data.txt is a file
18/08/05 18:45:15 info io.characterbasedreader: start read file d:\workspace_spark\sparkinaction\data\data.txt
18/08/05 18:45:15 info io.characterbasedreader: bytedata=72, char result=h
18/08/05 18:45:15 info io.characterbasedreader: bytedata=97, char result=a
18/08/05 18:45:15 info io.characterbasedreader: bytedata=100, char result=d
18/08/05 18:45:15 info io.characterbasedreader: bytedata=111, char result=o
18/08/05 18:45:15 info io.characterbasedreader: bytedata=111, char result=o
18/08/05 18:45:15 info io.characterbasedreader: bytedata=112, char result=p

需要注意的是，java内部使用utf8编码表示字符串。输入流中一个字节可能并不等同于一个utf8字符
，如果你从输入流中以字节为单位读取utf8编码的文本，并且尝试将读取到的字节转换成字符，你可能会得不到预期的结果。
如果输入的文件不是utf8编码的话，由于filereader不能指定编码，则需要利用字节流，然后利用转换流将字节流转换为字符流。

inputstream inputstream = new fileinputstream("d:\workspace_spark\sparkinaction\data\data.txt");
reader reader = new inputstreamreader(inputstream, "utf-8");

writer类图

writer的类图如下，主要实现appendable,flushable,closeable接口，根据不同的功能有众多的子类。

主要的api接口如下：
write(string str)
public void write(string str) throws ioexception
写入字符串。
参数：
str - 要写入的字符串
抛出：
ioexception - 如果发生 i/o 错误

write(string str,int off,int len)

public void write(string str,int off,int len) throws ioexception
写入字符串的某一部分。
参数：
str - 字符串
off - 相对初始写入字符的偏移量
len - 要写入的字符数
抛出：
indexoutofboundsexception - 如果 off 或 len 为负，或者 off+len 为负或大于给定字符串的长度
ioexception - 如果发生 i/o 错误

flush()

public abstract void flush() throws ioexception
刷新该流的缓冲。如果该流已保存缓冲区中各种 write() 方法的所有字符，则立即将它们写入预期目标。然后，如果该目标是另一个字符或字节流，则将其刷新。因此，一次 flush() 调用将刷新 writer 和 outputstream 链中的所有缓冲区。
如果此流的预期目标是由底层操作系统提供的一个抽象（如一个文件），则刷新该流只能保证将以前写入到流的字节传递给操作系统进行写入，但不保证能将这些字节实际写入到物理设备（如磁盘驱动器）。
抛出：
ioexception - 如果发生 i/o 错误

输出字符流使用流程

输出流往往和某些数据的目标媒介相关联，比如文件，网络连接，管道等，如下将字符串apache写入当前项目data目录下的output.txt文件

package com.molyeo.java.io;

import org.slf4j.logger;
import org.slf4j.loggerfactory;

import java.io.file;
import java.io.filewriter;
import java.io.ioexception;

/**
 * created by zhangkh on 2018/8/5.
 */
public class characterbasedwriter {
    static logger logger = loggerfactory.getlogger(characterbasedwriter.class.getname());

    public static void main(string[] args) throws ioexception {
        file path = new file(".");
        file file = new file(path, "data/output.txt");
        logger.info(file.getabsolutepath());
        write(file, "apache");

    }

    public static void write(file file, string content) throws ioexception {
        try (filewriter output = new filewriter(file)) {
            output.write(content);
            output.flush();
        }
    }
}

示例中以文件作为参数构造实例filewriter,将会新写入的内容将会覆盖原文件。
以下的构造函数取文件名和一个布尔变量作为参数，布尔值表明你是想追加还是覆盖该文件。例子如下：

writer writer = new filewriter(file, true); //appends to file
writer writer = new filewriter(file, false); //overwrites file

调用write方法写入具体的值，调用flush接口刷新缓冲区，将数据流传递给操作系统进行写入。
需要注意的是，上述输出的内容编码格式为utf8,如果要输出其他编码格式，和reader一样，要利用字节流，然后转换为字符流后以便于操作。

outputstream outputstream = new fileoutputstream(file,charsetname);
writer writer = new outputstreamwriter(outputstream);
writer.write("apache");
writer.close();

字节流和字符流转换

输入字节流转换
inputstreamreader是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集,即utf-8编码。
inputstreamreader的构造函数输入字节流

public inputstreamreader(inputstream in) {
    super(in);
    try {
        sd = streamdecoder.forinputstreamreader(in, this, (string)null); // ## check lock object
    } catch (unsupportedencodingexception e) {
        // the default encoding should always be available
        throw new error(e);
    }
}

通过调用streamdecoder类的forinputstreamreader方法，设置var2为null

public static streamdecoder forinputstreamreader(inputstream var0, object var1, string var2) throws unsupportedencodingexception {
    string var3 = var2;
    if(var2 == null) {
        var3 = charset.defaultcharset().name();
    }

    try {
        if(charset.issupported(var3)) {
            return new streamdecoder(var0, var1, charset.forname(var3));
        }
    } catch (illegalcharsetnameexception var5) {
        ;
    }

    throw new unsupportedencodingexception(var3);
}

进而调用类charset的defaultcharset方法，设置编码格式为utf-8。

public static charset defaultcharset() {
    if (defaultcharset == null) {
        synchronized (charset.class) {
            string csn = accesscontroller.doprivileged(
                new getpropertyaction("file.encoding"));
            charset cs = lookup(csn);
            if (cs != null)
                defaultcharset = cs;
            else
                defaultcharset = forname("utf-8");
        }
    }
    return defaultcharset;
}

其他指定编码格式的构造函数如下：

public inputstreamreader(inputstream in, string charsetname) throws unsupportedencodingexception
public inputstreamreader(inputstream in, charset cs) 
public inputstreamreader(inputstream in, charsetdecoder dec) 

每次调用 inputstreamreader 中的一个 read() 方法都会导致从底层输入流读取一个或多个字节。要启用从字节到字符的有效转换，可以提前从底层流读取更多的字节，使其超过满足当前读取操作所需的字节。
为了达到最高效率，可要考虑在bufferedreader内包装inputstreamreader。例如：

bufferedreader in = new bufferedreader(new inputstreamreader(system.in));

如下我们看一个实例，从控制台输入字符串，并将输入字节流转换为字符流。

package com.molyeo.java.io;

import java.io.bufferedreader;
import java.io.ioexception;
import java.io.inputstreamreader;
import java.io.unsupportedencodingexception;

/**
 * created by zhangkh on 2018/8/22.
 */
public class streamtransform {
    public static void main(string[] args) {

        string readstr = "";
        try (inputstreamreader inputstreamreader = new inputstreamreader(system.in, "utf-8");
             bufferedreader bufferreader = new bufferedreader(inputstreamreader)
        ) {
            system.out.println("please enter a string");
            readstr = bufferreader.readline();
            system.out.println("the input is " + integer.valueof(readstr));
        } catch (unsupportedencodingexception e) {
            e.printstacktrace();
        } catch (ioexception e) {
            e.printstacktrace();
        } catch (numberformatexception e) {
            e.printstacktrace();
        }
    }
}

输出字节流转换
outputstreamwriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。可以指定此缓冲区的大小，不过，默认的缓冲区对多数用途来说已足够大。注意，传递给 write() 方法的字符没有缓冲。
为了获得最高效率，可考虑将 outputstreamwriter 包装到 bufferedwriter 中，以避免频繁调用转换器。例如：

writer out = new bufferedwriter(new outputstreamwriter(system.out));

java io 的一般使用原则 ：

按数据来源或去向

文件： fileinputstream, fileoutputstream,filereader, filewriter
byte[] ： bytearrayinputstream, bytearrayoutputstream
char[]: chararrayreader, chararraywriter
string: stringbufferinputstream, stringbufferouputstream，stringreader, stringwriter
网络数据流： inputstream, outputstream, reader, writer

按是否格式化输出

格式化输出： printstream, printwriter

按是否要缓冲

缓冲： bufferedinputstream, bufferedoutputstream, bufferedreader, bufferedwriter

按数据格式

二进制格式（只要不能确定是纯文本的） : inputstream, outputstream 及其所有带 stream 结束的子类。
纯文本格式（含纯英文与汉字或其他编码方式）； reader, writer 及其所有带 reader, writer 的子类。

本文详细介绍讲述了java io的相关内容，涉及到字节流和字符流的设计，使用原则等。

本文参考：