/* | |
* Licensed to the Apache Software Foundation (ASF) under one or more | |
* contributor license agreements. See the NOTICE file distributed with | |
* this work for additional information regarding copyright ownership. | |
* The ASF licenses this file to You under the Apache License, Version 2.0 | |
* (the "License"); you may not use this file except in compliance with | |
* the License. You may obtain a copy of the License at | |
* | |
* http://www.apache.org/licenses/LICENSE-2.0 | |
* | |
* Unless required by applicable law or agreed to in writing, software | |
* distributed under the License is distributed on an "AS IS" BASIS, | |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
* See the License for the specific language governing permissions and | |
* limitations under the License. | |
*/ | |
package org.apache.commons.io; | |
import java.io.BufferedInputStream; | |
import java.io.BufferedReader; | |
import java.io.ByteArrayInputStream; | |
import java.io.CharArrayWriter; | |
import java.io.File; | |
import java.io.IOException; | |
import java.io.InputStream; | |
import java.io.InputStreamReader; | |
import java.io.OutputStream; | |
import java.io.OutputStreamWriter; | |
import java.io.PrintWriter; | |
import java.io.Reader; | |
import java.io.StringWriter; | |
import java.io.Writer; | |
import java.util.ArrayList; | |
import java.util.Collection; | |
import java.util.Iterator; | |
import java.util.List; | |
import org.apache.commons.io.output.ByteArrayOutputStream; | |
/** | |
* General IO stream manipulation utilities. | |
* <p> | |
* This class provides static utility methods for input/output operations. | |
* <ul> | |
* <li>closeQuietly - these methods close a stream ignoring nulls and exceptions | |
* <li>toXxx/read - these methods read data from a stream | |
* <li>write - these methods write data to a stream | |
* <li>copy - these methods copy all the data from one stream to another | |
* <li>contentEquals - these methods compare the content of two streams | |
* </ul> | |
* <p> | |
* The byte-to-char methods and char-to-byte methods involve a conversion step. | |
* Two methods are provided in each case, one that uses the platform default | |
* encoding and the other which allows you to specify an encoding. You are | |
* encouraged to always specify an encoding because relying on the platform | |
* default can lead to unexpected results, for example when moving from | |
* development to production. | |
* <p> | |
* All the methods in this class that read a stream are buffered internally. | |
* This means that there is no cause to use a <code>BufferedInputStream</code> | |
* or <code>BufferedReader</code>. The default buffer size of 4K has been shown | |
* to be efficient in tests. | |
* <p> | |
* Wherever possible, the methods in this class do <em>not</em> flush or close | |
* the stream. This is to avoid making non-portable assumptions about the | |
* streams' origin and further use. Thus the caller is still responsible for | |
* closing streams after use. | |
* <p> | |
* Origin of code: Excalibur. | |
* | |
* @author Peter Donald | |
* @author Jeff Turner | |
* @author Matthew Hawthorne | |
* @author Stephen Colebourne | |
* @author Gareth Davis | |
* @author Ian Springer | |
* @author Niall Pemberton | |
* @author Sandy McArthur | |
* @version $Id: IOUtils.java 481854 2006-12-03 18:30:07Z scolebourne $ | |
*/ | |
public class IOUtils { | |
// NOTE: This class is focussed on InputStream, OutputStream, Reader and | |
// Writer. Each method should take at least one of these as a parameter, | |
// or return one of them. | |
/** | |
* The Unix directory separator character. | |
*/ | |
public static final char DIR_SEPARATOR_UNIX = '/'; | |
/** | |
* The Windows directory separator character. | |
*/ | |
public static final char DIR_SEPARATOR_WINDOWS = '\\'; | |
/** | |
* The system directory separator character. | |
*/ | |
public static final char DIR_SEPARATOR = File.separatorChar; | |
/** | |
* The Unix line separator string. | |
*/ | |
public static final String LINE_SEPARATOR_UNIX = "\n"; | |
/** | |
* The Windows line separator string. | |
*/ | |
public static final String LINE_SEPARATOR_WINDOWS = "\r\n"; | |
/** | |
* The system line separator string. | |
*/ | |
public static final String LINE_SEPARATOR; | |
static { | |
// avoid security issues | |
StringWriter buf = new StringWriter(4); | |
PrintWriter out = new PrintWriter(buf); | |
out.println(); | |
LINE_SEPARATOR = buf.toString(); | |
} | |
/** | |
* The default buffer size to use. | |
*/ | |
private static final int DEFAULT_BUFFER_SIZE = 1024 * 4; | |
/** | |
* Instances should NOT be constructed in standard programming. | |
*/ | |
public IOUtils() { | |
super(); | |
} | |
//----------------------------------------------------------------------- | |
/** | |
* Unconditionally close an <code>Reader</code>. | |
* <p> | |
* Equivalent to {@link Reader#close()}, except any exceptions will be ignored. | |
* This is typically used in finally blocks. | |
* | |
* @param input the Reader to close, may be null or already closed | |
*/ | |
public static void closeQuietly(Reader input) { | |
try { | |
if (input != null) { | |
input.close(); | |
} | |
} catch (IOException ioe) { | |
// ignore | |
} | |
} | |
/** | |
* Unconditionally close a <code>Writer</code>. | |
* <p> | |
* Equivalent to {@link Writer#close()}, except any exceptions will be ignored. | |
* This is typically used in finally blocks. | |
* | |
* @param output the Writer to close, may be null or already closed | |
*/ | |
public static void closeQuietly(Writer output) { | |
try { | |
if (output != null) { | |
output.close(); | |
} | |
} catch (IOException ioe) { | |
// ignore | |
} | |
} | |
/** | |
* Unconditionally close an <code>InputStream</code>. | |
* <p> | |
* Equivalent to {@link InputStream#close()}, except any exceptions will be ignored. | |
* This is typically used in finally blocks. | |
* | |
* @param input the InputStream to close, may be null or already closed | |
*/ | |
public static void closeQuietly(InputStream input) { | |
try { | |
if (input != null) { | |
input.close(); | |
} | |
} catch (IOException ioe) { | |
// ignore | |
} | |
} | |
/** | |
* Unconditionally close an <code>OutputStream</code>. | |
* <p> | |
* Equivalent to {@link OutputStream#close()}, except any exceptions will be ignored. | |
* This is typically used in finally blocks. | |
* | |
* @param output the OutputStream to close, may be null or already closed | |
*/ | |
public static void closeQuietly(OutputStream output) { | |
try { | |
if (output != null) { | |
output.close(); | |
} | |
} catch (IOException ioe) { | |
// ignore | |
} | |
} | |
// read toByteArray | |
//----------------------------------------------------------------------- | |
/** | |
* Get the contents of an <code>InputStream</code> as a <code>byte[]</code>. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedInputStream</code>. | |
* | |
* @param input the <code>InputStream</code> to read from | |
* @return the requested byte array | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
*/ | |
public static byte[] toByteArray(InputStream input) throws IOException { | |
ByteArrayOutputStream output = new ByteArrayOutputStream(); | |
copy(input, output); | |
return output.toByteArray(); | |
} | |
/** | |
* Get the contents of a <code>Reader</code> as a <code>byte[]</code> | |
* using the default character encoding of the platform. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedReader</code>. | |
* | |
* @param input the <code>Reader</code> to read from | |
* @return the requested byte array | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
*/ | |
public static byte[] toByteArray(Reader input) throws IOException { | |
ByteArrayOutputStream output = new ByteArrayOutputStream(); | |
copy(input, output); | |
return output.toByteArray(); | |
} | |
/** | |
* Get the contents of a <code>Reader</code> as a <code>byte[]</code> | |
* using the specified character encoding. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedReader</code>. | |
* | |
* @param input the <code>Reader</code> to read from | |
* @param encoding the encoding to use, null means platform default | |
* @return the requested byte array | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static byte[] toByteArray(Reader input, String encoding) | |
throws IOException { | |
ByteArrayOutputStream output = new ByteArrayOutputStream(); | |
copy(input, output, encoding); | |
return output.toByteArray(); | |
} | |
/** | |
* Get the contents of a <code>String</code> as a <code>byte[]</code> | |
* using the default character encoding of the platform. | |
* <p> | |
* This is the same as {@link String#getBytes()}. | |
* | |
* @param input the <code>String</code> to convert | |
* @return the requested byte array | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs (never occurs) | |
* @deprecated Use {@link String#getBytes()} | |
*/ | |
public static byte[] toByteArray(String input) throws IOException { | |
return input.getBytes(); | |
} | |
// read char[] | |
//----------------------------------------------------------------------- | |
/** | |
* Get the contents of an <code>InputStream</code> as a character array | |
* using the default character encoding of the platform. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedInputStream</code>. | |
* | |
* @param is the <code>InputStream</code> to read from | |
* @return the requested character array | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static char[] toCharArray(InputStream is) throws IOException { | |
CharArrayWriter output = new CharArrayWriter(); | |
copy(is, output); | |
return output.toCharArray(); | |
} | |
/** | |
* Get the contents of an <code>InputStream</code> as a character array | |
* using the specified character encoding. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedInputStream</code>. | |
* | |
* @param is the <code>InputStream</code> to read from | |
* @param encoding the encoding to use, null means platform default | |
* @return the requested character array | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static char[] toCharArray(InputStream is, String encoding) | |
throws IOException { | |
CharArrayWriter output = new CharArrayWriter(); | |
copy(is, output, encoding); | |
return output.toCharArray(); | |
} | |
/** | |
* Get the contents of a <code>Reader</code> as a character array. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedReader</code>. | |
* | |
* @param input the <code>Reader</code> to read from | |
* @return the requested character array | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static char[] toCharArray(Reader input) throws IOException { | |
CharArrayWriter sw = new CharArrayWriter(); | |
copy(input, sw); | |
return sw.toCharArray(); | |
} | |
// read toString | |
//----------------------------------------------------------------------- | |
/** | |
* Get the contents of an <code>InputStream</code> as a String | |
* using the default character encoding of the platform. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedInputStream</code>. | |
* | |
* @param input the <code>InputStream</code> to read from | |
* @return the requested String | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
*/ | |
public static String toString(InputStream input) throws IOException { | |
StringWriter sw = new StringWriter(); | |
copy(input, sw); | |
return sw.toString(); | |
} | |
/** | |
* Get the contents of an <code>InputStream</code> as a String | |
* using the specified character encoding. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedInputStream</code>. | |
* | |
* @param input the <code>InputStream</code> to read from | |
* @param encoding the encoding to use, null means platform default | |
* @return the requested String | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
*/ | |
public static String toString(InputStream input, String encoding) | |
throws IOException { | |
StringWriter sw = new StringWriter(); | |
copy(input, sw, encoding); | |
return sw.toString(); | |
} | |
/** | |
* Get the contents of a <code>Reader</code> as a String. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedReader</code>. | |
* | |
* @param input the <code>Reader</code> to read from | |
* @return the requested String | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
*/ | |
public static String toString(Reader input) throws IOException { | |
StringWriter sw = new StringWriter(); | |
copy(input, sw); | |
return sw.toString(); | |
} | |
/** | |
* Get the contents of a <code>byte[]</code> as a String | |
* using the default character encoding of the platform. | |
* | |
* @param input the byte array to read from | |
* @return the requested String | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs (never occurs) | |
* @deprecated Use {@link String#String(byte[])} | |
*/ | |
public static String toString(byte[] input) throws IOException { | |
return new String(input); | |
} | |
/** | |
* Get the contents of a <code>byte[]</code> as a String | |
* using the specified character encoding. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* | |
* @param input the byte array to read from | |
* @param encoding the encoding to use, null means platform default | |
* @return the requested String | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs (never occurs) | |
* @deprecated Use {@link String#String(byte[],String)} | |
*/ | |
public static String toString(byte[] input, String encoding) | |
throws IOException { | |
if (encoding == null) { | |
return new String(input); | |
} else { | |
return new String(input, encoding); | |
} | |
} | |
// readLines | |
//----------------------------------------------------------------------- | |
/** | |
* Get the contents of an <code>InputStream</code> as a list of Strings, | |
* one entry per line, using the default character encoding of the platform. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedInputStream</code>. | |
* | |
* @param input the <code>InputStream</code> to read from, not null | |
* @return the list of Strings, never null | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static List<String> readLines(InputStream input) throws IOException { | |
InputStreamReader reader = new InputStreamReader(input); | |
return readLines(reader); | |
} | |
/** | |
* Get the contents of an <code>InputStream</code> as a list of Strings, | |
* one entry per line, using the specified character encoding. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedInputStream</code>. | |
* | |
* @param input the <code>InputStream</code> to read from, not null | |
* @param encoding the encoding to use, null means platform default | |
* @return the list of Strings, never null | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static List<String> readLines(InputStream input, String encoding) throws IOException { | |
if (encoding == null) { | |
return readLines(input); | |
} else { | |
InputStreamReader reader = new InputStreamReader(input, encoding); | |
return readLines(reader); | |
} | |
} | |
/** | |
* Get the contents of a <code>Reader</code> as a list of Strings, | |
* one entry per line. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedReader</code>. | |
* | |
* @param input the <code>Reader</code> to read from, not null | |
* @return the list of Strings, never null | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static List<String> readLines(Reader input) throws IOException { | |
BufferedReader reader = new BufferedReader(input); | |
List<String> list = new ArrayList<String>(); | |
String line = reader.readLine(); | |
while (line != null) { | |
list.add(line); | |
line = reader.readLine(); | |
} | |
return list; | |
} | |
// lineIterator | |
//----------------------------------------------------------------------- | |
/** | |
* Return an Iterator for the lines in a <code>Reader</code>. | |
* <p> | |
* <code>LineIterator</code> holds a reference to the open | |
* <code>Reader</code> specified here. When you have finished with the | |
* iterator you should close the reader to free internal resources. | |
* This can be done by closing the reader directly, or by calling | |
* {@link LineIterator#close()} or {@link LineIterator#closeQuietly(LineIterator)}. | |
* <p> | |
* The recommended usage pattern is: | |
* <pre> | |
* try { | |
* LineIterator it = IOUtils.lineIterator(reader); | |
* while (it.hasNext()) { | |
* String line = it.nextLine(); | |
* /// do something with line | |
* } | |
* } finally { | |
* IOUtils.closeQuietly(reader); | |
* } | |
* </pre> | |
* | |
* @param reader the <code>Reader</code> to read from, not null | |
* @return an Iterator of the lines in the reader, never null | |
* @throws IllegalArgumentException if the reader is null | |
* @since Commons IO 1.2 | |
*/ | |
public static LineIterator lineIterator(Reader reader) { | |
return new LineIterator(reader); | |
} | |
/** | |
* Return an Iterator for the lines in an <code>InputStream</code>, using | |
* the character encoding specified (or default encoding if null). | |
* <p> | |
* <code>LineIterator</code> holds a reference to the open | |
* <code>InputStream</code> specified here. When you have finished with | |
* the iterator you should close the stream to free internal resources. | |
* This can be done by closing the stream directly, or by calling | |
* {@link LineIterator#close()} or {@link LineIterator#closeQuietly(LineIterator)}. | |
* <p> | |
* The recommended usage pattern is: | |
* <pre> | |
* try { | |
* LineIterator it = IOUtils.lineIterator(stream, "UTF-8"); | |
* while (it.hasNext()) { | |
* String line = it.nextLine(); | |
* /// do something with line | |
* } | |
* } finally { | |
* IOUtils.closeQuietly(stream); | |
* } | |
* </pre> | |
* | |
* @param input the <code>InputStream</code> to read from, not null | |
* @param encoding the encoding to use, null means platform default | |
* @return an Iterator of the lines in the reader, never null | |
* @throws IllegalArgumentException if the input is null | |
* @throws IOException if an I/O error occurs, such as if the encoding is invalid | |
* @since Commons IO 1.2 | |
*/ | |
public static LineIterator lineIterator(InputStream input, String encoding) | |
throws IOException { | |
Reader reader = null; | |
if (encoding == null) { | |
reader = new InputStreamReader(input); | |
} else { | |
reader = new InputStreamReader(input, encoding); | |
} | |
return new LineIterator(reader); | |
} | |
//----------------------------------------------------------------------- | |
/** | |
* Convert the specified string to an input stream, encoded as bytes | |
* using the default character encoding of the platform. | |
* | |
* @param input the string to convert | |
* @return an input stream | |
* @since Commons IO 1.1 | |
*/ | |
public static InputStream toInputStream(String input) { | |
byte[] bytes = input.getBytes(); | |
return new ByteArrayInputStream(bytes); | |
} | |
/** | |
* Convert the specified string to an input stream, encoded as bytes | |
* using the specified character encoding. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* | |
* @param input the string to convert | |
* @param encoding the encoding to use, null means platform default | |
* @throws IOException if the encoding is invalid | |
* @return an input stream | |
* @since Commons IO 1.1 | |
*/ | |
public static InputStream toInputStream(String input, String encoding) throws IOException { | |
byte[] bytes = encoding != null ? input.getBytes(encoding) : input.getBytes(); | |
return new ByteArrayInputStream(bytes); | |
} | |
// write byte[] | |
//----------------------------------------------------------------------- | |
/** | |
* Writes bytes from a <code>byte[]</code> to an <code>OutputStream</code>. | |
* | |
* @param data the byte array to write, do not modify during output, | |
* null ignored | |
* @param output the <code>OutputStream</code> to write to | |
* @throws NullPointerException if output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void write(byte[] data, OutputStream output) | |
throws IOException { | |
if (data != null) { | |
output.write(data); | |
} | |
} | |
/** | |
* Writes bytes from a <code>byte[]</code> to chars on a <code>Writer</code> | |
* using the default character encoding of the platform. | |
* <p> | |
* This method uses {@link String#String(byte[])}. | |
* | |
* @param data the byte array to write, do not modify during output, | |
* null ignored | |
* @param output the <code>Writer</code> to write to | |
* @throws NullPointerException if output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void write(byte[] data, Writer output) throws IOException { | |
if (data != null) { | |
output.write(new String(data)); | |
} | |
} | |
/** | |
* Writes bytes from a <code>byte[]</code> to chars on a <code>Writer</code> | |
* using the specified character encoding. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* <p> | |
* This method uses {@link String#String(byte[], String)}. | |
* | |
* @param data the byte array to write, do not modify during output, | |
* null ignored | |
* @param output the <code>Writer</code> to write to | |
* @param encoding the encoding to use, null means platform default | |
* @throws NullPointerException if output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void write(byte[] data, Writer output, String encoding) | |
throws IOException { | |
if (data != null) { | |
if (encoding == null) { | |
write(data, output); | |
} else { | |
output.write(new String(data, encoding)); | |
} | |
} | |
} | |
// write char[] | |
//----------------------------------------------------------------------- | |
/** | |
* Writes chars from a <code>char[]</code> to a <code>Writer</code> | |
* using the default character encoding of the platform. | |
* | |
* @param data the char array to write, do not modify during output, | |
* null ignored | |
* @param output the <code>Writer</code> to write to | |
* @throws NullPointerException if output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void write(char[] data, Writer output) throws IOException { | |
if (data != null) { | |
output.write(data); | |
} | |
} | |
/** | |
* Writes chars from a <code>char[]</code> to bytes on an | |
* <code>OutputStream</code>. | |
* <p> | |
* This method uses {@link String#String(char[])} and | |
* {@link String#getBytes()}. | |
* | |
* @param data the char array to write, do not modify during output, | |
* null ignored | |
* @param output the <code>OutputStream</code> to write to | |
* @throws NullPointerException if output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void write(char[] data, OutputStream output) | |
throws IOException { | |
if (data != null) { | |
output.write(new String(data).getBytes()); | |
} | |
} | |
/** | |
* Writes chars from a <code>char[]</code> to bytes on an | |
* <code>OutputStream</code> using the specified character encoding. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* <p> | |
* This method uses {@link String#String(char[])} and | |
* {@link String#getBytes(String)}. | |
* | |
* @param data the char array to write, do not modify during output, | |
* null ignored | |
* @param output the <code>OutputStream</code> to write to | |
* @param encoding the encoding to use, null means platform default | |
* @throws NullPointerException if output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void write(char[] data, OutputStream output, String encoding) | |
throws IOException { | |
if (data != null) { | |
if (encoding == null) { | |
write(data, output); | |
} else { | |
output.write(new String(data).getBytes(encoding)); | |
} | |
} | |
} | |
// write String | |
//----------------------------------------------------------------------- | |
/** | |
* Writes chars from a <code>String</code> to a <code>Writer</code>. | |
* | |
* @param data the <code>String</code> to write, null ignored | |
* @param output the <code>Writer</code> to write to | |
* @throws NullPointerException if output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void write(String data, Writer output) throws IOException { | |
if (data != null) { | |
output.write(data); | |
} | |
} | |
/** | |
* Writes chars from a <code>String</code> to bytes on an | |
* <code>OutputStream</code> using the default character encoding of the | |
* platform. | |
* <p> | |
* This method uses {@link String#getBytes()}. | |
* | |
* @param data the <code>String</code> to write, null ignored | |
* @param output the <code>OutputStream</code> to write to | |
* @throws NullPointerException if output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void write(String data, OutputStream output) | |
throws IOException { | |
if (data != null) { | |
output.write(data.getBytes()); | |
} | |
} | |
/** | |
* Writes chars from a <code>String</code> to bytes on an | |
* <code>OutputStream</code> using the specified character encoding. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* <p> | |
* This method uses {@link String#getBytes(String)}. | |
* | |
* @param data the <code>String</code> to write, null ignored | |
* @param output the <code>OutputStream</code> to write to | |
* @param encoding the encoding to use, null means platform default | |
* @throws NullPointerException if output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void write(String data, OutputStream output, String encoding) | |
throws IOException { | |
if (data != null) { | |
if (encoding == null) { | |
write(data, output); | |
} else { | |
output.write(data.getBytes(encoding)); | |
} | |
} | |
} | |
// write StringBuffer | |
//----------------------------------------------------------------------- | |
/** | |
* Writes chars from a <code>StringBuffer</code> to a <code>Writer</code>. | |
* | |
* @param data the <code>StringBuffer</code> to write, null ignored | |
* @param output the <code>Writer</code> to write to | |
* @throws NullPointerException if output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void write(StringBuffer data, Writer output) | |
throws IOException { | |
if (data != null) { | |
output.write(data.toString()); | |
} | |
} | |
/** | |
* Writes chars from a <code>StringBuffer</code> to bytes on an | |
* <code>OutputStream</code> using the default character encoding of the | |
* platform. | |
* <p> | |
* This method uses {@link String#getBytes()}. | |
* | |
* @param data the <code>StringBuffer</code> to write, null ignored | |
* @param output the <code>OutputStream</code> to write to | |
* @throws NullPointerException if output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void write(StringBuffer data, OutputStream output) | |
throws IOException { | |
if (data != null) { | |
output.write(data.toString().getBytes()); | |
} | |
} | |
/** | |
* Writes chars from a <code>StringBuffer</code> to bytes on an | |
* <code>OutputStream</code> using the specified character encoding. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* <p> | |
* This method uses {@link String#getBytes(String)}. | |
* | |
* @param data the <code>StringBuffer</code> to write, null ignored | |
* @param output the <code>OutputStream</code> to write to | |
* @param encoding the encoding to use, null means platform default | |
* @throws NullPointerException if output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void write(StringBuffer data, OutputStream output, | |
String encoding) throws IOException { | |
if (data != null) { | |
if (encoding == null) { | |
write(data, output); | |
} else { | |
output.write(data.toString().getBytes(encoding)); | |
} | |
} | |
} | |
// writeLines | |
//----------------------------------------------------------------------- | |
/** | |
* Writes the <code>toString()</code> value of each item in a collection to | |
* an <code>OutputStream</code> line by line, using the default character | |
* encoding of the platform and the specified line ending. | |
* | |
* @param lines the lines to write, null entries produce blank lines | |
* @param lineEnding the line separator to use, null is system default | |
* @param output the <code>OutputStream</code> to write to, not null, not closed | |
* @throws NullPointerException if the output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void writeLines(Collection<Object> lines, String lineEnding, | |
OutputStream output) throws IOException { | |
if (lines == null) { | |
return; | |
} | |
if (lineEnding == null) { | |
lineEnding = LINE_SEPARATOR; | |
} | |
for (Iterator<Object> it = lines.iterator(); it.hasNext(); ) { | |
Object line = it.next(); | |
if (line != null) { | |
output.write(line.toString().getBytes()); | |
} | |
output.write(lineEnding.getBytes()); | |
} | |
} | |
/** | |
* Writes the <code>toString()</code> value of each item in a collection to | |
* an <code>OutputStream</code> line by line, using the specified character | |
* encoding and the specified line ending. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* | |
* @param lines the lines to write, null entries produce blank lines | |
* @param lineEnding the line separator to use, null is system default | |
* @param output the <code>OutputStream</code> to write to, not null, not closed | |
* @param encoding the encoding to use, null means platform default | |
* @throws NullPointerException if the output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void writeLines(Collection<Object> lines, String lineEnding, | |
OutputStream output, String encoding) throws IOException { | |
if (encoding == null) { | |
writeLines(lines, lineEnding, output); | |
} else { | |
if (lines == null) { | |
return; | |
} | |
if (lineEnding == null) { | |
lineEnding = LINE_SEPARATOR; | |
} | |
for (Iterator<Object> it = lines.iterator(); it.hasNext(); ) { | |
Object line = it.next(); | |
if (line != null) { | |
output.write(line.toString().getBytes(encoding)); | |
} | |
output.write(lineEnding.getBytes(encoding)); | |
} | |
} | |
} | |
/** | |
* Writes the <code>toString()</code> value of each item in a collection to | |
* a <code>Writer</code> line by line, using the specified line ending. | |
* | |
* @param lines the lines to write, null entries produce blank lines | |
* @param lineEnding the line separator to use, null is system default | |
* @param writer the <code>Writer</code> to write to, not null, not closed | |
* @throws NullPointerException if the input is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void writeLines(Collection<Object> lines, String lineEnding, | |
Writer writer) throws IOException { | |
if (lines == null) { | |
return; | |
} | |
if (lineEnding == null) { | |
lineEnding = LINE_SEPARATOR; | |
} | |
for (Iterator<Object> it = lines.iterator(); it.hasNext(); ) { | |
Object line = it.next(); | |
if (line != null) { | |
writer.write(line.toString()); | |
} | |
writer.write(lineEnding); | |
} | |
} | |
// copy from InputStream | |
//----------------------------------------------------------------------- | |
/** | |
* Copy bytes from an <code>InputStream</code> to an | |
* <code>OutputStream</code>. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedInputStream</code>. | |
* <p> | |
* Large streams (over 2GB) will return a bytes copied value of | |
* <code>-1</code> after the copy has completed since the correct | |
* number of bytes cannot be returned as an int. For large streams | |
* use the <code>copyLarge(InputStream, OutputStream)</code> method. | |
* | |
* @param input the <code>InputStream</code> to read from | |
* @param output the <code>OutputStream</code> to write to | |
* @return the number of bytes copied | |
* @throws NullPointerException if the input or output is null | |
* @throws IOException if an I/O error occurs | |
* @throws ArithmeticException if the byte count is too large | |
* @since Commons IO 1.1 | |
*/ | |
public static int copy(InputStream input, OutputStream output) throws IOException { | |
long count = copyLarge(input, output); | |
if (count > Integer.MAX_VALUE) { | |
return -1; | |
} | |
return (int) count; | |
} | |
/** | |
* Copy bytes from a large (over 2GB) <code>InputStream</code> to an | |
* <code>OutputStream</code>. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedInputStream</code>. | |
* | |
* @param input the <code>InputStream</code> to read from | |
* @param output the <code>OutputStream</code> to write to | |
* @return the number of bytes copied | |
* @throws NullPointerException if the input or output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.3 | |
*/ | |
public static long copyLarge(InputStream input, OutputStream output) | |
throws IOException { | |
byte[] buffer = new byte[DEFAULT_BUFFER_SIZE]; | |
long count = 0; | |
int n = 0; | |
while (-1 != (n = input.read(buffer))) { | |
output.write(buffer, 0, n); | |
count += n; | |
} | |
return count; | |
} | |
/** | |
* Copy bytes from an <code>InputStream</code> to chars on a | |
* <code>Writer</code> using the default character encoding of the platform. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedInputStream</code>. | |
* <p> | |
* This method uses {@link InputStreamReader}. | |
* | |
* @param input the <code>InputStream</code> to read from | |
* @param output the <code>Writer</code> to write to | |
* @throws NullPointerException if the input or output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void copy(InputStream input, Writer output) | |
throws IOException { | |
InputStreamReader in = new InputStreamReader(input); | |
copy(in, output); | |
} | |
/** | |
* Copy bytes from an <code>InputStream</code> to chars on a | |
* <code>Writer</code> using the specified character encoding. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedInputStream</code>. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* <p> | |
* This method uses {@link InputStreamReader}. | |
* | |
* @param input the <code>InputStream</code> to read from | |
* @param output the <code>Writer</code> to write to | |
* @param encoding the encoding to use, null means platform default | |
* @throws NullPointerException if the input or output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void copy(InputStream input, Writer output, String encoding) | |
throws IOException { | |
if (encoding == null) { | |
copy(input, output); | |
} else { | |
InputStreamReader in = new InputStreamReader(input, encoding); | |
copy(in, output); | |
} | |
} | |
// copy from Reader | |
//----------------------------------------------------------------------- | |
/** | |
* Copy chars from a <code>Reader</code> to a <code>Writer</code>. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedReader</code>. | |
* <p> | |
* Large streams (over 2GB) will return a chars copied value of | |
* <code>-1</code> after the copy has completed since the correct | |
* number of chars cannot be returned as an int. For large streams | |
* use the <code>copyLarge(Reader, Writer)</code> method. | |
* | |
* @param input the <code>Reader</code> to read from | |
* @param output the <code>Writer</code> to write to | |
* @return the number of characters copied | |
* @throws NullPointerException if the input or output is null | |
* @throws IOException if an I/O error occurs | |
* @throws ArithmeticException if the character count is too large | |
* @since Commons IO 1.1 | |
*/ | |
public static int copy(Reader input, Writer output) throws IOException { | |
long count = copyLarge(input, output); | |
if (count > Integer.MAX_VALUE) { | |
return -1; | |
} | |
return (int) count; | |
} | |
/** | |
* Copy chars from a large (over 2GB) <code>Reader</code> to a <code>Writer</code>. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedReader</code>. | |
* | |
* @param input the <code>Reader</code> to read from | |
* @param output the <code>Writer</code> to write to | |
* @return the number of characters copied | |
* @throws NullPointerException if the input or output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.3 | |
*/ | |
public static long copyLarge(Reader input, Writer output) throws IOException { | |
char[] buffer = new char[DEFAULT_BUFFER_SIZE]; | |
long count = 0; | |
int n = 0; | |
while (-1 != (n = input.read(buffer))) { | |
output.write(buffer, 0, n); | |
count += n; | |
} | |
return count; | |
} | |
/** | |
* Copy chars from a <code>Reader</code> to bytes on an | |
* <code>OutputStream</code> using the default character encoding of the | |
* platform, and calling flush. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedReader</code>. | |
* <p> | |
* Due to the implementation of OutputStreamWriter, this method performs a | |
* flush. | |
* <p> | |
* This method uses {@link OutputStreamWriter}. | |
* | |
* @param input the <code>Reader</code> to read from | |
* @param output the <code>OutputStream</code> to write to | |
* @throws NullPointerException if the input or output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void copy(Reader input, OutputStream output) | |
throws IOException { | |
OutputStreamWriter out = new OutputStreamWriter(output); | |
copy(input, out); | |
// XXX Unless anyone is planning on rewriting OutputStreamWriter, we | |
// have to flush here. | |
out.flush(); | |
} | |
/** | |
* Copy chars from a <code>Reader</code> to bytes on an | |
* <code>OutputStream</code> using the specified character encoding, and | |
* calling flush. | |
* <p> | |
* This method buffers the input internally, so there is no need to use a | |
* <code>BufferedReader</code>. | |
* <p> | |
* Character encoding names can be found at | |
* <a href="http://www.iana.org/assignments/character-sets">IANA</a>. | |
* <p> | |
* Due to the implementation of OutputStreamWriter, this method performs a | |
* flush. | |
* <p> | |
* This method uses {@link OutputStreamWriter}. | |
* | |
* @param input the <code>Reader</code> to read from | |
* @param output the <code>OutputStream</code> to write to | |
* @param encoding the encoding to use, null means platform default | |
* @throws NullPointerException if the input or output is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static void copy(Reader input, OutputStream output, String encoding) | |
throws IOException { | |
if (encoding == null) { | |
copy(input, output); | |
} else { | |
OutputStreamWriter out = new OutputStreamWriter(output, encoding); | |
copy(input, out); | |
// XXX Unless anyone is planning on rewriting OutputStreamWriter, | |
// we have to flush here. | |
out.flush(); | |
} | |
} | |
// content equals | |
//----------------------------------------------------------------------- | |
/** | |
* Compare the contents of two Streams to determine if they are equal or | |
* not. | |
* <p> | |
* This method buffers the input internally using | |
* <code>BufferedInputStream</code> if they are not already buffered. | |
* | |
* @param input1 the first stream | |
* @param input2 the second stream | |
* @return true if the content of the streams are equal or they both don't | |
* exist, false otherwise | |
* @throws NullPointerException if either input is null | |
* @throws IOException if an I/O error occurs | |
*/ | |
public static boolean contentEquals(InputStream input1, InputStream input2) | |
throws IOException { | |
if (!(input1 instanceof BufferedInputStream)) { | |
input1 = new BufferedInputStream(input1); | |
} | |
if (!(input2 instanceof BufferedInputStream)) { | |
input2 = new BufferedInputStream(input2); | |
} | |
int ch = input1.read(); | |
while (-1 != ch) { | |
int ch2 = input2.read(); | |
if (ch != ch2) { | |
return false; | |
} | |
ch = input1.read(); | |
} | |
int ch2 = input2.read(); | |
return (ch2 == -1); | |
} | |
/** | |
* Compare the contents of two Readers to determine if they are equal or | |
* not. | |
* <p> | |
* This method buffers the input internally using | |
* <code>BufferedReader</code> if they are not already buffered. | |
* | |
* @param input1 the first reader | |
* @param input2 the second reader | |
* @return true if the content of the readers are equal or they both don't | |
* exist, false otherwise | |
* @throws NullPointerException if either input is null | |
* @throws IOException if an I/O error occurs | |
* @since Commons IO 1.1 | |
*/ | |
public static boolean contentEquals(Reader input1, Reader input2) | |
throws IOException { | |
if (!(input1 instanceof BufferedReader)) { | |
input1 = new BufferedReader(input1); | |
} | |
if (!(input2 instanceof BufferedReader)) { | |
input2 = new BufferedReader(input2); | |
} | |
int ch = input1.read(); | |
while (-1 != ch) { | |
int ch2 = input2.read(); | |
if (ch != ch2) { | |
return false; | |
} | |
ch = input1.read(); | |
} | |
int ch2 = input2.read(); | |
return (ch2 == -1); | |
} | |
} |