All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.codehaus.plexus.util.IOUtil Maven / Gradle / Ivy

Go to download

A collection of various utility classes to ease working with strings, files, command lines, XML and more.

There is a newer version: 4.0.1
Show newest version
package org.codehaus.plexus.util;

/* ====================================================================
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 2001 The Apache Software Foundation.  All rights
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.codehaus.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Apache" and "Apache Software Foundation" and
 *    "Apache Turbine" must not be used to endorse or promote products
 *    derived from this software without prior written permission. For
 *    written permission, please contact [email protected].
 *
 * 5. Products derived from this software may not be called "Apache",
 *    "Apache Turbine", nor may "Apache" appear in their name, without
 *    prior written permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * .
 */

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.nio.channels.Channel;

/**
 * General IO Stream manipulation.
 * 

* This class provides static utility methods for input/output operations, particularly buffered copying between sources * (InputStream, Reader, String and byte[]) and destinations * (OutputStream, Writer, String and byte[]). *

*

* Unless otherwise noted, these copy methods do not flush or close the streams. Often, doing so * would require making non-portable assumptions about the streams' origin and further use. This means that both * streams' close() methods must be called after copying. if one omits this step, then the stream resources * (sockets, file descriptors) are released when the associated Stream is garbage-collected. It is not a good idea to * rely on this mechanism. For a good overview of the distinction between "memory management" and "resource management", * see this UnixReview article *

*

* For each copy method, a variant is provided that allows the caller to specify the buffer size (the * default is 4k). As the buffer size can have a fairly large impact on speed, this may be worth tweaking. Often "large * buffer -> faster" does not hold, even for large data transfers. *

*

* For byte-to-char methods, a copy variant allows the encoding to be selected (otherwise the platform * default is used). *

*

* The copy methods use an internal buffer when copying. It is therefore advisable not to * deliberately wrap the stream arguments to the copy methods in Buffered* streams. For * example, don't do the following: *

* copy( new BufferedInputStream( in ), new BufferedOutputStream( out ) ); *

* The rationale is as follows: *

*

* Imagine that an InputStream's read() is a very expensive operation, which would usually suggest wrapping in a * BufferedInputStream. The BufferedInputStream works by issuing infrequent * {@link java.io.InputStream#read(byte[] b, int off, int len)} requests on the underlying InputStream, to fill an * internal buffer, from which further read requests can inexpensively get their data (until the buffer * runs out). *

*

* However, the copy methods do the same thing, keeping an internal buffer, populated by * {@link InputStream#read(byte[] b, int off, int len)} requests. Having two buffers (or three if the destination stream * is also buffered) is pointless, and the unnecessary buffer management hurts performance slightly (about 3%, according * to some simple experiments). *

* * @author Peter Donald * @author Jeff Turner * @version $Id$ * @since 4.0 */ /* * Behold, intrepid explorers; a map of this class: Method Input Output Dependency ------ ----- ------ ------- 1 copy * InputStream OutputStream (primitive) 2 copy Reader Writer (primitive) 3 copy InputStream Writer 2 4 toString * InputStream String 3 5 toByteArray InputStream byte[] 1 6 copy Reader OutputStream 2 7 toString Reader String 2 8 * toByteArray Reader byte[] 6 9 copy String OutputStream 2 10 copy String Writer (trivial) 11 toByteArray String byte[] * 9 12 copy byte[] Writer 3 13 toString byte[] String 12 14 copy byte[] OutputStream (trivial) Note that only the first * two methods shuffle bytes; the rest use these two, or (if possible) copy using native Java copy methods. As there are * method variants to specify buffer size and encoding, each row may correspond to up to 4 methods. */ public final class IOUtil { private static final int DEFAULT_BUFFER_SIZE = 1024 * 16; /** * Private constructor to prevent instantiation. */ private IOUtil() { } /////////////////////////////////////////////////////////////// // Core copy methods /////////////////////////////////////////////////////////////// /** * Copy bytes from an InputStream to an OutputStream. */ public static void copy( final InputStream input, final OutputStream output ) throws IOException { copy( input, output, DEFAULT_BUFFER_SIZE ); } /** * Copy bytes from an InputStream to an OutputStream. * * @param bufferSize Size of internal buffer to use. */ public static void copy( final InputStream input, final OutputStream output, final int bufferSize ) throws IOException { final byte[] buffer = new byte[bufferSize]; int n = 0; while ( 0 <= ( n = input.read( buffer ) ) ) { output.write( buffer, 0, n ); } } /** * Copy chars from a Reader to a Writer. */ public static void copy( final Reader input, final Writer output ) throws IOException { copy( input, output, DEFAULT_BUFFER_SIZE ); } /** * Copy chars from a Reader to a Writer. * * @param bufferSize Size of internal buffer to use. */ public static void copy( final Reader input, final Writer output, final int bufferSize ) throws IOException { final char[] buffer = new char[bufferSize]; int n = 0; while ( 0 <= ( n = input.read( buffer ) ) ) { output.write( buffer, 0, n ); } output.flush(); } /////////////////////////////////////////////////////////////// // Derived copy methods // InputStream -> * /////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// // InputStream -> Writer /** * Copy and convert bytes from an InputStream to chars on a Writer. The platform's default * encoding is used for the byte-to-char conversion. */ public static void copy( final InputStream input, final Writer output ) throws IOException { copy( input, output, DEFAULT_BUFFER_SIZE ); } /** * Copy and convert bytes from an InputStream to chars on a Writer. The platform's default * encoding is used for the byte-to-char conversion. * * @param bufferSize Size of internal buffer to use. */ public static void copy( final InputStream input, final Writer output, final int bufferSize ) throws IOException { final InputStreamReader in = new InputStreamReader( input ); copy( in, output, bufferSize ); } /** * Copy and convert bytes from an InputStream to chars on a Writer, using the specified * encoding. * * @param encoding The name of a supported character encoding. See the * IANA Charset Registry for a list of valid * encoding types. */ public static void copy( final InputStream input, final Writer output, final String encoding ) throws IOException { final InputStreamReader in = new InputStreamReader( input, encoding ); copy( in, output ); } /** * Copy and convert bytes from an InputStream to chars on a Writer, using the specified * encoding. * * @param encoding The name of a supported character encoding. See the * IANA Charset Registry for a list of valid * encoding types. * @param bufferSize Size of internal buffer to use. */ public static void copy( final InputStream input, final Writer output, final String encoding, final int bufferSize ) throws IOException { final InputStreamReader in = new InputStreamReader( input, encoding ); copy( in, output, bufferSize ); } /////////////////////////////////////////////////////////////// // InputStream -> String /** * Get the contents of an InputStream as a String. The platform's default encoding is used for the * byte-to-char conversion. */ public static String toString( final InputStream input ) throws IOException { return toString( input, DEFAULT_BUFFER_SIZE ); } /** * Get the contents of an InputStream as a String. The platform's default encoding is used for the * byte-to-char conversion. * * @param bufferSize Size of internal buffer to use. */ public static String toString( final InputStream input, final int bufferSize ) throws IOException { final StringWriter sw = new StringWriter(); copy( input, sw, bufferSize ); return sw.toString(); } /** * Get the contents of an InputStream as a String. * * @param encoding The name of a supported character encoding. See the * IANA Charset Registry for a list of valid * encoding types. */ public static String toString( final InputStream input, final String encoding ) throws IOException { return toString( input, encoding, DEFAULT_BUFFER_SIZE ); } /** * Get the contents of an InputStream as a String. * * @param encoding The name of a supported character encoding. See the * IANA Charset Registry for a list of valid * encoding types. * @param bufferSize Size of internal buffer to use. */ public static String toString( final InputStream input, final String encoding, final int bufferSize ) throws IOException { final StringWriter sw = new StringWriter(); copy( input, sw, encoding, bufferSize ); return sw.toString(); } /////////////////////////////////////////////////////////////// // InputStream -> byte[] /** * Get the contents of an InputStream as a byte[]. */ public static byte[] toByteArray( final InputStream input ) throws IOException { return toByteArray( input, DEFAULT_BUFFER_SIZE ); } /** * Get the contents of an InputStream as a byte[]. * * @param bufferSize Size of internal buffer to use. */ public static byte[] toByteArray( final InputStream input, final int bufferSize ) throws IOException { final ByteArrayOutputStream output = new ByteArrayOutputStream(); copy( input, output, bufferSize ); return output.toByteArray(); } /////////////////////////////////////////////////////////////// // Derived copy methods // Reader -> * /////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// // Reader -> OutputStream /** * Serialize chars from a Reader to bytes on an OutputStream, and flush the * OutputStream. */ public static void copy( final Reader input, final OutputStream output ) throws IOException { copy( input, output, DEFAULT_BUFFER_SIZE ); } /** * Serialize chars from a Reader to bytes on an OutputStream, and flush the * OutputStream. * * @param bufferSize Size of internal buffer to use. */ public static void copy( final Reader input, final OutputStream output, final int bufferSize ) throws IOException { final OutputStreamWriter out = new OutputStreamWriter( output ); copy( input, out, bufferSize ); // NOTE: Unless anyone is planning on rewriting OutputStreamWriter, we have to flush // here. out.flush(); } /////////////////////////////////////////////////////////////// // Reader -> String /** * Get the contents of a Reader as a String. */ public static String toString( final Reader input ) throws IOException { return toString( input, DEFAULT_BUFFER_SIZE ); } /** * Get the contents of a Reader as a String. * * @param bufferSize Size of internal buffer to use. */ public static String toString( final Reader input, final int bufferSize ) throws IOException { final StringWriter sw = new StringWriter(); copy( input, sw, bufferSize ); return sw.toString(); } /////////////////////////////////////////////////////////////// // Reader -> byte[] /** * Get the contents of a Reader as a byte[]. */ public static byte[] toByteArray( final Reader input ) throws IOException { return toByteArray( input, DEFAULT_BUFFER_SIZE ); } /** * Get the contents of a Reader as a byte[]. * * @param bufferSize Size of internal buffer to use. */ public static byte[] toByteArray( final Reader input, final int bufferSize ) throws IOException { ByteArrayOutputStream output = new ByteArrayOutputStream(); copy( input, output, bufferSize ); return output.toByteArray(); } /////////////////////////////////////////////////////////////// // Derived copy methods // String -> * /////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// // String -> OutputStream /** * Serialize chars from a String to bytes on an OutputStream, and flush the * OutputStream. */ public static void copy( final String input, final OutputStream output ) throws IOException { copy( input, output, DEFAULT_BUFFER_SIZE ); } /** * Serialize chars from a String to bytes on an OutputStream, and flush the * OutputStream. * * @param bufferSize Size of internal buffer to use. */ public static void copy( final String input, final OutputStream output, final int bufferSize ) throws IOException { final StringReader in = new StringReader( input ); final OutputStreamWriter out = new OutputStreamWriter( output ); copy( in, out, bufferSize ); // NOTE: Unless anyone is planning on rewriting OutputStreamWriter, we have to flush // here. out.flush(); } /////////////////////////////////////////////////////////////// // String -> Writer /** * Copy chars from a String to a Writer. */ public static void copy( final String input, final Writer output ) throws IOException { output.write( input ); } /** * Copy bytes from an InputStream to an OutputStream, with buffering. This is equivalent * to passing a {@link java.io.BufferedInputStream} and {@link java.io.BufferedOutputStream} to * {@link #copy(InputStream, OutputStream)}, and flushing the output stream afterwards. The streams are not closed * after the copy. * * @deprecated Buffering streams is actively harmful! See the class description as to why. Use * {@link #copy(InputStream, OutputStream)} instead. */ public static void bufferedCopy( final InputStream input, final OutputStream output ) throws IOException { final BufferedInputStream in = new BufferedInputStream( input ); final BufferedOutputStream out = new BufferedOutputStream( output ); copy( in, out ); out.flush(); } /////////////////////////////////////////////////////////////// // String -> byte[] /** * Get the contents of a String as a byte[]. */ public static byte[] toByteArray( final String input ) throws IOException { return toByteArray( input, DEFAULT_BUFFER_SIZE ); } /** * Get the contents of a String as a byte[]. * * @param bufferSize Size of internal buffer to use. */ public static byte[] toByteArray( final String input, final int bufferSize ) throws IOException { ByteArrayOutputStream output = new ByteArrayOutputStream(); copy( input, output, bufferSize ); return output.toByteArray(); } /////////////////////////////////////////////////////////////// // Derived copy methods // byte[] -> * /////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// // byte[] -> Writer /** * Copy and convert bytes from a byte[] to chars on a Writer. The platform's default * encoding is used for the byte-to-char conversion. */ public static void copy( final byte[] input, final Writer output ) throws IOException { copy( input, output, DEFAULT_BUFFER_SIZE ); } /** * Copy and convert bytes from a byte[] to chars on a Writer. The platform's default * encoding is used for the byte-to-char conversion. * * @param bufferSize Size of internal buffer to use. */ public static void copy( final byte[] input, final Writer output, final int bufferSize ) throws IOException { final ByteArrayInputStream in = new ByteArrayInputStream( input ); copy( in, output, bufferSize ); } /** * Copy and convert bytes from a byte[] to chars on a Writer, using the specified * encoding. * * @param encoding The name of a supported character encoding. See the * IANA Charset Registry for a list of valid * encoding types. */ public static void copy( final byte[] input, final Writer output, final String encoding ) throws IOException { final ByteArrayInputStream in = new ByteArrayInputStream( input ); copy( in, output, encoding ); } /** * Copy and convert bytes from a byte[] to chars on a Writer, using the specified * encoding. * * @param encoding The name of a supported character encoding. See the * IANA Charset Registry for a list of valid * encoding types. * @param bufferSize Size of internal buffer to use. */ public static void copy( final byte[] input, final Writer output, final String encoding, final int bufferSize ) throws IOException { final ByteArrayInputStream in = new ByteArrayInputStream( input ); copy( in, output, encoding, bufferSize ); } /////////////////////////////////////////////////////////////// // byte[] -> String /** * Get the contents of a byte[] as a String. The platform's default encoding is used for the * byte-to-char conversion. */ public static String toString( final byte[] input ) throws IOException { return toString( input, DEFAULT_BUFFER_SIZE ); } /** * Get the contents of a byte[] as a String. The platform's default encoding is used for the * byte-to-char conversion. * * @param bufferSize Size of internal buffer to use. */ public static String toString( final byte[] input, final int bufferSize ) throws IOException { final StringWriter sw = new StringWriter(); copy( input, sw, bufferSize ); return sw.toString(); } /** * Get the contents of a byte[] as a String. * * @param encoding The name of a supported character encoding. See the * IANA Charset Registry for a list of valid * encoding types. */ public static String toString( final byte[] input, final String encoding ) throws IOException { return toString( input, encoding, DEFAULT_BUFFER_SIZE ); } /** * Get the contents of a byte[] as a String. * * @param encoding The name of a supported character encoding. See the * IANA Charset Registry for a list of valid * encoding types. * @param bufferSize Size of internal buffer to use. */ public static String toString( final byte[] input, final String encoding, final int bufferSize ) throws IOException { final StringWriter sw = new StringWriter(); copy( input, sw, encoding, bufferSize ); return sw.toString(); } /////////////////////////////////////////////////////////////// // byte[] -> OutputStream /** * Copy bytes from a byte[] to an OutputStream. */ public static void copy( final byte[] input, final OutputStream output ) throws IOException { copy( input, output, DEFAULT_BUFFER_SIZE ); } /** * Copy bytes from a byte[] to an OutputStream. * * @param bufferSize Size of internal buffer to use. */ public static void copy( final byte[] input, final OutputStream output, final int bufferSize ) throws IOException { output.write( input ); } /** * Compare the contents of two Streams to determine if they are equal or not. * * @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 */ public static boolean contentEquals( final InputStream input1, final InputStream input2 ) throws IOException { final InputStream bufferedInput1 = new BufferedInputStream( input1 ); final InputStream bufferedInput2 = new BufferedInputStream( input2 ); int ch = bufferedInput1.read(); while ( 0 <= ch ) { final int ch2 = bufferedInput2.read(); if ( ch != ch2 ) { return false; } ch = bufferedInput1.read(); } final int ch2 = bufferedInput2.read(); if ( 0 <= ch2 ) { return false; } else { return true; } } // ---------------------------------------------------------------------- // closeXXX() // ---------------------------------------------------------------------- /** * Closes the input stream. The input stream can be null and any IOException's will be swallowed. * * @param inputStream The stream to close. */ public static void close( InputStream inputStream ) { if ( inputStream == null ) { return; } try { inputStream.close(); } catch ( IOException ex ) { // ignore } } /** * Closes a channel. Channel can be null and any IOException's will be swallowed. * * @param channel The stream to close. */ public static void close( Channel channel ) { if ( channel == null ) { return; } try { channel.close(); } catch ( IOException ex ) { // ignore } } /** * Closes the output stream. The output stream can be null and any IOException's will be swallowed. * * @param outputStream The stream to close. */ public static void close( OutputStream outputStream ) { if ( outputStream == null ) { return; } try { outputStream.close(); } catch ( IOException ex ) { // ignore } } /** * Closes the reader. The reader can be null and any IOException's will be swallowed. * * @param reader The reader to close. */ public static void close( Reader reader ) { if ( reader == null ) { return; } try { reader.close(); } catch ( IOException ex ) { // ignore } } /** * Closes the writer. The writer can be null and any IOException's will be swallowed. * * @param writer The writer to close. */ public static void close( Writer writer ) { if ( writer == null ) { return; } try { writer.close(); } catch ( IOException ex ) { // ignore } } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy