Java进阶核⼼之Reader、Writer字符流

最新推荐文章于 2024-07-31 19:38:21 发布

不吃青椒！

最新推荐文章于 2024-07-31 19:38:21 发布

阅读量1k

点赞数 2

分类专栏： javase 文章标签： java

本文链接：https://blog.csdn.net/weixin_65728526/article/details/124040418

版权

javase 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一，java字符输入流Reader讲解

：讲解Reader相关介绍及其⼦子类
Reader是输⼊入字符流的⽗父类，它是⼀一个抽象类, 部分库不不推荐使⽤用Reader/Writer，所以简单了了解
即可

package chapter12;

import java.io.*;

public class ReaderTest {
    public static void main(String [] args) throws Exception {
        test2();

    }
    public static void test1()throws Exception{
        String dir="C:\\Users\\联想\\Desktop\\test\\1.txt";
        File file=new File(dir);
        Reader input = new FileReader(file);
        int ch;
        while((ch=input.read())!=-1){
            System.out.print((char)ch);
        }
        input.close();


    }
    public static void test2()throws Exception{
        String dir="C:\\Users\\联想\\Desktop\\test\\1.txt";
        File file=new File(dir);
        Reader input = new FileReader(file);
        int ch;
        char [] buf= new char[1024];
        while((ch=input.read(buf))!=-1){
            System.out.print(new String(buf,0,ch));
        }
        input.close();


    }
}

二，java字符输出流Writer讲解

：讲解Writer相关介绍及其⼦子类
Writer是输出字符流的⽗父类，它是⼀一个抽象类

public void write(int c) throws IOException
讲解：直接将int型数据作为参数的话，是不不会写⼊入数字的，⽽而是现将数字按照ascll码表转换为
相应的字符，然后写⼊入
public void write(String str) throws IOException
讲解：要想实现数字和中⽂文的写⼊入，必须要⽤用String为参数的Write
public abstract void write(char cbuf[], int off, int len) throws
IOException;
讲解：将cbuf字符数组的⼀一部分写⼊入到流中，但能不不能写len个字符取决于cbuf中是否有那么多
void flush() throws IOException
讲解：write是写到缓冲区中，可以认为是内存中,当缓冲区满时系统会⾃自动将缓冲区的内容写⼊入
⽂文件，但是⼀一般还有⼀一部分有可能会留留在内存这个缓冲区中, 所以需要调⽤用flush空缓冲区数据。
对⽐比BufferWriter需要实时查表，效率低，其实缓冲区IO的各个都有，只不不过很⼩小被忽
略略,OutputStream都有flush⽅方法，看⼦子类是否有重写
void close() throws IOException
解：关闭输⼊入流并释放与该流关联的系统资源

public FileWriter(String fileName) throws IOException
讲解：如果⽂文件不不存在，这会⾃自动创建。如果⽂文件存在，则会覆盖
public FileWriter(File file) throws IOException
讲解：如果⽂文件不不存在，这会⾃自动创建。如果⽂文件存在，则会覆盖
public FileWriter(String fileName, boolean append) throws
IOException
讲解：加⼊入true参数，会实现对⽂文件的续写，使⽤用false则会实现对⽂文件的覆盖
public FileWriter(File file, boolean append) throws IOException
讲解：加⼊入true参数，会实现对⽂文件的续写，使⽤用false则会实现对⽂文件的覆盖

实战

package chapter12;

import javax.imageio.IIOException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class WriterTest {
    public static void main(String [] args)throws Exception {
        test2();
    }

    public static void test2()throws Exception {
        String dir="C:\\Users\\联想\\Desktop\\test\\2.txt";
        Writer writer = new FileWriter(dir,true);
        writer.write(23567);
        writer.write(28404);
        writer.write(35838);
        writer.write(22530);
        writer.write("23567");
        writer.flush();
        writer.close();

    }
    public static void test1()throws Exception {
        String dir="C:\\Users\\联想\\Desktop\\test\\2.txt";
        Writer writer = new FileWriter(dir);
        writer.write(23567);
        writer.write(28404);
        writer.write(35838);
        writer.write(22530);
        writer.write("23567");
        writer.flush();
        writer.close();

    }
}

三，Buffered Reader字符输⼊入缓冲流实战

boolean ready()
讲解：判断此流是否已准备好被读取，依赖其他流，所以⼀一般需要做判断
int read()
讲解：读取单个字符
实战
第4集 BufferedWriter字符输出缓冲流实战
简介：讲解Java字符输出缓冲流讲解
BufferedWriter
简介：写⼊入的数据并不不会先输出到⽬目的地，⽽而是先存储⾄至缓冲区中。如果缓冲区中的数据满
了了，才会⼀一次对⽬目的地进⾏行行写出
构造函数
int read(char[] cbuf, int off, int len)
讲解：读取⼀一部分字符到数组⾥里里⾯面，从数组下标off处放置length⻓长度的字符
String readLine()
讲解:读取⼀一整⾏行行⽂文本⾏行行，返回⼀一整⾏行行字符串串，如果读到⾏行行尾了了就返回null,注意返回的⼀一⾏行行字符中不不
包含换⾏行行符
void close()
讲解：关闭流释放资源

package chapter12;

import java.io.BufferedReader;
import java.io.FileReader;

public class BufferReaderTest  {
    public static void main(String [] args)throws Exception{
        test1("C:\\Users\\联想\\Desktop\\test\\1.txt");
    }
    public static void test2(String path)throws Exception{
        BufferedReader reader= new BufferedReader(new FileReader(path));
        if(!reader.ready()){
            System.out.println("文件流暂时无法读取");
            return;
        }
        String str="";
        while((str=reader.readLine())!=null){
            System.out.println(str);
        }
    }
    public static void test1(String path)throws Exception{
        BufferedReader reader= new BufferedReader(new FileReader(path));
        if(!reader.ready()){
            System.out.println("文件流暂时无法读取");
            return;
        }
        int size;
        char [] cbuf=new char[1024];
        while((size=reader.read(cbuf,0,cbuf.length))!=-1){
            System.out.println(new String(cbuf,0,size));
        }
    }
}

四，BufferedWriter字符输出缓冲流实战

BufferedWriter(Writer out)
BufferedWriter(Writer out, int sz)

void write(int c)
讲解：写⼊入⼀一个字符
void write(char[] cbuf, int off, int len)
讲解：写⼊入字符数组的⼀一部分，通过off和len控制。
void write(String s, int off, int len)
讲解：写⼊入字符数组的⼀一部分，通过off和len控制。
void newLine()
讲解：写如⼀一个换⾏行行符合
void close()
讲解：关闭输⼊入流并释放与该流关联的系统资源
void flush()
讲解：write是写到缓冲区中，可以认为是内存中,当缓冲区满时系统会⾃自动将缓冲区的内容
写⼊入⽂文件，但是⼀一般还有⼀一部分有可能会留留在内存这个缓冲区中, 所以需要调⽤用flush空缓
冲区数据。

实战

package chapter12;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

public class BufferWriterTest {
    public static void main(String [] args)throws Exception{
        test1("C:\\Users\\联想\\Desktop\\test\\8.txt");
    }
    public static void test1(String path)throws Exception{
        BufferedWriter writer=new BufferedWriter(new FileWriter(path));
        char ch='小';
        writer.write(ch);
        String other= "小弟课堂";
        //写入一个字符数组
        writer.write(other.toCharArray(),0,other.length());
        writer.newLine();
        String newLine="学习java课程";
        writer.write(newLine);
        writer.close();


    }
}

五，字符流和字节流的桥梁梁InputStreamReader

int read()
讲解：读取单个字符
int read(char[] cbuf, int off, int len)
讲解：读取⼀一部分字符到数组⾥里里⾯面，从数组下标off处放置length⻓长度的字符
int read(char []cbuf)
讲解：将读取到的字符存到数组中，返回读取的字符数
void close()
讲解：关闭流释放资源

package chapter12;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;

public class InputStreamReaderTest {
    public static void main(String [] args)throws Exception{
        test1("C:\\Users\\联想\\Desktop\\test\\8.txt");
    }
    public static void test1(String path)throws Exception{
        //读取字节流
        InputStream in = new FileInputStream(path);
//        InputStreamReader isr = new InputStreamReader(in,"GBK");
        InputStreamReader isr = new InputStreamReader(in);

        BufferedReader reader = new BufferedReader(isr);
//        String line;
//        while((line=reader.readLine())!=null){
//            System.out.println(line);
//        }
//        isr.close();
//        reader.close();
        int size;
        char [] ch=new char[1024];
        while((size=reader.read(ch,0,ch.length))!=-1){
            System.out.println(new String(ch,0,size));
        }
        isr.close();
        reader.close();
    }
}

六，字符流和字节流的桥梁梁OutputStreamWriter

