X Tutup
/* * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.io; /** * A character stream whose source is a string. * * @author Mark Reinhold * @since JDK1.1 */ public class StringReader extends Reader { private String str; private int length; private int next = 0; private int mark = 0; /** * Creates a new string reader. * * @param s String providing the character stream. */ public StringReader(String s) { this.str = s; this.length = s.length(); } /** Check to make sure that the stream has not been closed */ private void ensureOpen() throws IOException { if (str == null) throw new IOException("Stream closed"); } /** * Reads a single character. * * @return The character read, or -1 if the end of the stream has been * reached * * @exception IOException If an I/O error occurs */ public int read() throws IOException { synchronized (lock) { ensureOpen(); if (next >= length) return -1; return str.charAt(next++); } } /** * Reads characters into a portion of an array. * * @param cbuf Destination buffer * @param off Offset at which to start writing characters * @param len Maximum number of characters to read * * @return The number of characters read, or -1 if the end of the * stream has been reached * * @exception IOException If an I/O error occurs */ 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; } if (next >= length) return -1; int n = Math.min(length - next, len); str.getChars(next, next + n, cbuf, off); next += n; return n; } } /** * Skips the specified number of characters in the stream. Returns * the number of characters that were skipped. * *

The ns parameter may be negative, even though the * skip method of the {@link Reader} superclass throws * an exception in this case. Negative values of ns cause the * stream to skip backwards. Negative return values indicate a skip * backwards. It is not possible to skip backwards past the beginning of * the string. * *

If the entire string has been read or skipped, then this method has * no effect and always returns 0. * * @exception IOException If an I/O error occurs */ 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; } } /** * Tells whether this stream is ready to be read. * * @return True if the next read() is guaranteed not to block for input * * @exception IOException If the stream is closed */ public boolean ready() throws IOException { synchronized (lock) { ensureOpen(); return true; } } /** * Tells whether this stream supports the mark() operation, which it does. */ public boolean markSupported() { return true; } /** * Marks the present position in the stream. Subsequent calls to reset() * will reposition the stream to this point. * * @param readAheadLimit Limit on the number of characters that may be * read while still preserving the mark. Because * the stream's input comes from a string, there * is no actual limit, so this argument must not * be negative, but is otherwise ignored. * * @exception IllegalArgumentException If {@code readAheadLimit < 0} * @exception IOException If an I/O error occurs */ public void mark(int readAheadLimit) throws IOException { if (readAheadLimit < 0){ throw new IllegalArgumentException("Read-ahead limit < 0"); } synchronized (lock) { ensureOpen(); mark = next; } } /** * Resets the stream to the most recent mark, or to the beginning of the * string if it has never been marked. * * @exception IOException If an I/O error occurs */ public void reset() throws IOException { synchronized (lock) { ensureOpen(); next = mark; } } /** * Closes the stream and releases any system resources associated with * it. Once the stream has been closed, further read(), * ready(), mark(), or reset() invocations will throw an IOException. * Closing a previously closed stream has no effect. */ public void close() { str = null; } }

X Tutup