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() { }
}