Java?IO流之StringWriter和StringReader用法分析

 更新时间:2021年12月10日 10:00:33   作者:DreamTech1113  
这篇文章主要介绍了Java?IO流之StringWriter和StringReader用法分析,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
(福利推荐:【腾讯云】服务器最新限时优惠活动,云服务器1核2G仅99元/年、2核4G仅768元/3年,立即抢购>>>:9i0i.cn/qcloud

(福利推荐:你还在原价购买阿里云服务器?现在阿里云0.8折限时抢购活动来啦!4核8G企业云服务器仅2998元/3年,立即抢购>>>:9i0i.cn/aliyun

简介

StringWriter和StringReader分别继承自Writer和Reader抽象类,作用就是将字符串String类型适配到StringWriter和StringReader类.

其中StringWriter实际上是用StringBuffer实现的,StringBuffer是一个线程安全的类,实际上默认的是16个字符的char数组.所以通过方法write()和append()等其他重载的方法.将字符串添加到StringBuffer中,可以调用toString()或者getBuffer()方法显示StringWriter流中所有的数据.其中close()方法和flush()方法,无实际的功能,只是简单的继承.

StringReader的有参构造方法传入的是String类型的数据,通过read()重载方法读取流中部分或者全部的字符内容.

StringWriter介绍

1.构造方法

public StringWriter() {}
public StringWriter(int initialSize) {}

无参构造方法,创建的是默认大小为StringBuffer的StringWriter流,其中StringBuffer底层实际是一个字符数组,默认大小是16个字符.

有参构造方法,创建的是指定大小的StringBuffer的StringWriter流,也就是指定initialSize个字符的字符数组.

2.内部变量

private StringBuffer buf;

StringWriter流中缓冲区实际上通过StringBuffer来实现的.

3. 内部方法

public void write(int c) {}
public void write(char cbuf[], int off, int len){}
public void write(String str) {}
public void write(String str, int off, int len){}
public StringWriter append(CharSequence csq){}
public StringWriter append(CharSequence csq, int start, int end){}
public StringWriter append(char c){}
public String toString() {}
public StringBuffer getBuffer() {}
public void flush() {}
public void close() {}
  • write(int c)---将单个字符写到流中.
  • write(char cbuf[] ,int off,int len)---将字符数组cbuf中off开始,len个字符写到流中.
  • write(String str)---将字符串str写到流中.
  • write(String str,int off,int len)---将字符串str中off位置开始,len个字符写到流中.
  • append(charsequence csq)---将字符序列csq写到流中.
  • append(charsequence csq,int start ,int end)----将字符序列中start到end之间字符写到流中.
  • append(char c)---将单个字符写到流中.
  • toString()---将流中所有字符转换成字符串返回.
  • getBuffer()----将流中内容,实际是StringBuffer返回.
  • flush()---仅仅是继承,方法内没有任何实现.
  • close()----仅仅是继承,方法内没有任何实现.

StringReader介绍

1.构造方法

public StringReader(String s) {}

有参构造方法,传入的实际上是流中内容为字符串s.

2.内部变量

  private String str;
  private int length;
  private int next = 0;
  private int mark = 0;
  • str---StringReader流中实际的数据就是通过构造方法传入的字符串str.
  • length---流中字符串的长度.
  • next---要读取的下一个字符的位置.
  • mark---标记字符位置,调用mark()方法会将当前位置保存到mark中.

3. 内部方法

private void ensureOpen(){}
public int read(){}
public int read(char cbuf[], int off, int len){}
public long skip(long ns){}
public boolean ready(){}
public boolean markSupported() {}
public void mark(int readAheadLimit){}
public void reset(){}
public void close(){}
  • ensureOpen()---确保流没有关闭,实际判断是流中内容字符串str不为null.
  • read()---从流中读取一个字符.
  • read(char cbuf[],int off,int len)---将流中最多len个字符读取到字符数组cbuf中,cbuf中从off开始.
  • skip(long ns)---跳过ns个字符.
  • ready()---流是否准备读取.
  • markSupported()---是否支持标记
  • mark(int readAheadLimit)---标记当前位置,readAheadLimit表示的是在标记有效情况下,从当前位置开始可取的最大字符数.
  • reset()---将流中当前位置重置到标记位置.
  • close()---关闭流,实际上是将流中内容字符串str置为null.

案例

public class StringWriterDemo {
  public static void main(String[] args) throws IOException {
    testStringWriter();
    testStringReader();
    testOfAnotherStringWriter();
  }
  //测试StringWriter
  private static void testStringWriter() throws IOException {
    StringWriter sw = new StringWriter();
    sw.append("this is a");
    sw.write("demo of StringWriter");
    System.out.println(sw.toString());
    sw.close();
  }
   
  //测试StringReader
  private static void testStringReader() throws IOException {
   String content = "this is a demo of StringReader";
   StringReader sr = new StringReader(content);
   int c;
   while((c=sr.read())!=-1) {
     System.out.println((char)c);
   }
    sr.close();
  }
  
  //将读取的数据先写到StringWriter流中,然后直接调用toString()方法打印结果
  private static void testOfAnotherStringWriter() throws IOException {
    FileReader fr = new FileReader("D:\\java.txt");
    BufferedReader br = new BufferedReader(fr);
    StringWriter sw = new StringWriter();
    int n;
    char cbuf[] = new char[1024];
    while((n=br.read(cbuf))!=-1) {
      sw.write(cbuf, 0, n);
    }
    System.out.println(sw.toString());
    fr.close();
    br.close();
  }
}

源码分析

1.StringWriter源码分析

public class StringWriter extends Writer {
    //StringWriter中缓冲功能是通过StringBuffer来实现的.
    private StringBuffer buf;
 
    //创建默认缓冲为16个字符的StringWriter.默认的StringBuffer实际是大小为16个字符的字符数组.
    public StringWriter() {
        buf = new StringBuffer();
        lock = buf;
    }
 
    //创建指定大小StringBuffer的StringWriter,也就是指定了initialSize个字符的字符数组.
    public StringWriter(int initialSize) {
        if (initialSize < 0) {
            throw new IllegalArgumentException("Negative buffer size");
        }
        buf = new StringBuffer(initialSize);
        lock = buf;
    }
 
    //向流写入单个字符c
    public void write(int c) {
        buf.append((char) c);
    }
 
    //将字符数组cbuf中off位置开始,len个字符写到流中
    public void write(char cbuf[], int off, int len) {
        if ((off < 0) || (off > cbuf.length) || (len < 0) ||
            ((off + len) > cbuf.length) || ((off + len) < 0)) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return;
        }
        buf.append(cbuf, off, len);
    }
 
    //将字符串str写到流中
    public void write(String str) {
        buf.append(str);
    }
 
    //将字符串str中off位置开始,len个字符写到流中
    public void write(String str, int off, int len)  {
        buf.append(str.substring(off, off + len));
    }
 
    //将字符序列csq添加到流中.
    public StringWriter append(CharSequence csq) {
        if (csq == null)
            write("null");
        else
            write(csq.toString());
        return this;
    }
 
    //将字符序列csq中start位置到end之间的字符添加到流中
    public StringWriter append(CharSequence csq, int start, int end) {
        CharSequence cs = (csq == null ? "null" : csq);
        write(cs.subSequence(start, end).toString());
        return this;
    }
 
    //向流中添加一个字符c
    public StringWriter append(char c) {
        write(c);
        return this;
    }
 
    //将流中字符转换成字符串返回.
    public String toString() {
        return buf.toString();
    }
 
    //返回流的内容,即StringBuffer
    public StringBuffer getBuffer() {
        return buf;
    }
 
    //刷新流,没有具体实现.
    public void flush() {
    }
 
    //关闭流后读取数据不会抛出异常,因为没有具体实现
    public void close() throws IOException {
    }
 
}

2,StringReader源码分析

public class StringReader extends Reader {
    //流中实际数据就是通过构造方法传入str字符串.
    private String str;
    //字符串str的长度
    private int length;
    //下一个要读取字符的位置.
    private int next = 0;
    //标记的位置.
    private int mark = 0;
 
    //创建一个StringReader流,参数传入的是字符串s
    public StringReader(String s) {
        this.str = s;
        this.length = s.length();
    }
 
   //确保流没有关闭,实际判断的是StringReader构造方法是否有传入字符串.
    private void ensureOpen() throws IOException {
        if (str == null)
            throw new IOException("Stream closed");
    }
 
    //读取单个字符
    public int read() throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (next >= length)
                return -1;
            return str.charAt(next++);
        }
    }
 
    //将缓冲区中最多len个字符写到字符数组cbuf中,位置从off开始,长度为len个
    public int read(char cbuf[], int off, int len) throws IOException {
        synchronized (lock) {
            ensureOpen();
            //检测参数的合法性
            if ((off < 0) || (off > cbuf.length) || (len < 0) ||
                ((off + len) > cbuf.length) || ((off + len) < 0)) {
                throw new IndexOutOfBoundsException();
            } else if (len == 0) {
                return 0;
            }
            //超过字符串的长度,返回-1
            if (next >= length)
                return -1;
            //剩余可读取的字符为length-next,
            //如果len超过剩余可读取字符,实际只能读取剩余可读取字符
            //如果len小于剩余可读取字符,实际上读取的是len个字符
            int n = Math.min(length - next, len);
            str.getChars(next, next + n, cbuf, off);
            next += n;
            return n;
        }
    }
 
    //跳过ns个字符,返回跳过的字符数
    public long skip(long ns) throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (next >= length)
                return 0;
            // Bound skip by beginning and end of the source
            //缓冲区中剩余字符数与要跳过的字符数比较.取较小值
            long n = Math.min(length - next, ns);
            n = Math.max(-next, n);
            next += n;
            return n;
        }
    }
 
    //流是否准备读取.
    public boolean ready() throws IOException {
        synchronized (lock) {
        ensureOpen();
        return true;
        }
    }
 
    //流是否支持标记
    public boolean markSupported() {
        return true;
    }
 
   //标记缓冲区中当前位置,readAheadLimit表示的是在保留标记的情况下,最大可读取的字符数
    public void mark(int readAheadLimit) throws IOException {
        if (readAheadLimit < 0){
            throw new IllegalArgumentException("Read-ahead limit < 0");
        }
        synchronized (lock) {
            ensureOpen();
            mark = next;
        }
    }
 
    //将缓冲区当前位置重置到标记位置
    public void reset() throws IOException {
        synchronized (lock) {
            ensureOpen();
            next = mark;
        }
    }
 
    //关闭流,释放相关资源(实际只是将流中内容字符串置为空)
    public void close() {
        str = null;
    }
}
 

