Java基础IO流~~复习用

文章目录

• IO流概念
• 字节流
• 字符流

IO流概念

流的定义：
流是指一连串流动的字符,是以先进先出方式发送信息的通道。
分类:
按流向分：
输入流
输出流
按数据类型分：
字节流：
字节输入流 InputStream(抽象类)
字节输出流 OutputStream(抽象类)
字符流：
字符输入流 Reader
字符输出流 Writer

注意：I/O默认按照数据类型分类

File类

概念：

Java中万物皆对象，所以在计算机中的文件夹与文件也可以当做一个对象，那么创建这些对象的类就为File类

Java中提供java.io.File类操作文件及目录

常用方法

路径书写常用格式： 盘符://文件夹/文件夹/文件

构造方法

//F://test/a/a.txt
//使用构造方法创建指定文件对象
//1、使用地址字符串直接创建
File f1=new File("F://test/a/a.txt");
//2、使用在已有file对象下的文件
File file=new File("F://test/a");
File f2=new File(file,"a.txt");
//3、使用文件所在文件夹的字符串与文件名创建
File f3=new File("F://test/a","a.txt");  

字节流

InputStream: 程序可以从中连续读取字节的对象称为字节输入流
OutputStream: 程序可以向其中连续写入字节的对象称为字节输出流

InputStream与OutputStream为抽象类，在实际开发过程中，根据使用使用不同的子类进行需求的书写，但多数为为文件进行读取写入操作。

引入相关的类：InputStream ins =null;
构建输入流，例如FileInputStream：
ins =new FileInputStream（new File（path））;
操控字节输入流的，所用的方法也是针对字节的

使用子类FileInputStream和FileOutputStream分别读取和写入文件的内容

FileOutputStream的构造方法

public FileOutputStream(File file,boolean append)

其中boolean flag参数是可选的．true表示以追加模式打开文件，false表示以覆盖模式打开文件默认情况下flag参数值为false。

FilelnputStream的构造方法：

public FileInputStream(File file)
常用方法：

字节流使用场景：
当进行文件复制时使用字节流进行复制，无需将读取写入内容输出至控制台或者进行查看。
例如、图片、视频、音乐等文件

