欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java 中的CharArrayReader 介绍_动力节点Java学院整理

程序员文章站 2024-02-19 21:59:16
chararrayreader 介绍 chararrayreader 是字符数组输入流。它和bytearrayinputstream类似,只不过bytearrayin...

chararrayreader 介绍

chararrayreader 是字符数组输入流。它和bytearrayinputstream类似,只不过bytearrayinputstream是字节数组输入流,而chararray是字符数组输入流。chararrayreader 是用于读取字符数组,它继承于reader。操作的数据是以字符为单位!

chararrayreader 函数列表 

chararrayreader(char[] buf)
chararrayreader(char[] buf, int offset, int length)
void   close()
void   mark(int readlimit)
boolean  marksupported()
int    read()
int    read(char[] buffer, int offset, int len)
boolean  ready()
void   reset()
long   skip(long charcount)

reader和chararrayreader源码分析

reader是chararrayreader的父类,我们先看看reader的源码,然后再学chararrayreader的源码。

1. reader源码分析(基于jdk1.7.40) 

 package java.io;
 public abstract class reader implements readable, closeable {
   protected object lock;
   protected reader() {
     this.lock = this;
   }
   protected reader(object lock) {
     if (lock == null) {
       throw new nullpointerexception();
     }
     this.lock = lock;
   }
   public int read(java.nio.charbuffer target) throws ioexception {
     int len = target.remaining();
     char[] cbuf = new char[len];
     int n = read(cbuf, 0, len);
     if (n > 0)
       target.put(cbuf, 0, n);
     return n;
   }
   public int read() throws ioexception {
    char cb[] = new char[1];
     if (read(cb, 0, 1) == -1)
       return -1;
     else
       return cb[0];
   }
   public int read(char cbuf[]) throws ioexception {
     return read(cbuf, 0, cbuf.length);
   }
   abstract public int read(char cbuf[], int off, int len) throws ioexception;
   private static final int maxskipbuffersize = 8192;
   private char skipbuffer[] = null;
   public long skip(long n) throws ioexception {
     if (n < l)
       throw new illegalargumentexception("skip value is negative");
     int nn = (int) math.min(n, maxskipbuffersize);
     synchronized (lock) {
       if ((skipbuffer == null) || (skipbuffer.length < nn))
       while (r > 0) {
        int nc = read(skipbuffer, 0, (int)math.min(r, nn));
        if (nc == -1)
           break;
         r -= nc;
       }
       return n - r;
     }
   }
   public boolean ready() throws ioexception {
     return false;
   }
   public boolean marksupported() {
     return false;
   }
   public void mark(int readaheadlimit) throws ioexception {
     throw new ioexception("mark() not supported");
   }
   public void reset() throws ioexception {
     throw new ioexception("reset() not supported");
   }
   abstract public void close() throws ioexception;
 }

2. chararrayreader 源码分析(基于jdk1.7.40) 

  package java.io;
  public class chararrayreader extends reader {
    // 字符数组缓冲
    protected char buf[];
    // 下一个被获取的字符的位置
    protected int pos;
   // 被标记的位置
   protected int markedpos = 0;
   // 字符缓冲的长度
   protected int count;
   // 构造函数
   public chararrayreader(char buf[]) {
     this.buf = buf;
     this.pos = 0;
     this.count = buf.length;
   }
   // 构造函数
     if ((offset < 0) || (offset > buf.length) || (length < 0) ||
      ((offset + length) < 0)) {
       throw new illegalargumentexception();
     }
     this.buf = buf;
     this.pos = offset;
     this.count = math.min(offset + length, buf.length);
     this.markedpos = offset;
   }
   // 判断“chararrayreader是否有效”。
   // 若字符缓冲为null,则认为其无效。
   private void ensureopen() throws ioexception {
     if (buf == null)
       throw new ioexception("stream closed");
   }
   // 读取下一个字符。即返回字符缓冲区中下一位置的值。
   // 注意:读取的是字符!
   public int read() throws ioexception {
     synchronized (lock) {
       ensureopen();
       if (pos >= count)
         return -1;
       else
         return buf[pos++];
     }
   }
   // 读取数据,并保存到字符数组b中从off开始的位置中,len是读取长度。
   public int read(char b[], int off, int len) throws ioexception {
     synchronized (lock) {
       ensureopen();
       if ((off < 0) || (off > b.length) || (len < 0) ||
         ((off + len) > b.length) || ((off + len) < 0)) {
         throw new indexoutofboundsexception();
       } else if (len == 0) {
         return 0;
       }
       if (pos >= count) {
         return -;
       }
       if (pos + len > count) {
         len = count - pos;
       }
      if (len <= 0) {
        return 0;
       }
       system.arraycopy(buf, pos, b, off, len);
       pos += len;
       return len;
     }
   }
   // 跳过n个字符
   public long skip(long n) throws ioexception {
     synchronized (lock) {
       ensureopen();
       if (pos + n > count) {
         n = count - pos;
       }
       if (n < 0) {
         return 0;
       }
       pos += n;
       return n;
     }
   }
   // 判断“是否能读取下一个字符”。能的话,返回true。
   public boolean ready() throws ioexception {
     synchronized (lock) {
       ensureopen();
       return (count - pos) > ;
     }
   }
   public boolean marksupported() {
     return true;
   }
   // 保存当前位置。readaheadlimit在此处没有任何实际意义
   // mark()必须和reset()配合使用才有意义!
   public void mark(int readaheadlimit) throws ioexception {
     synchronized (lock) {
       ensureopen();
       markedpos = pos;
     }
   }
   // 重置“下一个读取位置”为“mark所标记的位置”
   public void reset() throws ioexception {
     synchronized (lock) {
       ensureopen();
       pos = markedpos;
     }
   }
   public void close() {
     buf = null;
   }
 }