以上为个人经验,希望能给大家一个参考,也希望大家多多支持程序员之家。

相关文章

  • 玩转spring boot 结合AngularJs和JDBC(4)

    玩转spring boot 结合AngularJs和JDBC(4)

    玩转spring boot,这篇文章主要介绍了结合AngularJs和JDBC,玩转spring boot,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2017-01-01
  • SpringBoot整合neo4j使用详解

    SpringBoot整合neo4j使用详解

    这篇文章将和大家详细聊聊如何在springboot应用中集成和使用neo4j,文中有详细的实现流程和实例代码,具有一定的借鉴价值,感兴趣的小伙伴可以跟随小编一起学习一下
    2023-10-10
  • Java通过Lambda表达式实现简化代码

    Java通过Lambda表达式实现简化代码

    我们在编写代码时,常常会遇到代码又长又重复的情况,就像调用第3方服务时,每个方法都差不多,?写起来啰嗦,?改起来麻烦,?还容易改漏,所以本文就来用Lambda表达式简化一下代码,希望对大家有所帮助
    2023-05-05
  • 使用springboot单元测试对weblistener的加载测试

    使用springboot单元测试对weblistener的加载测试

    这篇文章主要介绍了使用springboot单元测试对weblistener的加载测试,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-10-10
  • Java Servlet请求重定向的方法

    Java Servlet请求重定向的方法

    这篇文章主要介绍了使用Java Servlet请求重定向的方法,帮助大家更好的理解和学习Java Servlet的相关知识,感兴趣的朋友可以了解下
    2020-11-11
  • 基于springMvc+hibernate的web application的构建

    基于springMvc+hibernate的web application的构建

    下面小编就为大家带来一篇基于springMvc+hibernate的web application的构建。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2017-10-10
  • Java实现截取字符串的操作详解

    Java实现截取字符串的操作详解

    在这篇文章中,小编将带大家一起学习一下在Java中把一个String截断到所需的字符数的几种方法,文中的方法简洁易懂,需要的可以参考一下
    2022-07-07
  • SpringCloud feign微服务调用之间的异常处理方式

    SpringCloud feign微服务调用之间的异常处理方式

    这篇文章主要介绍了SpringCloud feign微服务调用之间的异常处理方式,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-06-06
  • spring boot自定义配置时在yml文件输入有提示问题及解决方案

    spring boot自定义配置时在yml文件输入有提示问题及解决方案

    自定义一个配置类,然后在yml文件具体配置值时,一般不会有提示,今天小编给大家分享spring boot自定义配置时在yml文件输入有提示问题,感兴趣的朋友一起看看吧
    2023-10-10
  • SpringBoot接收请求参数的四种方式总结

    SpringBoot接收请求参数的四种方式总结

    这篇文章主要给大家介绍了关于SpringBoot接收请求参数的四种方式,文中通过代码以及图文介绍的非常详细,对大家学习或者使用SpringBoot具有一定的参考借鉴价值,需要的朋友可以参考下
    2023-09-09

最新评论

?


http://www.vxiaotou.com