public class FileSteamTest {
public static void main(String[] args) throws Exception {
//使用文件字节输入流与文件字节输出流实现文件的复制
//1创建读取写入文件对象
File file1=new File("D://e.zip");//原文件
File file2=new File("D://test/e.zip");//新文件
// File file3=new File("D://test/b.txt");
if(file2.exists()) {
System.out.println("已存在");
}else {
File parentFile = file2.getParentFile();
parentFile.mkdirs();
file2.createNewFile();
//2创建相应操作流
FileInputStream fis=new FileInputStream(file1);
FileOutputStream fos=new FileOutputStream(file2);//append=false
// FileOutputStream fos1=new FileOutputStream(file3);//append=false
//3进行相应操作
//边读取边写入
int length=0;//读取长度
byte []b =new byte[1024];
while((length=fis.read(b))!=-1) {
fos.write(b, 0, length);
//fos1.write(b, 0, length);
}
fis.close();
fos.flush();
fos.close();
// fos1.flush();
//fos1.close();
}
}
public static void output() throws Exception {
// 1创建file对象
File f = new File("D://test/a/a.txt");
// 2创建操作流
FileOutputStream fos=new FileOutputStream(f,true);
// 3执行操作
// fos.write(byte[]); 将指定字节数组写入文件
// fos.write(int); 写入单个字节ascii码代表的字符
// fos.write(b, off, len); 将指定字节数组写入文件 从指定索引开始指定长度

OutputStream
常用方法：

同InputStream

字符流

Reade和Writer是两个抽象类，分别与InputStream和OutputStream对应

FileReader和FileWriter是Reader和Writer的子类，主要用于读写字符文件
与FileInputStream和FileOutputStream对应（使用方式也相似）
字符流本质是按指定编码进行读取数据的字节流

FileInputStream是读取原始字节的图像数据流。读取字符流，考虑使用FileReader。

常用方法：
见InputStream中的方法

构建输入流：（准备工作）

FIle file =new File（path）;
InputStream ins =null;
ins =new FileInputStream; //这里需要try catch

读取文件字符：

int i =0;
while( ( i=ins.read( ) ) ！= -1）{
System.out.println( i );
} //输出的是自动转化的ASCII值，此处会抛出 IOException，需要try catch

或者提高效率，使用缓冲数组byte[ ] b,可读取英文文件，需要转化成char字符：

int len =0;
byte [ ]b=new byte [ 1024 ];//建立缓冲流数组
while(（len=ins.read( b )）!= -1）{
         for( int j=0;j<len ;j++){
         System.out.println( (char) bt [ j ] );
     }
} //中间嵌套for循环，读多少输出多少，中文不可用，会输出乱码-->此处会抛出  IOException，需要try catch

完整案例：

package cn.pojo;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class InputStreamDemo {
            public static void main(String[] args) {
                        readByte();
                        readArr();
            }
            /**
             * 读取字节
             */
            public static void readByte() {
                        // 1、明确源数据源
                        File f = new File("F:\\1\\余文佳\\1.txt");
                        // 2、构建输入流对象
                        InputStream ins = null;
                        try {
                                    ins = new FileInputStream(f);
                                    int i;
                                    // 3、 读取文件字符
                                    while ((i = ins.read()) != -1) {
                                                System.out.println("i=" + i);// 输出为转化的ascii码值
                                    }
                        } catch (Exception e) {
                                    e.printStackTrace();
                        } finally {
                                    // 4、关闭资源
                                    if (ins != null) {
                                                try {
                                                            ins.close();
                                                } catch (Exception e) {
                                                            e.printStackTrace();
                                                }
                                    }
                        }
            }
            // 2、使用缓冲数组的方法读取文件内容,提高效率
            public static void readArr() {
                        // 1、明确源数据源
                        File f = new File("F:/1/余文佳/1.txt");
                        // 2、构建流的对象
                        InputStream ins = null;
                        try {
                                    ins = new FileInputStream(f);
                                    // 3、声明缓冲数组
                                    int i;// 表示读取了多少个字符到数组中
                                    byte[] bt = new byte[5];// 字节缓冲数组
                                    // 4、读取数据到数组中
                                    while ((i = (ins.read(bt))) != -1) {
                                                for (int j = 0; j < i; j++) {
                                                            System.out.print((char) bt[j]);
                                                }
                                    }
                        } catch (Exception e) {
                                    e.printStackTrace();
                        } finally {
                                    //关闭流
                                    try {
                                                if (ins != null) {
                                                            ins.close();
                                                }
                                    } catch (Exception e) {
                                                e.printStackTrace();
                                    }
                        }
            }
}

FileOutputStream

是OutputSTream的子类，主要功能是从源文件写入资料至指定文件中

构造方法：
FileOutputStream( File file )// 创建“File对象”对应的“文件输入流”；默认“追加模式”是false，即“写到输出的流内容”不是以追加的方式添加到文件中。若要追加则为（File file， true）;
FileOutputStream( String path ) // 创建“文件(路径为path)”对应的“文件输入流”； （若没有，自动系统调用方法创建）
默认“追加模式”是false，即“写到输出的流内容”不是以追加的方式添加到文件中。 若要追加则为（String path， true）;

try {
                // 构造方法1
                File file = new File("E:/java47.txt");
                FileOutputStream fos1 = new FileOutputStream(file);
                // File file = new File("E:/java47.txt");
                // FileOutputStream fos1 = new  FileOutputStream(file);
                // 没有该文件会直接创建文件，但不能有多级目录，否则会报错，或者这只是个目录
                // -->java.io.FileNotFoundException:E:\java\java48.txt (系统找不到指定的路径。)
                // 构造方法2       
                FileOutputStream fos2 = new FileOutputStream("E:/java/java48.txt");// 规则如上
           } catch (Exception e) {
                e.printStackTrace();
           }
 

常用方法：（同OutputStream）
返回值类型 方法名 方法简介
void flush( ) 刷新输出流，是缓存数据被写出来
void write(byte [ ] b) 写b.length 字节从指定的字节数组的输出流
void write(byte [ ] b, int off, int len) 写len字节从字节数组数据中到输入流
abstract int write( int b ) 将指定的字节写入该输出流中
void close( ) 关闭流
应用主要步骤：1、构建字节输出流对象
2、写数据
3、关闭流
案例：

package cn.pojo;
 
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
 
/**
* 字节输出流案例
*
* @author kuang
*
*/
public final class OutputStreamDemo {
 
        public static void main(String[] args) {
                // 1、明确目标数据源
                File f = new File("E:/java48/java48.txt");
                // 判断文件是否存在，否则创建
                if (!f.exists()) {
                    f.getParentFile().mkdirs();// 先创建目录
                    try {
                        f.createNewFile();// 再创建文件 此处需要处理异常，
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                // 2、构建输出流对象（通过子类实例化父类的对象）
                OutputStream outs = null ; // 首先准备好一个输出的对象
                try {
                    outs = new FileOutputStream(f) ; // 构造方法 ，实例化，此处需要处理异常
                    // 执行写入文件的操作
                    String st = "java48班" ; // 创建字符串
                    byte[] bt = st.getBytes(); // 只能输出byte数组，所以将字符串变为byte数组
                                                           // 使用String st.getByte();方法
                    outs.write(bt); // 将内容输出，保存文件
                    outs.flush(); // 刷新输出流
                    System.out.println("写入成功！"); // 若（文件夹必须存在）没有文件，会创建文件然后写入;若文件已有相同内容，则直接覆盖
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                        // 4、关闭资源
                        if (outs != null) { 
                        try {
                            outs.close(); // 此处也要处理异常
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
        }
}

Test：用FileInputStream 和 FileOutputStream 实现文件的复制

package cn.pojo;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
public class Demo {
     // 检查文件是否存在，否则创建
     public static void checkFile(File file) {
           if (!file.exists()) {
                file.getParentFile().mkdirs();// 创建多级目录
                try {
                     file.createNewFile();// 创建文件，此处需要处理异常
                     System.out.println("创建文件成功！");
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
     public static void main(String[] args) {
           // 明确源文件和目标文件
           File o = new File("E:/java48/java48.txt");// 源文件
           File t = new File("E:/java48/新建.txt");// 目标文件
           checkFile(t);// 这里仅仅检查了目标文件
           // 构建输入、输出流对象
           InputStream ins = null; // 输入的对象
           OutputStream outs = null; // 输出的对象
           // 进行实例化,需要处理异常
           try {
                ins = new FileInputStream(o);// 源文件作为输入对象--->若要拼接后面加上true
                outs = new FileOutputStream(t);// 目标文件作为输出对象--->若要拼接后面加上true
                // 创建缓冲数组
                byte[] b = new byte[1024];
                int len = 0;
                // 执行边读边写操作
                while ((len = ins.read(b)) != -1) {
                     outs.write(b, 0, len);
                }
                // 刷新输出流
                outs.flush();
                // 至此复制成功
           } catch (Exception e) {
                e.printStackTrace();
           } finally {
                // 关闭流（先开的后关）
                try {
                     if (outs != null) {// 为了避免空指针异常，进行判空
                           outs.close();
                     }
                     if (ins != null) {
                           ins.close();
                     }
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
}

字节高效流

BufferedInputStream

带缓冲区的输入流，默认缓冲区大小是8M，能够减少访问磁盘的次数，提高文件读取性能；是 FileInputStream 的子类。 实现了装饰设计模式！

BufferedInputStream没有无参构造方法,它必须传入一个InputStream(一般是FileInputStream)，来一起使用，以提高读写效率。
构造方法：
1、BufferInputStream（InputStream in）

// 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

创建一个内部缓冲区数组并将其存储在 buf 中,该buf的大小默认为8192。

2、BufferedInputStream（InputStream in, int size）

//创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

创建一个长度为 size 的内部缓冲区数组并将其存储在 buf 中。

常用方法：

BufferedOutputStream

带缓冲区的输出流，能够提高文件的写入效率。实现了装饰设计模式！

BufferedOutputStream

没有无参构造方法,它必须传入一个OutputStream(一般是FileOutputStream)，来一起使用，以提高读写效率。

构造方法：
1、BufferOutputStream（OutputStream outs）// 创建一个 BufferedInputStream 并保存其参数，即输出流outs，将数据写入指定的基本输入流中。
2、BufferedOutputStream（OutputStream outs, int size） //创建具有指定缓冲区大小的 BufferedOutputStream ，即输出流outs，将数据写入指定的基本输入流中 。

常用方法：

Test：
使用 BufferedInputStream 和 BufferedOutputStream 实现文件的复制
（与上面的FileInputStream Test类似）

tips：
为什么要用BufferedInputStream 和 BufferedOutputStream？
优点：效率高
缺点：内存占用多
why？
不带缓冲的操作，每读一个字节就要写入一个字节，由于涉及磁盘的IO操作相比内存的操作要慢很多，所以不带缓冲的流效率很低。
带缓冲的流，可以一次读很多字节，但不向磁盘中写入，只是先放到内存里。等凑够了缓冲区大小的时候一次性写入磁盘，这种方式可以减少磁盘操作次数，速度就会提高很多。

可以理解为在创建时额外创建了缓冲区，在进行读取时会现将数据缓存到缓存区，我们可以直接在缓冲区获取指定数据，这样大大的提高了读取速度，在进行输出的时候，也是将数据输出至缓冲区，当缓冲区存储的数据达到一定量时写入至相应位置

BufferedInputStream和BufferedOutputStream为InputStream和OutputStream增加了内存缓冲区,从而提高整个系统的性能。

public BufferedInputStream(InputStream in)
public BufferedInputStream(InputStream in,int size)
第一种形式的构造方法创建带有32个字节缓冲区的缓冲流
第二种形式的构造方法按照创建了指定大小的缓冲区。

public BufferedOutputStream(OutputStream in)
public BufferedOutputStream(OutputStream in,int size)
第一种形式的构造方法创建带有32个字节缓冲区的缓冲流
第二种形式的构造方法按指定的大小来创建缓冲区。

方法使用与文件字符输入流、文件字符输出流一样，但我们通常使用高效流进行文件的读取与写入。

public class BufferedSteamTest {
public static void main(String[] args) throws Exception {
// 高效流
// 在基本的文件输入输出流的基础上进行添加缓冲区 从而达到提高效率的过程
// 会自动将要读取/写入的内容缓存到缓冲区，
// 在进行读取操作时，直接从缓冲区进行数据的读取而不需要直接访问数据源
// 在进行写入操作时，将要写入的数据写入缓冲区，当缓冲区达到一定数据量时自动写入文件 
// 1创建file对象
File f = new File("D://e.zip");
File f1 = new File("D://a.zip");
// 2创建相应流
FileInputStream fis=new FileInputStream(f);
FileOutputStream fos=new FileOutputStream(f1);
//根据已有输入流创建高效流
//默认创建32字节
BufferedInputStream bis=new BufferedInputStream(fis,1024);
BufferedOutputStream bos=new BufferedOutputStream(fos);
//3 执行操作
int len=0;
byte [] b=new byte[10240];
Date d=new Date();
while((len=bis.read(b))!=-1) {
bos.write(b, 0, len);
}
Date d1=new Date();
//4关闭
bis.close();
bos.flush();
bos.close();
System.out.println("执行时间："+(d1.getTime()-d.getTime()));
}
}
 
 

高效字节流与文件字节流的使用场景
高效字节流可以理解为在字节流的基础上添加的额外的缓冲区，使用缓冲区进行文件读取与写入时比不使用效率更高，通常在使用高效流时通常进行读取时会与读取的数组一同使用。
到达一定的阀值，提升效果就没有那么明显。
当只需要进行简单小文件复制时使用哪种方式读取写入都可以，但是进行大文件的读取写入时，建议使用高效流。

字符高效流

与字节高效流相同，就是为相应的流开辟缓冲区进行数据的存储。

public static void main(String[] args) throws Exception {
File f1 = new File("D://shz1.txt");
File f2 = new File("D://shz4.txt");
FileReader fr = new FileReader(f1);
FileWriter fw = new FileWriter(f2, true);
BufferedReader br=new BufferedReader(fr,1024);
//高效字符输入流
BufferedWriter bw=new BufferedWriter(fw);
//高效字符输出流
int len = 0;char[] c = new char[1024];
Date d1 = new Date();
while ((len = br.read(c)) != -1) {
bw.write(c, 0, len);
}
Date d2 = new Date();
br.close();
bw.flush();
bw.close();
System.out.println("时间:" + (d2.getTime() - d1.getTime())); 
}

BufferedReader（缓冲流）
特点：
字节输入缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。BufferedReader 由Reader类扩展而来，提供通用的缓冲方式文本读取，而且提供了很实用的readLine。

构造方法：
1、BufferedReader( Reader in ) ； 创建一个使用默认大小输入缓冲区的缓冲字符输入流
2、BufferedReader( Reader in, int sz ) ； 创建一个使用指定大小的输入缓冲区的缓冲字符输入流

常用方法：
该类读取文本的方法就是父类Reader提供的read（）系列方法（见2.1.1 InputStreamReader）。在这里仅介绍他自己特有的方法readLine()

//public String readLine()throws IOException读取一个文本行。通过下列字符之一即可认为某行已终止：换行 (’\n’)、回车 (’\r’) 或回车后直接跟着换行。

 public static void readLineTest() throws IOException{
     BufferedReader br=new BufferedReader(new FileReader("E:\\test\\javaIo\\1.txt"));               
     String str=null;
     while((str=br.readLine())!=null){
         System.out.println(str);
     }
     br.close();
 }

BufferedWriter （缓冲流）

特点： 字节输出缓冲流，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。 该类提供了 newLine() 方法，它使用平台自己的行分隔符概念，此概念由系统属性 line.separator 定义。

构造方法：
1、BufferedWriter( Writer out ) ；创建一个使用默认大小输出缓冲区的缓冲字符输出流
2、BufferedWriter( Writer out, int sz ) ；创建一个新的缓冲字符输出流，该流使用给定大小的输出缓冲区。

常用方法：
该类写入文本的方法就是父类Writer提供的write（）系列方法（见2.2.1 OutputStreamWriter），在这里仅介绍他特有的newLine( )方法。

例：

 
  public static void newLineTest() throws IOException{
                   BufferedWriter bw=new BufferedWriter(new FileWriter("E:\\test\\javaIo\\2.txt"));
                   bw.write("爱我");
                   bw.newLine();
                   bw.write("中华");
                   bw.flush();
                   bw.close();
               }
           //结果:(加入了换行符)
           　　爱我
           　　中华

字符缓冲流 案例：
（使用 BufferedReader 和 BufferedWriter）

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.Reader;
import java.io.Writer;
/**
 * 字符缓冲流
 *
 * @author kuang
 *
 */
public class Demo2 {
     public static void main(String[] args) {
           // 1、指明源和目标
           File o = new File("F:/temp/java48.template");
           File t = new File("F:/temp/java48.txt");
           // 2、构建流的对象
           Reader re = null;
           Writer wt = null;
           BufferedReader bfr = null;
           BufferedWriter bfw = null;
           try {
                re = new FileReader(o);
                bfr = new BufferedReader(re);
                wt = new FileWriter(t);
                bfw = new BufferedWriter(wt);
                String msg = null;
                // 读取操作
                while ((msg = bfr.readLine()) != null) {// 读一行
                     // System.out.println(msg);
                     bfw.write(msg);
                     bfw.write("\r\n");// 执行换行，读一行 写一行 换行
                     // 或者 ：bfw.newLine();//换行
                }
                bfw.flush();
           } catch (Exception e) {
                e.printStackTrace();
           } finally {
                // 关闭流
                try {
                     if (wt != null) {// 为了避免空指针异常，进行判空
                           wt.close();
                     }
                     if (re != null) {
                           re.close();
                     }
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
}

转换流

在进行io流代码书写时，按照数据类型分为字节流与字符流，但字符流的本质就是按照一定格式读取多个字节的字节流，转换流就是将字节流按照一定的编码格式转换为字符流

OutputStreamWriter 字符输出流

public OutputStreamWriter(OutputStream out)：
根据默认编码把字节流的数据转换为字符流

public OutputStreamWriter
(OutputStream out,String charsetName)：
根据指定编码把字节流数据转换为字符流

InputStreamReader 字符输入流
public InputStreamReader(InputStream in)：

用默认的编码读取数据字节流转换为字符输入流

public InputStreamReader
(InputStream in,String charsetName)：

用指定的编码读取数据转换为字符输入流

// 转换流
public static void main(String[] args) throws Exception {
File file = new File("D://stream1.txt");
// 在输出到文件时，将输出流使用转换流转换
// 不使用转换流输出数据
// FileWriter fw = new FileWriter(file, true);
// fw.write("你好");
FileOutputStream fos=new FileOutputStream(file);
OutputStreamWriter osw=new OutputStreamWriter(fos,"UTF-8");
BufferedWriter bw=new BufferedWriter(osw);
bw.write("你好");
bw.flush();
bw.close();
}
public static void InputStreamReader() throws Exception {
File file = new File("D://stream.txt");
// 转换流是将字节流与字符流进行相互转换
// 在进行文件读取时，先使用字节流读取文件之后使用转换流转换
FileReader fr = new FileReader(file);// 不使用转换流直接读取
// 创建字节流使用转换流将字节流转换为指定字符编码的字符流
FileInputStream fis = new FileInputStream(file);
InputStreamReader isr = new InputStreamReader(fis, "GB2312");
BufferedReader br = new BufferedReader(isr);
System.out.println(br.readLine());
br.close();
}

InputStreamReader

特点：
将字节输入流转换为字符输入流。是字节流通向字符流的桥梁，可以指定字节流转换为字符流的字符集。

构造方法：
1、InputStreamReader( InputStream ins) ; 创建一个默认字符集的 InputStreamReader
2、InputStreamReader( InputStream ins ，“ encoding”) ; 创建使用指定字符集的 InputStreamReader

常用方法：

读文件内容的常用三种方法：
1、int read（）

 //public int read() throws IOException
 //读取单个字符。在字符可用、发生 I/O 错误或者已到达流的末尾前，此方法一直阻塞。
 public static void readOneStr() throws IOException{
     InputStreamReader isr=new InputStreamReader(new FileInputStream("E:\\test\\javaIo\\1.txt"));
     int ch=0;
     while((ch=isr.read())!=-1){
         System.out.print((char)ch);
     }
     isr.close();
}

2、int read( char [ ]ch, int off, in len )

 //public int read(char[] cbuf) throws IOException
 //将字符读入数组。在某个输入可用、发生 I/O 错误或者已到达流的末尾前，此方法一直阻塞。
 public static void readOneStrArr() throws IOException{
     InputStreamReader isr=new InputStreamReader(new FileInputStream("E:\\test\\javaIo\\1.txt"));
     char [] ch=new char[1024];
     int len=0;
     while((len=isr.read(ch))!=-1){
         System.out.print(new String(ch,0,len));
     }
     isr.close();
 }

3、int read( char [ ] ch)

   //public int read(char[] cbuf) throws IOException
     //将字符读入数组的某一部分。在某个输入可用、发生 I/O 错误或者到达流的末尾前，此方法一直阻塞。
     public static void readOneStrArrLen() throws IOException{
         InputStreamReader isr=new InputStreamReader(new FileInputStream("E:\\test\\javaIo\\1.txt"));
         char [] ch=new char[1024];
         int len=0;
         while((len=isr.read(ch,0,ch.length))!=-1){
             System.out.print(new String(ch,0,len));
         }
         isr.close();
     }

OutputStreamWriter

特点：
将字节输出流转为字符输出流，是字符流通向字节流的桥梁，可使用指定的 encoding 要写入流中的字符编码成字节。
它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。

构造方法：
1、OutputStreamWriter(OutputStream outs) ; 创建使用默认字符编码的 OutputStreamWriter
2、 OutputStreamWriter(OutputStream outs , “ecoding”) ; 可以设置编码格式

常用方法：

用OutputStreamWriter 将内存中的数据写入文件中有5种方式：

1、 void writer( int val )

 //public void write(int c)throws IOException
 //写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。
         public static void writerOneChar() throws IOException{
             OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("E:\\test\\javaIo\\1.txt"));
             osw.write(97);//char ch=(char)97; 
             osw.write('c');
             osw.flush();
             osw.close();
         }
 

2、 void writer( char [ ]ch )

 //public void write(char[] cbuf)throws IOException 写入字符数组。
         public static void writerCharArr() throws IOException{
             OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("E:\\test\\javaIo\\1.txt"));
             char [] ch=new char[]{'我','爱','中','国'};
             osw.write(ch);
             osw.flush();
             osw.close();
         }

3、 void writer( char [ ]ch, int off, int len)

 
 //public abstract void write(char[] cbuf,int off,int len)throws IOException 写入字符数组的某一部分。
         public static void writerCharArrLen() throws IOException{
             OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("E:\\test\\javaIo\\1.txt"));
             char [] ch=new char[]{'我','爱','中','国'};
             osw.write(ch,0,ch.length-1);
             osw.flush();
             osw.close();
         }

4、 viod writer( String str )

 //public void write(String str) throws IOException  写入字符串。
         public static void writerOneStr() throws IOException{
             OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("E:\\test\\javaIo\\1.txt"));
             osw.write("中国");
             osw.flush();
             osw.close();
         }

5、 void writer( String str, int off ,int len )

 //public void write(String str,int off, int len)throws IOException; 写入字符串的某一部分。
         public static void writerOneStrArrLen() throws IOException{
             OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("E:\\test\\javaIo\\1.txt"));
             String str="我爱中国";
             osw.write(str,0,str.length()-2);
             osw.flush();
             osw.close();
         }
 

包装流设置字符集的案例，
使用InputStreamReader 和 OUtputStreamWriter：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.Scanner;
/**
 * 包装流设置字符集
 *
 * @author kuang
 *
 */
public class homework_2 {
     public static void main(String[] args) {
           // 确定源和目标文件
           Scanner sc = new Scanner(System.in);
           File o = new File("kh/java48.template");
           File t = new File("kh/java48.txt");
           check(o);
           check(t);
           // 构建流对象
           InputStream ins = null;
           OutputStream outs = null;
           InputStreamReader insr = null;
           OutputStreamWriter outsw = null;
           try {
                outs = new FileOutputStream(o);// 先做为目标文件写入内容
                outsw = new OutputStreamWriter(outs, "UTF-8");//编码格式为UTF-8
                System.out.println("输入你要写入的内容：");
                String msg = sc.next();
                // 写入内容
                outsw.write(msg);
                // 刷新
                outsw.flush();
                System.out.println("已经完全写入！");
                ins = new FileInputStream(o);// 作为源文件
                insr = new InputStreamReader(ins, "UTF-8");//编码格式为UTF-8
                outs = new FileOutputStream(t);// 作为写入的目标文件
                outsw = new OutputStreamWriter(outs, "UTF-8");//编码格式为UTF-8
                char[] ch = new char[1024];
                int i = 0;
                // 执行边读边写
                while ((i = insr.read(ch)) != -1) {
                     outsw.write(ch, 0, i);
                }
                // 刷新
                outsw.flush();
           } catch (Exception e) {
                e.printStackTrace();
           } finally {
                // 关闭流
                try {
                     if (outs != null) {
                           outs.close();
                     }
                     if (ins != null) {
                           ins.close();
                     }
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
     public static void check(File file) {
           try {
                if (!file.exists()) {
                     file.getParentFile().mkdirs();// 创建文件夹
                     file.createNewFile();// 创建文件
                     System.out.println("没有该文件！已创建成功！");
                }
           } catch (Exception e) {
                e.printStackTrace();
           }
     }
}
 

FileReader FileWriter
与上面InputStreamReader 和 OutputStreamWriter没啥区别 ，不多说