content: package com.taobao.arthas.core.util;
  
  /**
   * Copied from {@link org.apache.commons.io.IOUtils}
   * @author ralf0131 2016-12-28 11:41.
   */
  
  import java.io.BufferedReader;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStream;
  
  public class IOUtils {
  
      private static final int EOF = -1;
  
      /**
       * The default buffer size ({@value}) to use for
       * {@link #copyLarge(InputStream, OutputStream)}
       */
      private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
  
      /**
       * 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();
      }
  
  
      /**
       * 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, or -1 if &gt; Integer.MAX_VALUE
       * @throws NullPointerException if the input or output is null
       * @throws IOException if an I/O error occurs
       * @since 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>.
       * <p>
       * The buffer size is given by {@link #DEFAULT_BUFFER_SIZE}.
       *
       * @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 1.3
       */
      public static long copyLarge(InputStream input, OutputStream output)
              throws IOException {
          return copyLarge(input, output, new byte[DEFAULT_BUFFER_SIZE]);
      }
  
      /**
       * Copy bytes from a large (over 2GB) <code>InputStream</code> to an
       * <code>OutputStream</code>.
       * <p>
       * This method uses the provided buffer, so there is no need to use a
       * <code>BufferedInputStream</code>.
       * <p>
       *
       * @param input  the <code>InputStream</code> to read from
       * @param output  the <code>OutputStream</code> to write to
       * @param buffer the buffer to use for the copy
       * @return the number of bytes copied
       * @throws NullPointerException if the input or output is null
       * @throws IOException if an I/O error occurs
       * @since 2.2
       */
      public static long copyLarge(InputStream input, OutputStream output, byte[] buffer)
              throws IOException {
          long count = 0;
          int n = 0;
          while (EOF != (n = input.read(buffer))) {
              output.write(buffer, 0, n);
              count += n;
          }
          return count;
      }
  
      /**
       * 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 {
          BufferedReader br = null;
          try {
              StringBuilder sb = new StringBuilder();
              br = new BufferedReader(new InputStreamReader(input));
              String line;
              while ((line = br.readLine()) != null) {
                  sb.append(line).append("\n");
              }
              return sb.toString();
          } finally {
              if (br != null) {
                  try {
                      br.close();
                  } catch (IOException e) {
                      // ignore
                  }
              }
          }
      }
  
  
  }
  