java（io流—字符输入流、字符输出流、转换流）

全栈开发日记

发布于 2022-05-12 20:30:14

9370

发布于 2022-05-12 20:30:14

文章被收录于专栏：全栈开发日记

字符流

java.io.Reader：

字符输入流，是字符输入流的最顶层父类，定义了一些共性方法，是一个抽象类；

共性方法：

int read()：读取单个字符；
int read(char[] cbuf)：将字符读入数组；
abstract int read(char[] cbuf, int off, int len)：将字符读入数组的某一部分；
abstract void close()：关闭该流并释放与之关联的所有资源；

java.io.FileReader extends InputStreamReader extends Reader

FileReader：文件字符输入流；

作用：把硬盘中文件中的数据以字符的方式读取到内存中；

构造方法：

FileReader(String fileName)：在给定从中读取数据的文件名的情况下创建一个新 FileReader；
FileReader(File file)：在给定从中读取数据的 File 的情况下创建一个新 FileReader；

参数：读取文件的数据源；

FileReader fileReader=new FileReader("D:\\Java\\abc.txt");
char[] chars=new char[1024];
int i=0;
while ((i=fileReader.read(chars))!=-1){
      System.out.print(chars);//字符形式
      System.out.print(new String(chars));//这是字符串形式
}
fileReader.close();

java.io.writer：

字符输出流，是所有字符输出流的最顶层，是抽象类；

共性方法：

abstract void close()：关闭此流，但要先刷新它；
abstract void flush()：刷新该流的缓冲；
void write(char[] cbuf)：写入字符数组；
abstract void write(char[] cbuf, int off, int len)：写入字符数组的某一部分；
void write(int c)：写入单个字符；
void write(String str)：写入字符串；
void write(String str, int off, int len)：写入字符串的某一部分；

FileWriter：文件字符输出流；

作用：把内存中字符数据写入文件中；

构造方法：

FileWriter(File file)：根据给定的 File 对象构造一个 FileWriter 对象；
FileWriter(String fileName)：根据给定的文件名构造一个 FileWriter 对象；

参数：写入数据目的；

构造方法的作用：

创建一个FileWriter对象；
根据构造方法中传递的文件/文件路径，创建文件；
会把FileWriter对象指向创建好的文件；

字符输出流使用步骤：

创建FileWriter对象，构造方法中绑定要写入数据的目的地；
使用FileWriter的方法writer，把数据写入内存缓冲区中(字符转换为字节的过程)；
使用FileWriter中的flush()方法，把内存中的数据，刷新到文件中；
释放资源；

flush和close的区别：

flush：刷新缓冲区，流对象可以继续使用；

close：先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了；

代码：

FileWriter fileWriter=new FileWriter("D:\\Java\\abcd.txt",true);
fileWriter.write("你好",0,2); //从零开始 输入两个字符 
fileWriter.write("你好"+"\n"+"世界");
fileWriter.close();

异常处理（JDK7之前）：

FileWriter fileWriter=null;
try {
    fileWriter = new FileWriter("D:\\\\Java\\\\abce.txt");
    for (int i = 0; i < 10; i++) {
         fileWriter.write("哈哈" + i + "\r\n");
    }
}catch (IOException ex){
    System.out.println(ex);
    System.out.println("写入文件失败，请重新尝试");
}finally {
    try {
        if (fileWriter!=null){
            fileWriter.close();
        }
    }catch (IOException ex){
        System.out.println(ex);
        System.out.println("关闭发生错误");
    }
}

JDK7新特性

在try的后边增加一个()，在括号中可以定义流对象；

那么这个流对象的作用域就在try中有效；

异常处理：

try (FileWriter fileWriter= new FileWriter("D:\\Java\\abce.txt");){
    for (int i = 0; i < 10; i++) {
        fileWriter.write("哈哈" + i + "\r\n");
    }
}catch (IOException ex){
      System.out.println(ex);
      System.out.println("写入文件失败，请重新尝试");
}

转换流

java.io.InputStreamReader 继承Reader

字符输入流，读取文本文件；

将字节流转为字符流

方法同io流其他类基本相同；

构造方法：

InputStreamReader(InputStream in(FileInputStream))：创建一个使用默认字符集的 InputStreamReader；
InputStreamReader(InputStream in, String charsetName(要转的编码))：创建使用指定字符集的 InputStreamReader；

public static void readUTF() throws IOException {
    FileInputStream fileInputStream=new FileInputStream("D:\\Java\\abce.txt");
    InputStreamReader inputStreamReader=new InputStreamReader(fileInputStream,"UTF-8");
    char[] chars=new char[1024];
    int i=inputStreamReader.read(chars);
    System.out.println(chars);
    inputStreamReader.close();
}

OutputStreamWriter同上

字符输出流

构造方法也与字符输入流基本相同；

public static void writers() throws Exception {
    FileOutputStream fileout=new FileOutputStream("D:\\Java\\abce.txt");
    OutputStreamWriter out=new OutputStreamWriter(fileout,"GBK");
    out.write("软赢科技");
    out.close();
}

缓冲流

字节缓冲流

写入数据到流中：字节缓冲输出流BufferedOutputStream

读取流中的数据，字节缓冲输入流 BufferedInputStream

字符缓冲流

字符缓冲输入流BufferedReader

字符缓冲输出流 BufferedWriter

字符缓冲流

字符缓冲输入流 BufferedReader

方法：

int read()：读取单个字符；

int read(char[] cbuf, int off, int len)：将字符读入数组的某一部分；

String readLine()：读取一个文本行； 构造方法：

BufferedReader(Reader in)：创建一个使用默认大小输入缓冲区的缓冲字符输入流；

代码：

//读取一行文本
FileReader fr=new FileReader("D:\\Java\\abc.txt");
BufferedReader bfr=new BufferedReader(fr);
String s=bfr.readLine();
System.out.println(s);

//读取全文
FileReader fr=new FileReader("D:\\Java\\abc.txt");
BufferedReader bfr=new BufferedReader(fr);
String s1=null;
while ((s1=bfr.readLine())!=null){
        System.out.println(s1);
}
bfr.close();

字符缓冲输出流 BufferedWriter

void newLine()：写入一个行分割符；运行过结果，和操作系统相互有关系；

System.out.print()：方法的源码就是调用newLine()；

代码：

FileWriter fr=new FileWriter("D:\\Java\\abc.txt");
BufferedWriter bfr=new BufferedWriter(fr);
bfr.write("你好");
bfr.newLine();
bfr.write("我好");
bfr.write("大家好");
bfr.close();

字节缓冲流

字节缓冲输入流 BufferedInputStream

代码：

//字节缓冲输入流
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("D:\\Java\\abc.txt"));
byte[] bytes=new byte[1024];
int i=0;
while ((i=bis.read(bytes))!=-1){
    System.out.println(new String(bytes));//将byte数组转为字符串 
}

字节缓冲输出流 BufferedOutputStream

代码：

//字节缓冲输出流 
BufferedOutputStream bis=new BufferedOutputStream(new FileOutputStream("D:\\Java\\abc.txt"));
byte[] bytes="哈哈".getBytes();//将字符串转为byte数组
bis.write(bytes);
bis.close();

五种拷贝文件方式：

输出后面的注释是运行时间，以下案例中拷贝的是同一个十兆的文本文件；

import java.io.FileInputStream;
import java.io.FileOutputStream;

//字节流读写单个字节
public class Z1 {
    public static void main(String[] args) throws Exception{
        long s = System.currentTimeMillis();
        FileInputStream fileIn=new FileInputStream("D:\\Java\\abc.txt");
        FileOutputStream fileout=new FileOutputStream("D:\\Java\\abc拷贝.txt");
        int i=0;
        while ((i=fileIn.read())!=-1){
            fileout.write(i);
        }
        fileout.close();
        fileIn.close();
        long s1=System.currentTimeMillis();
        System.out.println(s1-s);//太慢
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
//字节流读写字节数组
public class Z2 {
    public static void main(String[] args) throws Exception{
        long s = System.currentTimeMillis();
        FileInputStream fileInput=new FileInputStream("D:\\Java\\abc.txt");
        FileOutputStream file1=new FileOutputStream("D:\\Java\\abc拷贝2.txt");
        int i=0;
        byte[] bytes=new byte[1024];
        while ((i=fileInput.read(bytes))!=-1){
            file1.write(bytes,0,i);
        }
        file1.close();
        fileInput.close();
        long s1 = System.currentTimeMillis();
        System.out.println(s1-s);//123
    }
}

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

//字节流缓冲区读写单个字节
public class Z3 {
    public static void main(String[] args) throws Exception{
        long s = System.currentTimeMillis();
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("D:\\Java\\abc.txt"));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("D:\\Java\\abc拷贝3.txt"));
        int i=0;
        while ((i=bis.read())!=-1){
            bos.write(i);
        }
        bis.close();
        bos.close();
        long s1=System.currentTimeMillis();
        System.out.println(s1-s);//224
    }
}

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
//字节流缓冲区读写字节数组
public class Z4 {
    public static void main(String[] args) throws Exception{
        long s = System.currentTimeMillis();
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("D:\\Java\\abc.txt"));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("D:\\Java\\abc拷贝4.txt"));
        byte[] bytes=new byte[1024];
        int i=0;
        while ((i=bis.read(bytes))!=-1){
            bos.write(bytes);
        }
        bis.close();
        bos.close();
        long s1=System.currentTimeMillis();
        System.out.println(s1-s);//23
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
//用字符缓冲区，复制文本文件 
//这种方式只能复制拷贝文本文件 
public class Z5 {
    public static void main(String[] args) throws Exception{
        long s=System.currentTimeMillis();
        BufferedReader bfr=new BufferedReader(new FileReader("D:\\Java\\abc.txt"));
        BufferedWriter bwr=new BufferedWriter(new FileWriter("D:\\Java\\abc拷贝5.txt"));
        String str=null;
        while ((str=bfr.readLine())!=null){
            bwr.write(str);
            bwr.newLine();
        }
        bwr.close();
        bfr.close();
        long s1 = System.currentTimeMillis();
        System.out.println(s1-s);//214
    }
}

io流往期：Java（io流—字节输入流、字节输出流）

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2020-03-03，如有侵权请联系 cloudcommunity@tencent.com 删除

java