Java tutorial
/* * 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 com.aoyetech.fee.commons.utils; import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.CharArrayWriter; import java.io.Closeable; 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.nio.charset.Charset; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.List; /** * modify from common-io * * @author Peter Donald * @author Jeff Turner * @author Matthew Hawthorne * @author Stephen Colebourne * @author Gareth Davis * @author Ian Springer * @author Niall Pemberton * @author Sandy McArthur * @author <a href=mailto://wq163@163.com>jenwang</a> * @since 2012-12-5 ?11:54:39 * @see org.apache.commons.io.IOUtils **/ 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 final StringWriter buf = new StringWriter(4); final 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(); } //----------------------------------------------------------------------- public static void closeQuietly(final Closeable closeable) { try { if (closeable != null) { closeable.close(); } } catch (final 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(final InputStream input) throws IOException { final 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(final Reader input) throws IOException { final 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(final Reader input, final String encoding) throws IOException { final 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()} */ @Deprecated public static byte[] toByteArray(final 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(final InputStream is) throws IOException { final 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(final InputStream is, final String encoding) throws IOException { final 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(final Reader input) throws IOException { final 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(final InputStream input) throws IOException { final 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(final InputStream input, final String encoding) throws IOException { final 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(final Reader input) throws IOException { final StringWriter sw = new StringWriter(); copy(input, sw); return sw.toString(); } // 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(final InputStream input) throws IOException { final 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(final InputStream input, final String encoding) throws IOException { if (encoding == null) { return readLines(input); } else { final 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(final Reader input) throws IOException { final BufferedReader reader = new BufferedReader(input); final List<String> list = new ArrayList<String>(); String line = reader.readLine(); while (line != null) { list.add(line); line = reader.readLine(); } return list; } //----------------------------------------------------------------------- /** * 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(final String input) { final 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(final String input, final String encoding) throws IOException { final 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(final byte[] data, final 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(final byte[] data, final 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(final byte[] data, final Writer output, final 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(final char[] data, final 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(final char[] data, final 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(final char[] data, final OutputStream output, final 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(final String data, final 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(final String data, final 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(final String data, final OutputStream output, final 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(final StringBuffer data, final 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(final StringBuffer data, final 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(final StringBuffer data, final OutputStream output, final String encoding) throws IOException { if (data != null) { if (encoding == null) { write(data, output); } else { output.write(data.toString().getBytes(encoding)); } } } public static void write(final String data, final OutputStream output, final Charset encoding) throws IOException { if (data != null) { output.write(data.getBytes(toCharset(encoding))); } } public static Charset toCharset(final Charset charset) { return charset == null ? Charset.defaultCharset() : charset; } public static Charset toCharset(final String charset) { return charset == null ? Charset.defaultCharset() : Charset.forName(charset); } // 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(final Collection<?> lines, String lineEnding, final OutputStream output) throws IOException { if (lines == null) { return; } if (lineEnding == null) { lineEnding = LINE_SEPARATOR; } for (final Iterator<?> it = lines.iterator(); it.hasNext();) { final 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(final Collection<?> lines, String lineEnding, final OutputStream output, final String encoding) throws IOException { if (encoding == null) { writeLines(lines, lineEnding, output); } else { if (lines == null) { return; } if (lineEnding == null) { lineEnding = LINE_SEPARATOR; } for (final Iterator<?> it = lines.iterator(); it.hasNext();) { final 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(final Collection<?> lines, String lineEnding, final Writer writer) throws IOException { if (lines == null) { return; } if (lineEnding == null) { lineEnding = LINE_SEPARATOR; } for (final Iterator<?> it = lines.iterator(); it.hasNext();) { final 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(final InputStream input, final OutputStream output) throws IOException { final 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(final InputStream input, final OutputStream output) throws IOException { final 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(final InputStream input, final Writer output) throws IOException { final 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(final InputStream input, final Writer output, final String encoding) throws IOException { if (encoding == null) { copy(input, output); } else { final 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(final Reader input, final Writer output) throws IOException { final 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(final Reader input, final Writer output) throws IOException { final 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(final Reader input, final OutputStream output) throws IOException { final 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(final Reader input, final OutputStream output, final String encoding) throws IOException { if (encoding == null) { copy(input, output); } else { final 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) { final int ch2 = input2.read(); if (ch != ch2) { return false; } ch = input1.read(); } final 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) { final int ch2 = input2.read(); if (ch != ch2) { return false; } ch = input1.read(); } final int ch2 = input2.read(); return (ch2 == -1); } }