用apache的工具类FileUtils将文件转换成字节流

         昨天在做一个将获取到的文件转换成字节流的工作，查了一下都是自己用流写的代码，然而同事告诉我说有一个专门的工具类 ---- apache的commons包下的FileUtils类，里面有跟多跟流有关的代码。所以还是要多看多记一些专门的工具类。

org.apache.commons.io.FileUtils源码：

package org.apache.commons.io;
 
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.math.BigInteger;
import java.net.URI;
import java.net.URL;
import java.net.URLConnection;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.zip.CRC32;
import java.util.zip.CheckedInputStream;
import java.util.zip.Checksum;
import org.apache.commons.io.filefilter.DirectoryFileFilter;
import org.apache.commons.io.filefilter.FalseFileFilter;
import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.io.filefilter.IOFileFilter;
import org.apache.commons.io.filefilter.SuffixFileFilter;
import org.apache.commons.io.filefilter.TrueFileFilter;
import org.apache.commons.io.output.NullOutputStream;
 
public class FileUtils
{
  public static final long ONE_KB = 1024L;
  public static final BigInteger ONE_KB_BI = BigInteger.valueOf(1024L);
  public static final long ONE_MB = 1048576L;
  public static final BigInteger ONE_MB_BI = ONE_KB_BI.multiply(ONE_KB_BI);
  private static final long FILE_COPY_BUFFER_SIZE = 31457280L;
  public static final long ONE_GB = 1073741824L;
  public static final BigInteger ONE_GB_BI = ONE_KB_BI.multiply(ONE_MB_BI);
  public static final long ONE_TB = 1099511627776L;
  public static final BigInteger ONE_TB_BI = ONE_KB_BI.multiply(ONE_GB_BI);
  public static final long ONE_PB = 1125899906842624L;
  public static final BigInteger ONE_PB_BI = ONE_KB_BI.multiply(ONE_TB_BI);
  public static final long ONE_EB = 1152921504606846976L;
  public static final BigInteger ONE_EB_BI = ONE_KB_BI.multiply(ONE_PB_BI);
  public static final BigInteger ONE_ZB = BigInteger.valueOf(1024L).multiply(BigInteger.valueOf(1152921504606846976L));
  public static final BigInteger ONE_YB = ONE_KB_BI.multiply(ONE_ZB);
  public static final File[] EMPTY_FILE_ARRAY = new File[0];
  private static final Charset UTF8 = Charset.forName("UTF-8");
 
  public static File getFile(File directory, String[] names)
  {
    if (directory == null)
      throw new NullPointerException("directorydirectory must not be null");
 
    if (names == null)
      throw new NullPointerException("names must not be null");
 
    File file = directory;
    String[] arr$ = names; int len$ = arr$.length; for (int i$ = 0; i$ < len$; ++i$) { String name = arr$[i$];
      file = new File(file, name);
    }
    return file;
  }
 
  public static File getFile(String[] names)
  {
    if (names == null)
      throw new NullPointerException("names must not be null");
 
    File file = null;
    String[] arr$ = names; int len$ = arr$.length; for (int i$ = 0; i$ < len$; ++i$) { String name = arr$[i$];
      if (file == null)
        file = new File(name);
      else
        file = new File(file, name);
    }
 
    return file;
  }
 
  public static String getTempDirectoryPath()
  {
    return System.getProperty("java.io.tmpdir");
  }
 
  public static File getTempDirectory()
  {
    return new File(getTempDirectoryPath());
  }
 
  public static String getUserDirectoryPath()
  {
    return System.getProperty("user.home");
  }
 
  public static File getUserDirectory()
  {
    return new File(getUserDirectoryPath());
  }
 
  public static FileInputStream openInputStream(File file)
    throws IOException
  {
    if (file.exists()) {
      if (file.isDirectory())
        throw new IOException("File '" + file + "' exists but is a directory");
 
      if (file.canRead()) break label117;
      throw new IOException("File '" + file + "' cannot be read");
    }
 
    throw new FileNotFoundException("File '" + file + "' does not exist");
 
    label117: return new FileInputStream(file);
  }
 
  public static FileOutputStream openOutputStream(File file)
    throws IOException
  {
    return openOutputStream(file, false);
  }
 
