Java IO - Arrays
目录
ByteArrayInputStream , ByteArrayOutputStream, CharArrayReader 和 CharArrayWriter。
ByteArrayInputStream
package java.io;
/**
* ByteArrayInputStream 内部包含了一个 buffer,这个 buffer 持有了从 stream 中
* 读取的字节。内部还有一个 conter,用来跟踪 read() 方法读取的下一个字节的位置
* close 一个 ByteArrayInputStream 没有任何作用. 即使调用了 close(),ByteArrayInputStream 的方法还是可以调用
*/
public class ByteArrayInputStream extends InputStream {
/**
* 字节数组,持有 stream 中的字节数据
*/
protected byte buf[];
/**
* 下一个 read() 字节所在的位置,不大于 count。
*/
protected int pos;
/**
* mark(打标记) 的位置
*/
protected int mark = 0;
/**
* input stream 中最后一个有效字节的位置的后一位
* 不能大于 buf 的长度
*/
protected int count;
/**
* 创建一个 ByteArrayInputStream,使用 buf 作为缓冲数组
*/
public ByteArrayInputStream(byte buf[]) {
this.buf = buf;
this.pos = 0;
this.count = buf.length;
}
public ByteArrayInputStream(byte buf[], int offset, int length) {
this.buf = buf;
this.pos = offset;
this.count = Math.min(offset + length, buf.length);
this.mark = offset;
}
/**
* 读取下一个字节,只取 低 8 位;
*/
public synchronized int read() {
return (pos < count) ? (buf[pos++] & 0xff) : -1;
}
/**
* 从输入流中读取最多 len 长度的字节到指定的字节数组
*/
public synchronized int read(byte b[], int off, int len) {
if (b == null) { // b 是空,或者 b 的长度不合法,抛出异常
throw new NullPointerException();
} else if (off < 0 || len < 0 || len > b.length - off) {
throw new IndexOutOfBoundsException();
}
if (pos >= count) { // 说明这个流已经到底了
return -1;
}
int avail = count - pos; // 剩余的字节
if (len > avail) {
len = avail;
}
if (len <= 0) {
return 0;
}
System.arraycopy(buf, pos, b, off, len);
pos += len; // pos 再往前移动 len
return len;
}
/**
* 方便啊,直接修改 pos 即可
*/
public synchronized long skip(long n) {
long k = count - pos;
if (n < k) {
k = n < 0 ? 0 : n;
}
pos += k;
return k;
}
public synchronized int available() {
return count - pos;
}
// 支持 标记
public boolean markSupported() {
return true;
}
/**
* ByteArrayInputStream 中 mark 方法的 readAheadLimit 参数没有任何意义
*/
public void mark(int readAheadLimit) {
mark = pos;
}
/**
* 与 mark() 配合使用
*/
public synchronized void reset() {
pos = mark;
}
/**
* 可见,即使关闭了 ByteArrayInputStream,还是可以调用它的方法.
*/
public void close() throws IOException {
}
}
ByteArrayOutputStream
package java.io;
import java.util.Arrays;
/**
* 这个输出流将数据写到一个 字节数组中,用来存储数据的缓存也会随着数据的增大而增大
* 数据可以通过 toByteArray() 和 toString() 获得。
* 关闭一个 ByteArrayOutputStream 也没什么意义,关了之后方法还是可以运行。
*/
public class ByteArrayOutputStream extends OutputStream {
/**
* 存储数据的缓存
*/
protected byte buf[];
/**
* 缓存中有效的字节数
*/
protected int count;
/**
* 创建一个 新的 byte array output stream,默认缓存大小是 32 字节
*/
public ByteArrayOutputStream() {
this(32);
}
public ByteArrayOutputStream(int size) {
if (size < 0) {
throw new IllegalArgumentException("Negative initial size: "
+ size);
}
buf = new byte[size];
}
/**
* buf 不够的时候会自动增大
*/
private void ensureCapacity(int minCapacity) {
// overflow-conscious code
if (minCapacity - buf.length > 0)
grow(minCapacity);
}
/**
* buf 的最大大小
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 把旧的容量增大 2 倍
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = buf.length;
int newCapacity = oldCapacity << 1;
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
buf = Arrays.copyOf(buf, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
/**
* 写入一个特定的字节
*/
public synchronized void write(int b) {
ensureCapacity(count + 1);
buf[count] = (byte) b;
count += 1;
}
/**
* 从 字节数组 b 的 off 处 写入 len 长度的字节数据
*/
public synchronized void write(byte b[], int off, int len) {
if ((off < 0) || (off > b.length) || (len < 0) ||
((off + len) - b.length > 0)) {
throw new IndexOutOfBoundsException();
}
ensureCapacity(count + len);
System.arraycopy(b, off, buf, count, len);
count += len;
}
/**
* 把输出流中的缓存数据全部写到一个特定的 输出流中
*/
public synchronized void writeTo(OutputStream out) throws IOException {
out.write(buf, 0, count);
}
/**
* 直接 reset 到开头了,这样输出流可以重复使用
*/
public synchronized void reset() {
count = 0;
}
/**
* 得到输出流中的数据
*/
public synchronized byte toByteArray()[] {
return Arrays.copyOf(buf, count);
}
public synchronized int size() {
return count;
}
/**
* 把缓存数据变成一个字符串,使用默认编码方式
*/
public synchronized String toString() {
return new String(buf, 0, count);
}
/**
* 把缓存数据变成一个字符串,使用 charsetName 编码方式
*/
public synchronized String toString(String charsetName)
throws UnsupportedEncodingException
{
return new String(buf, 0, count, charsetName);
}
@Deprecated
public synchronized String toString(int hibyte) {
return new String(buf, hibyte, 0, count);
}
public void close() throws IOException {
}
}
CharArrayReader
package java.io;
/**
* 这个类实现了一个 字符缓存,这个缓存可以作为 字符输入流 来用
*/
public class CharArrayReader extends Reader {
/** The character buffer. */
protected char buf[];
/** 当前缓存位置. */
protected int pos;
/** 标记的位置. */
protected int markedPos = 0;
/**
* buffer 最后一个有效字符的索引
*/
protected int count;
public CharArrayReader(char buf[]) {
this.buf = buf;
this.pos = 0;
this.count = buf.length;
}
public CharArrayReader(char buf[], int offset, int 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;
}
/** 确保 close() 之后啥也不能干! */
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++];
}
}
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 -1;
}
if (pos + len > count) {
len = count - pos;
}
if (len <= 0) {
return 0;
}
System.arraycopy(buf, pos, b, off, len);
pos += len;
return len;
}
}
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;
}
}
public boolean ready() throws IOException {
synchronized (lock) {
ensureOpen();
return (count - pos) > 0;
}
}
public boolean markSupported() {
return true;
}
/**
* readAheadLimit 没用
*/
public void mark(int readAheadLimit) throws IOException {
synchronized (lock) {
ensureOpen();
markedPos = pos;
}
}
public void reset() throws IOException {
synchronized (lock) {
ensureOpen();
pos = markedPos;
}
}
/**
* 关闭就是 设为 null, 等着 gc 回收
*/
public void close() {
buf = null;
}
}
CharArrayWriter
package java.io;
import java.util.Arrays;
/**
* 把 字符缓存 当 Writer 来使用,并且缓存可以在需要的时候自增长
*/
public
class CharArrayWriter extends Writer {
/**
* The buffer where data is stored.
*/
protected char buf[];
/**
* The number of chars in the buffer.
*/
protected int count;
/**
* Creates a new CharArrayWriter.
*/
public CharArrayWriter() {
this(32);
}
/**
* Creates a new CharArrayWriter with the specified initial size.
*
* @param initialSize an int specifying the initial buffer size.
* @exception IllegalArgumentException if initialSize is negative
*/
public CharArrayWriter(int initialSize) {
if (initialSize < 0) {
throw new IllegalArgumentException("Negative initial size: "
+ initialSize);
}
buf = new char[initialSize];
}
/**
* Writes a character to the buffer.
*/
public void write(int c) {
synchronized (lock) {
int newcount = count + 1;
if (newcount > buf.length) {
buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount));
}
buf[count] = (char)c;
count = newcount;
}
}
/**
* Writes characters to the buffer.
* @param c the data to be written
* @param off the start offset in the data
* @param len the number of chars that are written
*/
public void write(char c[], int off, int len) {
if ((off < 0) || (off > c.length) || (len < 0) ||
((off + len) > c.length) || ((off + len) < 0)) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return;
}
synchronized (lock) {
int newcount = count + len;
if (newcount > buf.length) {
buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount));
}
System.arraycopy(c, off, buf, count, len);
count = newcount;
}
}
/**
* Write a portion of a string to the buffer.
* @param str String to be written from
* @param off Offset from which to start reading characters
* @param len Number of characters to be written
*/
public void write(String str, int off, int len) {
synchronized (lock) {
int newcount = count + len;
if (newcount > buf.length) {
buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount));
}
str.getChars(off, off + len, buf, count);
count = newcount;
}
}
/**
* Writes the contents of the buffer to another character stream.
*
* @param out the output stream to write to
* @throws IOException If an I/O error occurs.
*/
public void writeTo(Writer out) throws IOException {
synchronized (lock) {
out.write(buf, 0, count);
}
}
/**
* Appends the specified character sequence to this writer.
*
* <p> An invocation of this method of the form <tt>out.append(csq)</tt>
* behaves in exactly the same way as the invocation
*
* <pre>
* out.write(csq.toString()) </pre>
*
* <p> Depending on the specification of <tt>toString</tt> for the
* character sequence <tt>csq</tt>, the entire sequence may not be
* appended. For instance, invoking the <tt>toString</tt> method of a
* character buffer will return a subsequence whose content depends upon
* the buffer's position and limit.
*
* @param csq
* The character sequence to append. If <tt>csq</tt> is
* <tt>null</tt>, then the four characters <tt>"null"</tt> are
* appended to this writer.
*
* @return This writer
*
* @since 1.5
*/
public CharArrayWriter append(CharSequence csq) {
String s = (csq == null ? "null" : csq.toString());
write(s, 0, s.length());
return this;
}
/**
* Appends a subsequence of the specified character sequence to this writer.
*
* <p> An invocation of this method of the form <tt>out.append(csq, start,
* end)</tt> when <tt>csq</tt> is not <tt>null</tt>, behaves in
* exactly the same way as the invocation
*
* <pre>
* out.write(csq.subSequence(start, end).toString()) </pre>
*
* @param csq
* The character sequence from which a subsequence will be
* appended. If <tt>csq</tt> is <tt>null</tt>, then characters
* will be appended as if <tt>csq</tt> contained the four
* characters <tt>"null"</tt>.
*
* @param start
* The index of the first character in the subsequence
*
* @param end
* The index of the character following the last character in the
* subsequence
*
* @return This writer
*
* @throws IndexOutOfBoundsException
* If <tt>start</tt> or <tt>end</tt> are negative, <tt>start</tt>
* is greater than <tt>end</tt>, or <tt>end</tt> is greater than
* <tt>csq.length()</tt>
*
* @since 1.5
*/
public CharArrayWriter append(CharSequence csq, int start, int end) {
String s = (csq == null ? "null" : csq).subSequence(start, end).toString();
write(s, 0, s.length());
return this;
}
/**
* Appends the specified character to this writer.
*
* <p> An invocation of this method of the form <tt>out.append(c)</tt>
* behaves in exactly the same way as the invocation
*
* <pre>
* out.write(c) </pre>
*
* @param c
* The 16-bit character to append
*
* @return This writer
*
* @since 1.5
*/
public CharArrayWriter append(char c) {
write(c);
return this;
}
/**
* Resets the buffer so that you can use it again without
* throwing away the already allocated buffer.
*/
public void reset() {
count = 0;
}
/**
* Returns a copy of the input data.
*
* @return an array of chars copied from the input data.
*/
public char toCharArray()[] {
synchronized (lock) {
return Arrays.copyOf(buf, count);
}
}
/**
* Returns the current size of the buffer.
*
* @return an int representing the current size of the buffer.
*/
public int size() {
return count;
}
/**
* Converts input data to a string.
* @return the string.
*/
public String toString() {
synchronized (lock) {
return new String(buf, 0, count);
}
}
/**
* 本身就是个数组,所以 flush() 和 close() 都没什么意义
*/
public void flush() { }
/**
* Close the stream. This method does not release the buffer, since its
* contents might still be required. Note: Invoking this method in this class
* will have no effect.
*/
public void close() { }
}