Back to index...

	/*
	* Copyright (c) 1996, 2021, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package java.io;


	/**
	* A character stream that collects its output in a string buffer, which can
	* then be used to construct a string.
	* <p>
	* Closing a {@code StringWriter} has no effect. The methods in this class
	* can be called after the stream has been closed without generating an
	* {@code IOException}.
	*
	* @author Mark Reinhold
	* @since 1.1
	*/

	public class StringWriter extends Writer {

	private StringBuffer buf;

	/**
	* Create a new string writer using the default initial string-buffer
	* size.
	*/
	public StringWriter() {
	buf = new StringBuffer();
	lock = buf;
	}

	/**
	* Create a new string writer using the specified initial string-buffer
	* size.
	*
	* @param initialSize
	* The number of {@code char} values that will fit into this buffer
	* before it is automatically expanded
	*
	* @throws IllegalArgumentException
	* If {@code initialSize} is negative
	*/
	public StringWriter(int initialSize) {
	if (initialSize < 0) {
	throw new IllegalArgumentException("Negative buffer size");
	}
	buf = new StringBuffer(initialSize);
	lock = buf;
	}

	/**
	* Write a single character.
	*/
	public void write(int c) {
	buf.append((char) c);
	}

	/**
	* Write a portion of an array of characters.
	*
	* @param cbuf Array of characters
	* @param off Offset from which to start writing characters
	* @param len Number of characters to write
	*
	* @throws IndexOutOfBoundsException
	* If {@code off} is negative, or {@code len} is negative,
	* or {@code off + len} is negative or greater than the length
	* of the given array
	*/
	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);
	}

	/**
	* Write a string.
	*/
	public void write(String str) {
	buf.append(str);
	}

	/**
	* Write a portion of a string.
	*
	* @param str String to be written
	* @param off Offset from which to start writing characters
	* @param len Number of characters to write
	*
	* @throws IndexOutOfBoundsException
	* If {@code off} is negative, or {@code len} is negative,
	* or {@code off + len} is negative or greater than the length
	* of the given string
	*/
	public void write(String str, int off, int len) {
	buf.append(str, off, off + len);
	}

	/**
	* Appends the specified character sequence to this writer.
	*
	* <p> An invocation of this method of the form {@code out.append(csq)}
	* behaves in exactly the same way as the invocation
	*
	* <pre>
	* out.write(csq.toString()) </pre>
	*
	* <p> Depending on the specification of {@code toString} for the
	* character sequence {@code csq}, the entire sequence may not be
	* appended. For instance, invoking the {@code toString} 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 {@code csq} is
	* {@code null}, then the four characters {@code "null"} are
	* appended to this writer.
	*
	* @return This writer
	*
	* @since 1.5
	*/
	public StringWriter append(CharSequence csq) {
	write(String.valueOf(csq));
	return this;
	}

	/**
	* Appends a subsequence of the specified character sequence to this writer.
	*
	* <p> An invocation of this method of the form
	* {@code out.append(csq, start, end)} when {@code csq}
	* is not {@code null}, behaves in
	* exactly the same way as the invocation
	*
	* <pre>{@code
	* out.write(csq.subSequence(start, end).toString())
	* }</pre>
	*
	* @param csq
	* The character sequence from which a subsequence will be
	* appended. If {@code csq} is {@code null}, then characters
	* will be appended as if {@code csq} contained the four
	* characters {@code "null"}.
	*
	* @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 {@code start} or {@code end} are negative, {@code start}
	* is greater than {@code end}, or {@code end} is greater than
	* {@code csq.length()}
	*
	* @since 1.5
	*/
	public StringWriter append(CharSequence csq, int start, int end) {
	if (csq == null) csq = "null";
	return append(csq.subSequence(start, end));
	}

	/**
	* Appends the specified character to this writer.
	*
	* <p> An invocation of this method of the form {@code out.append(c)}
	* 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 StringWriter append(char c) {
	write(c);
	return this;
	}

	/**
	* Return the buffer's current value as a string.
	*/
	public String toString() {
	return buf.toString();
	}

	/**
	* Return the string buffer itself.
	*
	* @return StringBuffer holding the current buffer value.
	*/
	public StringBuffer getBuffer() {
	return buf;
	}

	/**
	* Flush the stream.
	*
	* <p> The {@code flush} method of {@code StringWriter} does nothing.
	*/
	public void flush() {
	}

	/**
	* Closing a {@code StringWriter} has no effect. The methods in this
	* class can be called after the stream has been closed without generating
	* an {@code IOException}.
	*/
	public void close() throws IOException {
	}

	}

Back to index...