说明:

chararrayreader实际上是通过“字符数组”去保存数据。

(01) 通过 chararrayreader(char[] buf) 或 chararrayreader(char[] buf, int offset, int length) ,我们可以根据buf数组来创建chararrayreader对象。

(02) read()的作用是从chararrayreader中“读取下一个字符”。

(03) read(char[] buffer, int offset, int len)的作用是从chararrayreader读取字符数据,并写入到字符数组buffer中。offset是将字符写入到buffer的起始位置,len是写入的字符的长度。

(04) marksupported()是判断chararrayreader是否支持“标记功能”。它始终返回true。

(05) mark(int readlimit)的作用是记录标记位置。记录标记位置之后,某一时刻调用reset()则将“chararrayreader下一个被读取的位置”重置到“mark(int readlimit)所标记的位置”;也就是说,reset()之后再读取chararrayreader时,是从mark(int readlimit)所标记的位置开始读取。 

示例代码

关于chararrayreader中api的详细用法,参考示例代码(chararrayreadertest.java):  

 /**
  * chararrayreader 演示程序
  *
  * 
  */
 import java.io.chararrayreader;
 import java.io.chararraywriter;
 import java.io.ioexception;
 public class chararrayreadertest {
   private static final int len = 5;
   // 对应英文字母“abcdefghijklmnopqrstuvwxyz”
   private static final char[] arrayletters = new char[] {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
   public static void main(string[] args) {
     teschararrayreader() ;
   }
   /**
   * chararrayreader的api测试函数
   */
   private static void teschararrayreader() {
     try {
       // 创建chararrayreader字符流,内容是arrayletters数组
       chararrayreader car = new chararrayreader(arrayletters);
      // 从字符数组流中读取5个字符
       for (int i=; i<len; i++) {
         // 若能继续读取下一个字符,则读取下一个字符
         if (car.ready() == true) {
           // 读取“字符流的下一个字符”
           char tmp = (char)car.read();
           system.out.printf("%d : %c\n", i, tmp);
         }
       }
       // 若“该字符流”不支持标记功能,则直接退出
       if (!car.marksupported()) {
         system.out.println("make not supported!");
         return ;
       }
      // 标记“字符流中下一个被读取的位置”。即--标记“f”,因为因为前面已经读取了5个字符,所以下一个被读取的位置是第6个字符”
      // (01), chararrayreader类的mark(0)函数中的“参数0”是没有实际意义的。
      // (02), mark()与reset()是配套的,reset()会将“字符流中下一个被读取的位置”重置为“mark()中所保存的位置”
      car.mark(0);
      // 跳过5个字符。跳过5个字符后,字符流中下一个被读取的值应该是“k”。
       car.skip(5);
       // 从字符流中读取个数据。即读取“klmno”
       char[] buf = new char[len];
      car.read(buf, 0, len);
       system.out.printf("buf=%s\n", string.valueof(buf));
       // 重置“字符流”:即,将“字符流中下一个被读取的位置”重置到“mark()所标记的位置”,即f。
       car.reset();
       // 从“重置后的字符流”中读取5个字符到buf中。即读取“fghij”
      car.read(buf, 0, len);
       system.out.printf("buf=%s\n", string.valueof(buf));
     } catch (ioexception e) {
       e.printstacktrace();
     }
   }
 }

运行结果:

0 : a
1 : b
2 : c
3 : d
4 : e
buf=klmno
buf=fghij

以上所述是小编给大家介绍的java 中的chararrayreader知识,希望对大家有所帮助