Class IoUtils

    • Field Detail

      • EMPTY_OPEN_OPTIONS

        public static final OpenOption[] EMPTY_OPEN_OPTIONS
      • EMPTY_COPY_OPTIONS

        public static final CopyOption[] EMPTY_COPY_OPTIONS
      • EMPTY_LINK_OPTIONS

        public static final LinkOption[] EMPTY_LINK_OPTIONS
      • EMPTY_FILE_ATTRIBUTES

        public static final FileAttribute<?>[] EMPTY_FILE_ATTRIBUTES
      • WINDOWS_EXECUTABLE_EXTENSIONS

        public static final List<String> WINDOWS_EXECUTABLE_EXTENSIONS
      • DEFAULT_COPY_SIZE

        public static final int DEFAULT_COPY_SIZE
        Size of preferred work buffer when reading / writing data to / from streams
        See Also:
        Constant Field Values
      • EOL

        public static final String EOL
        The local O/S line separator
    • Method Detail

      • getEOLBytes

        public static byte[] getEOLBytes()
        Returns:
        The local platform line separator bytes as UTF-8. Note: each call returns a new instance in order to avoid inadvertent changes in shared objects
        See Also:
        EOL
      • getLinkOptions

        public static LinkOption[] getLinkOptions​(boolean followLinks)
      • closeQuietly

        public static IOException closeQuietly​(Closeable... closeables)
        Closes a bunch of resources suppressing any IOExceptions their Closeable.close() method may have thrown
        Parameters:
        closeables - The Closeables to close
        Returns:
        The first IOException that occurred during closing of a resource - null if not exception. If more than one exception occurred, they are added as suppressed exceptions to the first one
        See Also:
        Throwable.getSuppressed()
      • closeQuietly

        public static IOException closeQuietly​(Closeable c)
        Closes the specified Closeable resource
        Parameters:
        c - The resource to close - ignored if null
        Returns:
        The thrown IOException when close() was called - null if no exception was thrown (or no resource to close to begin with)
      • isWindowsExecutable

        public static boolean isWindowsExecutable​(String fileName)
        Parameters:
        fileName - The file name to be evaluated - ignored if null/empty
        Returns:
        true if the file ends in one of the WINDOWS_EXECUTABLE_EXTENSIONS
      • getPermissionsFromFile

        public static Set<PosixFilePermission> getPermissionsFromFile​(File f)
        Parameters:
        f - The File to be checked
        Returns:
        A Set of PosixFilePermissions based on whether the file is readable/writable/executable. If so, then all the relevant permissions are set (i.e., owner, group and others)
      • isExecutable

        public static boolean isExecutable​(File f)
      • setPermissionsToFile

        public static void setPermissionsToFile​(File f,
                                                Collection<PosixFilePermission> perms)
        Parameters:
        f - The File
        perms - A Collection of PosixFilePermissions to set on it. Note: the file is set to readable/writable/executable not only by the owner if any of relevant the owner/group/others permission is set
      • checkFileExists

        public static Boolean checkFileExists​(Path path,
                                              LinkOption... options)

        Checks if a file exists - Note: according to the Java tutorial - Checking a File or Directory:

         The methods in the Path class are syntactic, meaning that they operate
         on the Path instance. But eventually you must access the file system
         to verify that a particular Path exists, or does not exist. You can do
         so with the exists(Path, LinkOption...) and the notExists(Path, LinkOption...)
         methods. Note that !Files.exists(path) is not equivalent to Files.notExists(path).
         When you are testing a file's existence, three results are possible:
        
         - The file is verified to exist.
         - The file is verified to not exist.
         - The file's status is unknown.
        
         This result can occur when the program does not have access to the file.
         If both exists and notExists return false, the existence of the file cannot
         be verified.
         
        Parameters:
        path - The Path to be tested
        options - The LinkOptions to use
        Returns:
        Boolean.TRUE/Boolean.FALSE or null according to the file status as explained above
      • readFully

        public static void readFully​(InputStream input,
                                     byte[] buffer)
                              throws IOException
        Read the requested number of bytes or fail if there are not enough left.
        Parameters:
        input - where to read input from
        buffer - destination
        Throws:
        IOException - if there is a problem reading the file
        EOFException - if the number of bytes read was incorrect
      • readFully

        public static void readFully​(InputStream input,
                                     byte[] buffer,
                                     int offset,
                                     int length)
                              throws IOException
        Read the requested number of bytes or fail if there are not enough left.
        Parameters:
        input - where to read input from
        buffer - destination
        offset - initial offset into buffer
        length - length to read, must be ≥ 0
        Throws:
        IOException - if there is a problem reading the file
        EOFException - if the number of bytes read was incorrect
      • read

        public static int read​(InputStream input,
                               byte[] buffer)
                        throws IOException
        Read as many bytes as possible until EOF or achieved required length
        Parameters:
        input - where to read input from
        buffer - destination
        Returns:
        actual length read; may be less than requested if EOF was reached
        Throws:
        IOException - if a read error occurs
      • read

        public static int read​(InputStream input,
                               byte[] buffer,
                               int offset,
                               int length)
                        throws IOException
        Read as many bytes as possible until EOF or achieved required length
        Parameters:
        input - where to read input from
        buffer - destination
        offset - initial offset into buffer
        length - length to read - ignored if non-positive
        Returns:
        actual length read; may be less than requested if EOF was reached
        Throws:
        IOException - if a read error occurs
      • ensureDirectory

        public static Path ensureDirectory​(Path path,
                                           LinkOption... options)
        Parameters:
        path - The Path to check
        options - The LinkOptions to use when checking if path is a directory
        Returns:
        The same input path if it is a directory
        Throws:
        UnsupportedOperationException - if input path not a directory
      • followLinks

        public static boolean followLinks​(LinkOption... options)
        Parameters:
        options - The LinkOptions - OK if null/empty
        Returns:
        true if the link options are null/empty or do not contain LinkOption.NOFOLLOW_LINKS, false otherwise (i.e., the array is not empty and contains the special value)
      • appendPathComponent

        public static String appendPathComponent​(String prefix,
                                                 String component)
      • readAllLines

        public static List<String> readAllLines​(BufferedReader reader,
                                                int lineCountHint)
                                         throws IOException
        Reads all lines until no more available
        Parameters:
        reader - The BufferedReader to read all lines
        lineCountHint - A hint as to the expected number of lines - non-positive means unknown - in which case some initial default value will be used to initialize the list used to accumulate the lines.
        Returns:
        The List of lines in the same order as it was read
        Throws:
        IOException - If failed to read the lines