  public static FileOutputStream openOutputStream(File file, boolean append)
    throws IOException
  {
    if (file.exists()) {
      if (file.isDirectory())
        throw new IOException("File '" + file + "' exists but is a directory");
 
      if (file.canWrite()) break label140;
      throw new IOException("File '" + file + "' cannot be written to");
    }
 
    File parent = file.getParentFile();
    if ((parent != null) && 
      (!(parent.mkdirs())) && (!(parent.isDirectory()))) {
      throw new IOException("Directory '" + parent + "' could not be created");
    }
 
    label140: return new FileOutputStream(file, append);
  }
 
  public static String byteCountToDisplaySize(BigInteger size)
  {
    String displaySize;
    if (size.divide(ONE_EB_BI).compareTo(BigInteger.ZERO) > 0)
      displaySize = String.valueOf(size.divide(ONE_EB_BI)) + " EB";
    else if (size.divide(ONE_PB_BI).compareTo(BigInteger.ZERO) > 0)
      displaySize = String.valueOf(size.divide(ONE_PB_BI)) + " PB";
    else if (size.divide(ONE_TB_BI).compareTo(BigInteger.ZERO) > 0)
      displaySize = String.valueOf(size.divide(ONE_TB_BI)) + " TB";
    else if (size.divide(ONE_GB_BI).compareTo(BigInteger.ZERO) > 0)
      displaySize = String.valueOf(size.divide(ONE_GB_BI)) + " GB";
    else if (size.divide(ONE_MB_BI).compareTo(BigInteger.ZERO) > 0)
      displaySize = String.valueOf(size.divide(ONE_MB_BI)) + " MB";
    else if (size.divide(ONE_KB_BI).compareTo(BigInteger.ZERO) > 0)
      displaySize = String.valueOf(size.divide(ONE_KB_BI)) + " KB";
    else
      displaySize = String.valueOf(size) + " bytes";
 
    return displaySize;
  }
 
  public static String byteCountToDisplaySize(long size)
  {
    return byteCountToDisplaySize(BigInteger.valueOf(size));
  }
 
  public static void touch(File file)
    throws IOException
  {
    if (!(file.exists())) {
      OutputStream out = openOutputStream(file);
      IOUtils.closeQuietly(out);
    }
    boolean success = file.setLastModified(System.currentTimeMillis());
    if (!(success))
      throw new IOException("Unable to set the last modification time for " + file);
  }
 
  public static File[] convertFileCollectionToFileArray(Collection<File> files)
  {
    return ((File[])files.toArray(new File[files.size()]));
  }
 
  private static void innerListFiles(Collection<File> files, File directory, IOFileFilter filter, boolean includeSubDirectories)
  {
    File[] arr$;
    int i$;
    File[] found = directory.listFiles(filter);
 
    if (found != null) {
      arr$ = found; int len$ = arr$.length; for (i$ = 0; i$ < len$; ++i$) { File file = arr$[i$];
        if (file.isDirectory()) {
          if (includeSubDirectories)
            files.add(file);
 
          innerListFiles(files, file, filter, includeSubDirectories);
        } else {
          files.add(file);
        }
      }
    }
  }
 
  public static Collection<File> listFiles(File directory, IOFileFilter fileFilter, IOFileFilter dirFilter)
  {
    validateListFilesParameters(directory, fileFilter);
 
    IOFileFilter effFileFilter = setUpEffectiveFileFilter(fileFilter);
    IOFileFilter effDirFilter = setUpEffectiveDirFilter(dirFilter);
 
    Collection files = new LinkedList();
    innerListFiles(files, directory, FileFilterUtils.or(new IOFileFilter[] { effFileFilter, effDirFilter }), false);
 
    return files;
  }
 
  private static void validateListFilesParameters(File directory, IOFileFilter fileFilter)
  {
    if (!(directory.isDirectory()))
      throw new IllegalArgumentException("Parameter 'directory' is not a directory");
 
    if (fileFilter == null)
      throw new NullPointerException("Parameter 'fileFilter' is null");
  }
 
  private static IOFileFilter setUpEffectiveFileFilter(IOFileFilter fileFilter)
  {
    return FileFilterUtils.and(new IOFileFilter[] { fileFilter, FileFilterUtils.notFileFilter(DirectoryFileFilter.INSTANCE) });
  }
 
  private static IOFileFilter setUpEffectiveDirFilter(IOFileFilter dirFilter)
  {
    return (