void write(int c)
讲解：写⼊入⼀一个字符
void write(char[] cbuf, int off, int len)
讲解：写⼊入字符数组的⼀一部分，通过off和len控制。
实战（指定编码写⼊入，如果⽤用其他编码打开则乱码，读取也是会乱码）
第7集 JavaIO流内部异常处理理
简介: 讲解 Java IO流内部异常处理理
完成⼀一个⽂文件的拷⻉贝
写法⼀一(以前内容)
void write(String s, int off, int len)
讲解：写⼊入字符数组的⼀一部分，通过off和len控制。
void newLine()
讲解：写如⼀一个换⾏行行符合
void close()
讲解：关闭输⼊入流并释放与该流关联的系统资源
void flush()
讲解：write是写到缓冲区中，可以认为是内存中,当缓冲区满时系统会⾃自动将缓冲区的内容
写⼊入⽂文件，但是⼀一般还有⼀一部分有可能会留留在内存这个缓冲区中, 所以需要调⽤用flush空缓
冲区数据。

package chapter12;

import java.io.*;

public class OutputStreamWriterTest {
    public static void main(String [] args)throws Exception{
        test1("C:\\Users\\联想\\Desktop\\test\\8.txt");
        test2("C:\\Users\\联想\\Desktop\\test\\8.txt");
    }
    public static void test1(String path)throws Exception{
        OutputStream out=new FileOutputStream(path);
        OutputStreamWriter osr= new OutputStreamWriter(out,"GBK");
        BufferedWriter bufw=new BufferedWriter(osr);
        String srt="环保一百个啊说的话覅偶怕蓄电dsaf" ;
        bufw.write(srt);
        bufw.newLine();
        bufw.write("学习java课程");
        bufw.flush();
        bufw.close();

    }
    public static void test2(String path)throws Exception{
        InputStream inputStream= new FileInputStream(path);
        InputStreamReader isr=new InputStreamReader(inputStream,"GBK");
        BufferedReader bufr=new BufferedReader(isr);
        String line;
        while((line=bufr.readLine())!=null){
            System.out.println(line);
        }
        isr.close();
        bufr.close();
    }
}

七，JavaIO流内部异常处理理

写法⼀一(以前内容)

try {
FileInputStream fis = new FileInputStream("xdclass.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("copy.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
int size;
byte[] buf = new byte[1024];
写法⼆二(JDK6之前，⼤大部分⼈人还停留留这个写法)
while ((size = bis.read(buf)) != -1) {
bos.write(buf, 0, size);
}
//刷新此缓冲的输出流，才可以保证数据全部输出完成,close会⾃自动关闭
//bos.flush();
//关闭的时候只需要关闭最外层的流就⾏行行了了，源码⾥里里⾯面会⾃自动关闭inputstream对象的
bis.close();
bos.close();
} catch (Exception e) {
e.printStackTrace();
}

写法⼆二(JDK6之前，⼤大部分⼈人还停留留这个写法)

package chapter12;

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

public class TryCatchTest {
    public static void main(String [] args){
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        try{
            FileInputStream fis=new FileInputStream("C:\\Users\\联想\\Desktop\\test\\1.txt");
            bis=new BufferedInputStream(fis);
            FileOutputStream fos=new FileOutputStream("C:\\Users\\联想\\Desktop\\test\\111.txt");
            bos=new BufferedOutputStream(fos);
            int size;
            byte [] buf=new byte[1024];
            while((size=bis.read(buf))!=0){
                bos.write(buf,0,size);
            }

        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if( bis!=null){
                try{
                    bis.close();
                }catch(Exception e){
                    e.printStackTrace();
                }finally{
                    if(bos!=null){
                        try{
                            bos.close();
                        }catch(Exception e){
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

八，新版JDK try-with-resource处理理IO异常

public static void test4() {
try (FileInputStream fis = new FileInputStream("xdclass.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("copy.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
) {
int size;
byte[] buf = new byte[1024];
while ((size = bis.read(buf)) != -1) {
bos.write(buf, 0, size);
}
} catch (Exception e) {
e.printStackTrace();
}
}

不吃青椒！

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
Java进阶核⼼之Reader、Writer字符流

java Reader,Writer 讲解Buffer Reader 字符缓冲流讲解inputStreamReader讲解outputStreamWriter讲解java IO流内部异常处理新版JDK try-with-resourse处理IO异常
复制链接

扫一扫

专栏目录