FileUtil (File System API)

java.lang.Object
- org.openide.filesystems.FileUtil

```
public final class FileUtil
extends Object
```
Common utilities for handling files. This is a dummy class; all methods are static.

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static void`	`addFileChangeListener(FileChangeListener fcl)` Registers `listener` so that it will receive `FileEvent`s from `FileSystem`s providing instances of `FileObject` convertible to `java.io.File`.
`static void`	`addFileChangeListener(FileChangeListener listener, File path)` Adds a listener to changes in a given path.
`static void`	`addRecursiveListener(FileChangeListener listener, File path)` Works like `addRecursiveListener(listener, path, null, null)`.
`static void`	`addRecursiveListener(FileChangeListener listener, File path, Callable<Boolean> stop)` Works like `addRecursiveListener(listener, path, null, stop)`.
`static void`	`addRecursiveListener(FileChangeListener listener, File path, FileFilter recurseInto, Callable<Boolean> stop)` Adds a listener to changes under given path.
`static boolean`	`affectsOrder(FileAttributeEvent event)` Checks whether a change in a given file attribute would affect the result of `FileUtil.getOrder(java.util.Collection<org.openide.filesystems.FileObject>, boolean)`.
`static File`	`archiveOrDirForURL(URL entry)` Convert a classpath-type URL to a corresponding file.
`static void`	`copy(InputStream is, OutputStream os)` Copies stream of files.
`static void`	`copyAttributes(FileObject source, FileObject dest)` Copies attributes from one file to another.
`static void`	`copyAttributes(FileObject source, FileObject dest, java.util.function.BiFunction<String,Object,Object> attrTransformer)` Copies attributes from one file to another.
`static FileObject`	`copyFile(FileObject source, FileObject destFolder, String newName)` Copies file to the selected folder.
`static FileObject`	`copyFile(FileObject source, FileObject destFolder, String newName, String newExt)` Copies file to the selected folder.
`static FileObject`	`createData(File data)` Returns FileObject for a data file.
`static FileObject`	`createData(FileObject folder, String name)` Returns a data file on given filesystem if such a data file exists.
`static FileObject`	`createFolder(File folder)` Returns FileObject for a folder.
`static FileObject`	`createFolder(FileObject folder, String name)` Returns a folder on given filesystem if such a folder exists.
`static FileSystem`	`createMemoryFileSystem()` Factory method that creates an empty implementation of a filesystem that completely resides in a memory.
`static java.util.function.BiFunction<String,Object,Object>`	`defaultAttributesTransformer()` Default attribute transformer for `FileUtil.copyAttributes(org.openide.filesystems.FileObject, org.openide.filesystems.FileObject, java.util.function.BiFunction)` that skips common transient attributes defined or used by the Platform.
`static void`	`extractJar(FileObject fo, InputStream is)` Deprecated. Use of XML filesystem layers generally obsoletes this method. For tests, use `org.openide.util.test.TestFileUtils#unpackZipFile`.
`static FileObject`	`findBrother(FileObject fo, String ext)` Finds brother file with same base name but different extension.
`static String`	`findFreeFileName(FileObject folder, String name, String ext)` Finds an unused file name similar to that requested in the same folder.
`static String`	`findFreeFolderName(FileObject folder, String name)` Finds an unused folder name similar to that requested in the same parent folder.
`static FileObject[]`	`fromFile(File file)` Deprecated. Use `FileUtil.toFileObject(java.io.File)` instead.
`static FileObject`	`getArchiveFile(FileObject fo)` Returns a FileObject representing an archive file containing the FileObject given by the parameter.
`static URL`	`getArchiveFile(URL url)` Returns the URL of the archive file containing the file referred to by an archive (eg.
`static FileObject`	`getArchiveRoot(FileObject fo)` Returns a FileObject representing the root folder of an archive.
`static URL`	`getArchiveRoot(URL url)` Returns a URL representing the root of an archive.
`static FileObject`	`getConfigFile(String path)` Returns `FileObject` from the NetBeans default (system, configuration) filesystem or `null` if does not exist.
`static <T> T`	`getConfigObject(String path, Class<T> type)` Finds a config object under given path.
`static FileObject`	`getConfigRoot()` Returns the root of the NetBeans default (system, configuration) filesystem.
`static String`	`getExtension(String fileName)` Gets the extension of a specified file name.
`static String`	`getFileDisplayName(FileObject fo)` Get an appropriate display name for a file object.
`static String`	`getMIMEType(FileObject fo)` Resolves MIME type.
`static String`	`getMIMEType(FileObject fo, String... withinMIMETypes)` Resolves MIME type.
`static String`	`getMIMEType(String ext)` Deprecated. use `FileUtil.getMIMEType(FileObject)` or `FileUtil.getMIMEType(FileObject, String[])` as MIME cannot be generally detected by file object extension.
`static List<String>`	`getMIMETypeExtensions(String mimeType)` Returns list of file extensions associated with specified MIME type.
`static List<FileObject>`	`getOrder(Collection<FileObject> children, boolean logWarnings)` Sorts some sibling file objects.
`static String`	`getRelativePath(FileObject folder, FileObject fo)` Gets a relative resource path between folder and fo.
`static FileObject`	`getSystemConfigFile(String path)` Returns `FileObject` from the default filesystem, or `null` if the file does not exist.
`static <T> T`	`getSystemConfigObject(String path, Class<T> type)` Finds a config object under the given path, in system-wide configuration.
`static FileObject`	`getSystemConfigRoot()` Returns the root of the NetBeans default (system, configuration) filesystem.
`static boolean`	`isArchiveArtifact(FileObject fo)` Tests if an file is inside an archive.
`static boolean`	`isArchiveArtifact(URL url)` Tests if an `URL` denotes a file inside an archive.
`static boolean`	`isArchiveFile(FileObject fo)` Tests if a file represents a java archive.
`static boolean`	`isArchiveFile(URL url)` Tests if a URL represents a java archive.
`static boolean`	`isParentOf(FileObject folder, FileObject fo)` Recursively checks whether the file is underneath the folder.
`static boolean`	`isRecursiveSymbolicLink(FileObject fo)` Check whether some FileObject is a recursive symbolic link.
`static boolean`	`isValidFileName(String fileName)` Determines whether the string forms a valid filename (without a path component).
`static FileObject`	`moveFile(FileObject source, FileObject destFolder, String newName)` Moves file to the selected folder.
`static URLStreamHandler`	`nbfsURLStreamHandler()` Deprecated. No longer used.
`static File`	`normalizeFile(File file)` Normalize a file path to a clean form.
`static String`	`normalizePath(String path)` See `FileUtil.normalizeFile(java.io.File)` for details
`static void`	`preventFileChooserSymlinkTraversal(JFileChooser chooser, File currentDirectory)` Deprecated. Just use `JFileChooser.setCurrentDirectory(java.io.File)`. JDK 6 does not have this bug.
`static void`	`refreshAll()` Refreshes all `FileObject` that represent files `File.listRoots()` and their children recursively.
`static void`	`refreshFor(File... files)` Refreshes all necessary filesystems.
`static void`	`removeFileChangeListener(FileChangeListener fcl)` Unregisters `listener` so that it will no longer receive `FileEvent`s from `FileSystem`s providing instances of `FileObject` convertible to `java.io.File`
`static void`	`removeFileChangeListener(FileChangeListener listener, File path)` Removes a listener to changes in a given path.
`static void`	`removeRecursiveListener(FileChangeListener listener, File path)` Removes a listener to changes under given path.
`static void`	`runAtomicAction(FileSystem.AtomicAction atomicCode)` Executes atomic action.
`static void`	`runAtomicAction(Runnable atomicCode)` Executes atomic action.
`static void`	`setMIMEType(String extension, String mimeType)` Registers specified extension to be recognized as specified MIME type.
`static void`	`setOrder(List<FileObject> children)` Imposes an order on some sibling file objects.
`static File`	`toFile(FileObject fo)` Finds appropriate java.io.File to FileObject if possible.
`static FileObject`	`toFileObject(File file)` Converts a disk file to a matching file object.
`static FileObject`	`toFileObject(Path path)` Converts a Path to a FileObject if that is possible.
`static Path`	`toPath(FileObject fo)` Finds appropriate java.nio.file.Path to FileObject if possible.
`static URL`	`urlForArchiveOrDir(File entry)` Convert a file such as would be shown in a classpath entry into a proper folder URL.
`static FileChangeListener`	`weakFileChangeListener(FileChangeListener l, Object source)` Creates a weak implementation of FileChangeListener.
`static FileStatusListener`	`weakFileStatusListener(FileStatusListener l, Object source)` Creates a weak implementation of FileStatusListener.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - refreshFor
```
public static void refreshFor(File... files)
```
    Refreshes all necessary filesystems. Not all instances of FileObject are refreshed but just those that represent passed files and their children recursively.
    
    Parameters:
    
    files -
    
    Since:
    
    7.6
  - refreshAll
```
public static void refreshAll()
```
    Refreshes all FileObject that represent files File.listRoots() and their children recursively.
    
    Since:
    
    7.7
  - addFileChangeListener
```
public static void addFileChangeListener(FileChangeListener fcl)
```
    Registers listener so that it will receive FileEvents from FileSystems providing instances of FileObject convertible to java.io.File.
    
    Parameters:
    
    fcl -
    
    Since:
    
    7.7
    
    See Also:
    
    FileUtil.toFileObject(java.io.File)
  - removeFileChangeListener
```
public static void removeFileChangeListener(FileChangeListener fcl)
```
    Unregisters listener so that it will no longer receive FileEvents from FileSystems providing instances of FileObject convertible to java.io.File
    
    Parameters:
    
    fcl -
    
    Since:
    
    7.7
    
    See Also:
    
    FileUtil.toFileObject(java.io.File)
  - addFileChangeListener
```
public static void addFileChangeListener(FileChangeListener listener,
                                         File path)
```
    Adds a listener to changes in a given path. It permits you to listen to a file which does not yet exist, or continue listening to it after it is deleted and recreated, etc.
    When given path represents a file (path.isDirectory() == false)
    - fileDataCreated event is fired when the file is created
    - fileDeleted event is fired when the file is deleted
    - fileChanged event is fired when the file is modified
    - fileRenamed event is fired when the file is renamed
    - fileAttributeChanged is fired when FileObject's attribute is changed
    When given path represents a folder (path.isDirectory() == true)
    - fileFolderCreated event is fired when the folder is created or a child folder created
    - fileDataCreated event is fired when a child file is created
    - fileDeleted event is fired when the folder is deleted or a child file/folder removed
    - fileChanged event is fired when a child file is modified
    - fileRenamed event is fired when the folder is renamed or a child file/folder is renamed
    - fileAttributeChanged is fired when FileObject's attribute is changed
    Can only add a given [listener, path] pair once. However a listener can listen to any number of paths. Note that listeners are always held weakly - if the listener is collected, it is quietly removed.
    Parameters:
    
    listener - FileChangeListener to listen to changes in path
    
    path - File path to listen to (even not existing)
    
    Since:
    
    org.openide.filesystems 7.20
    
    See Also:
    
    FileObject.addFileChangeListener(org.openide.filesystems.FileChangeListener)
  - removeFileChangeListener
```
public static void removeFileChangeListener(FileChangeListener listener,
                                            File path)
```
    Removes a listener to changes in a given path.
    
    Parameters:
    
    listener - FileChangeListener to be removed
    
    path - File path in which listener was listening
    
    Throws:
    
    IllegalArgumentException - if listener was not listening to given path
    
    Since:
    
    org.openide.filesystems 7.20
    
    See Also:
    
    FileObject.removeFileChangeListener(org.openide.filesystems.FileChangeListener)
  - addRecursiveListener
```
public static void addRecursiveListener(FileChangeListener listener,
                                        File path)
```
    Works like addRecursiveListener(listener, path, null, null).
    
    Parameters:
    
    listener - FileChangeListener to listen to changes in path
    
    path - File path to listen to (even not existing)
    
    Since:
    
    org.openide.filesystems 7.28
  - addRecursiveListener
```
public static void addRecursiveListener(FileChangeListener listener,
                                        File path,
                                        Callable<Boolean> stop)
```
    Works like addRecursiveListener(listener, path, null, stop).
    
    Parameters:
    
    listener - FileChangeListener to listen to changes in path
    
    path - File path to listen to (even not existing)
    
    stop - an interface to interrupt the process of registering the listener. If the call returns true, the process of registering the listener is immediately interrupted
    
    Since:
    
    org.openide.filesystems 7.37
    
    See Also:
    
    FileObject.addRecursiveListener(org.openide.filesystems.FileChangeListener)
  - addRecursiveListener
```
public static void addRecursiveListener(FileChangeListener listener,
                                        File path,
                                        FileFilter recurseInto,
                                        Callable<Boolean> stop)
```
    Adds a listener to changes under given path. It permits you to listen to a file which does not yet exist, or continue listening to it after it is deleted and recreated, etc.
    When given path represents a file (path.isDirectory() == false), this code behaves exactly like FileUtil.addFileChangeListener(org.openide.filesystems.FileChangeListener, java.io.File). Usually the path shall represent a folder (path.isDirectory() == true)
    - fileFolderCreated event is fired when the folder is created or a child folder created
    - fileDataCreated event is fired when a child file is created
    - fileDeleted event is fired when the folder is deleted or a child file/folder removed
    - fileChanged event is fired when a child file is modified
    - fileRenamed event is fired when the folder is renamed or a child file/folder is renamed
    - fileAttributeChanged is fired when FileObject's attribute is changed
    The above events are delivered for changes in all subdirectories (recursively). It is guaranteed that with each change at least one event is generated. For example adding a folder does not notify about content of the folder, hence one event is delivered. Can only add a given [listener, path] pair once. However a listener can listen to any number of paths. Note that listeners are always held weakly - if the listener is collected, it is quietly removed.
    As registering of the listener can take a long time, especially on deep hierarchies, it is possible provide a callback stop. This stop object is guaranteed to be called once per every folder on the default (when masterfs module is included) implemention. If the call to stop.call() returns true, then the registration of next recursive items is interrupted. The listener may or may not get some events from already registered folders.
    Those who provide recurseInto callback can prevent the system to enter, and register operating system level listeners to certain subtrees under the provided path. This does not prevent delivery of changes, if they are made via the filesystem API. External changes however will not be detected.
    Parameters:
    
    listener - FileChangeListener to listen to changes in path
    
    path - File path to listen to (even not existing)
    
    stop - an interface to interrupt the process of registering the listener. If the call returns true, the process of registering the listener is immediately interrupted. null value disables this kind of callback.
    
    recurseInto - a file filter that may return false when a folder should not be traversed into and external changes in it ignored. null recurses into all subfolders
    
    Since:
    
    7.61
  - removeRecursiveListener
```
public static void removeRecursiveListener(FileChangeListener listener,
                                           File path)
```
    Removes a listener to changes under given path.
    
    Parameters:
    
    listener - FileChangeListener to be removed
    
    path - File path in which listener was listening
    
    Throws:
    
    IllegalArgumentException - if listener was not listening to given path
    
    Since:
    
    org.openide.filesystems 7.28
    
    See Also:
    
    FileObject.removeRecursiveListener(org.openide.filesystems.FileChangeListener)
  - runAtomicAction
```
public static final void runAtomicAction(FileSystem.AtomicAction atomicCode)
                                  throws IOException
```
    Executes atomic action. For more info see FileSystem.runAtomicAction(org.openide.filesystems.FileSystem.AtomicAction).
    All events about filesystem changes (related to events on all affected instances of FileSystem) are postponed after the whole atomicCode is executed.
    
    Parameters:
    
    atomicCode - code that is supposed to be run as atomic action. See FileSystem.runAtomicAction(org.openide.filesystems.FileSystem.AtomicAction)
    
    Throws:
    
    IOException
    
    Since:
    
    7.5
  - runAtomicAction
```
public static final void runAtomicAction(Runnable atomicCode)
```
    Executes atomic action. For more info see FileSystem.runAtomicAction(org.openide.filesystems.FileSystem.AtomicAction).
    All events about filesystem changes (related to events on all affected instances of FileSystem) are postponed after the whole atomicCode is executed.
    
    Parameters:
    
    atomicCode - code that is supposed to be run as atomic action. See FileSystem.runAtomicAction(org.openide.filesystems.FileSystem.AtomicAction)
    
    Since:
    
    7.5
  - createFolder
```
public static FileObject createFolder(File folder)
                               throws IOException
```
    Returns FileObject for a folder. If such a folder does not exist then it is created, including any necessary but nonexistent parent folders. Note that if this operation fails it may have succeeded in creating some of the necessary parent folders.
    
    Parameters:
    
    folder - folder to be created
    
    Returns:
    
    FileObject for a folder
    
    Throws:
    
    IOException - if the creation fails
    
    Since:
    
    7.0
  - createData
```
public static FileObject createData(File data)
                             throws IOException
```
    Returns FileObject for a data file. If such a data file does not exist then it is created, including any necessary but nonexistent parent folders. Note that if this operation fails it may have succeeded in creating some of the necessary parent folders.
    
    Parameters:
    
    data - data file to be created
    
    Returns:
    
    FileObject for a data file
    
    Throws:
    
    IOException - if the creation fails
    
    Since:
    
    7.0
  - copy
```
public static void copy(InputStream is,
                        OutputStream os)
                 throws IOException
```
    Copies stream of files.
    Please be aware, that this method doesn't close any of passed streams.
    
    Parameters:
    
    is - input stream
    
    os - output stream
    
    Throws:
    
    IOException
  - createMemoryFileSystem
```
public static FileSystem createMemoryFileSystem()
```
    Factory method that creates an empty implementation of a filesystem that completely resides in a memory.
    To specify the MIME type of a data file without using a MIME resolver, set the mimeType file attribute.
    Since 7.42, a URLMapper is available for files (and folders) in memory filesystems. These URLs are valid only so long as the filesystem has not been garbage-collected, so hold the filesystem (or a file in it) strongly for as long as you expect the URLs to be in play.
    
    Returns:
    
    a blank writable filesystem
    
    Since:
    
    4.43
  - copyFile
```
public static FileObject copyFile(FileObject source,
                                  FileObject destFolder,
                                  String newName,
                                  String newExt)
                           throws IOException
```
    Copies file to the selected folder. This implementation simply copies the file by stream content. Since version 9.32, the file POSIX permissions are copied as well.
    
    Parameters:
    
    source - source file object
    
    destFolder - destination folder
    
    newName - file name (without extension) of destination file
    
    newExt - extension of destination file
    
    Returns:
    
    the created file object in the destination folder
    
    Throws:
    
    IOException - if destFolder is not a folder or does not exist; the destination file already exists; or another critical error occurs during copying
  - copyFile
```
public static FileObject copyFile(FileObject source,
                                  FileObject destFolder,
                                  String newName)
                           throws IOException
```
    Copies file to the selected folder. This implementation simply copies the file by stream content. Since version 9.32, the file POSIX permissions are copied as well. Uses the extension of the source file.
    
    Parameters:
    
    source - source file object
    
    destFolder - destination folder
    
    newName - file name (without extension) of destination file
    
    Returns:
    
    the created file object in the destination folder
    
    Throws:
    
    IOException - if destFolder is not a folder or does not exist; the destination file already exists; or another critical error occurs during copying
  - moveFile
```
public static FileObject moveFile(FileObject source,
                                  FileObject destFolder,
                                  String newName)
                           throws IOException
```
    Moves file to the selected folder. This implementation uses a copy-and-delete mechanism, and automatically uses the necessary lock.
    
    Parameters:
    
    source - source file object
    
    destFolder - destination folder
    
    newName - file name (without extension) of destination file
    
    Returns:
    
    new file object
    
    Throws:
    
    IOException - if either the copy or delete failed
  - createFolder
```
public static FileObject createFolder(FileObject folder,
                                      String name)
                               throws IOException
```
    Returns a folder on given filesystem if such a folder exists. If not then a folder is created, including any necessary but nonexistent parent folders. Note that if this operation fails it may have succeeded in creating some of the necessary parent folders. The name of the new folder can be specified as a multi-component pathname whose components are separated by File.separatorChar or "/" (forward slash).
    
    Parameters:
    
    folder - where the new folder will be placed in
    
    name - name of the new folder
    
    Returns:
    
    the new folder
    
    Throws:
    
    IOException - if the creation fails
  - createData
```
public static FileObject createData(FileObject folder,
                                    String name)
                             throws IOException
```
    Returns a data file on given filesystem if such a data file exists. If not then a data file is created, including any necessary but nonexistent parent folders. Note that if this operation fails it may have succeeded in creating some of the necessary parent folders. The name of data file can be composed as resource name (e. g. org/netbeans/myfolder/mydata ).
    
    Parameters:
    
    folder - to begin with creation at
    
    name - name of data file as a resource
    
    Returns:
    
    the data file for given name
    
    Throws:
    
    IOException - if the creation fails
  - toFile
```
public static File toFile(FileObject fo)
```
    Finds appropriate java.io.File to FileObject if possible. If not possible then null is returned. This is the inverse operation of FileUtil.toFileObject(java.io.File).
    
    Parameters:
    
    fo - FileObject whose corresponding File will be looked for
    
    Returns:
    
    java.io.File or null if no corresponding File exists.
    
    Since:
    
    1.29
  - toPath
```
public static Path toPath(FileObject fo)
```
    Finds appropriate java.nio.file.Path to FileObject if possible. If not possible then null is returned. This is the inverse operation of FileUtil.toFileObject(java.io.File).
    
    Parameters:
    
    fo - FileObject whose corresponding Path will be looked for
    
    Returns:
    
    java.nio.file.Path or null if no corresponding File exists.
    
    Since:
    
    9.32
  - toFileObject
```
public static FileObject toFileObject(File file)
```
    Converts a disk file to a matching file object. This is the inverse operation of FileUtil.toFile(org.openide.filesystems.FileObject).
    If you are running with org.netbeans.modules.masterfs enabled, this method should never return null for a file which exists on disk. For example, to make this method work in unit tests in an Ant-based module project, right-click Unit Test Libraries, Add Unit Test Dependency, check Show Non-API Modules, select Master Filesystem. (Also right-click the new Master Filesystem node, Edit, uncheck Include in Compile Classpath.) To ensure masterfs (or some other module that can handle the conversion) is present put following line into your module manifest:
```
 OpenIDE-Module-Needs: org.openide.filesystems.FileUtil.toFileObject
 
```
    Parameters:
    
    file - a disk file (may or may not exist). This file must be normalized.
    
    Returns:
    
    a corresponding file object, or null if the file does not exist or there is no URLMapper available to convert it
    
    Since:
    
    4.29
  - toFileObject
```
public static FileObject toFileObject(Path path)
```
    Converts a Path to a FileObject if that is possible. It uses the FileUtil.toFileObject(java.io.File) method with path.toFile(). if the conversion is not possible for some reason null is returned.
    
    Parameters:
    
    path - the Path to be converted
    
    Returns:
    
    the FileObject representing the path or null
    
    Since:
    
    9.32
  - fromFile
```
@Deprecated
public static FileObject[] fromFile(File file)
```
    Deprecated. Use FileUtil.toFileObject(java.io.File) instead.
    
    Finds appropriate FileObjects to java.io.File if possible. If not possible then empty array is returned. More FileObjects may correspond to one java.io.File that`s why array is returned.
    
    Parameters:
    
    file - File whose corresponding FileObjects will be looked for. The file has to be "normalized" otherwise IllegalArgumentException is thrown. See FileUtil.normalizeFile(java.io.File) for how to do that.
    
    Returns:
    
    corresponding FileObjects or empty array if no corresponding FileObject exists.
    
    Since:
    
    1.29
  - copyAttributes
```
public static void copyAttributes(FileObject source,
                                  FileObject dest)
                           throws IOException
```
    Copies attributes from one file to another. Note: several special attributes will not be copied, as they should semantically be transient. These include attributes used by the template wizard (but not the template attribute itself).
    
    Parameters:
    
    source - source file object
    
    dest - destination file object
    
    Throws:
    
    IOException - if the copying failed
  - defaultAttributesTransformer
```
public static java.util.function.BiFunction<String,Object,Object> defaultAttributesTransformer()
```
    Default attribute transformer for FileUtil.copyAttributes(org.openide.filesystems.FileObject, org.openide.filesystems.FileObject, java.util.function.BiFunction) that skips common transient attributes defined or used by the Platform. Custom Attribute Transformers should delegate to this instance.
    
    Returns:
    
    default attribute transformer instance.
    
    Since:
    
    9.27
  - copyAttributes
```
public static void copyAttributes(FileObject source,
                                  FileObject dest,
                                  java.util.function.BiFunction<String,Object,Object> attrTransformer)
                           throws IOException
```
    Copies attributes from one file to another. Note: several special attributes will not be copied, as they should semantically be transient. These include attributes used by the template wizard (but not the template attribute itself). If attrTransformer is specified, it is called for each attribute that is about to be copied. The returned value will be written to the target. If attrTransformer returns null, the attribute will be skipped. The Transformer should delegate to FileUtil.defaultAttributesTransformer() to conform to the usual transient attribute conventions - unless it really intends to copy such otherwise transient attributes.
    
    Parameters:
    
    source - source file object
    
    dest - destination file object
    
    attrTransformer - callback to transform or filter attribute values. Can be null.
    
    Throws:
    
    IOException - if the copying failed
    
    Since:
    
    9.27
  - extractJar
```
@Deprecated
public static void extractJar(FileObject fo,
                                          InputStream is)
                                   throws IOException
```
    Deprecated. Use of XML filesystem layers generally obsoletes this method. For tests, use org.openide.util.test.TestFileUtils#unpackZipFile.
    
    Extract jar file into folder represented by file object. If the JAR contains files with name filesystem.attributes, it is assumed that these files has been created by DefaultAttributes implementation and the content of these files is treated as attributes and added to extracted files.
    META-INF/ directories are skipped over.
    
    Parameters:
    
    fo - file object of destination folder
    
    is - input stream of jar file
    
    Throws:
    
    IOException - if the extraction fails
  - getExtension
```
public static String getExtension(String fileName)
```
    Gets the extension of a specified file name. The extension is everything after the last dot.
    
    Parameters:
    
    fileName - name of the file
    
    Returns:
    
    extension of the file (or "" if it had none)
  - findFreeFileName
```
public static String findFreeFileName(FileObject folder,
                                      String name,
                                      String ext)
```
    Finds an unused file name similar to that requested in the same folder. The specified file name is used if that does not yet exist or is isVirtual. Otherwise, the first available name of the form basename_nnn.ext (counting from one) is used.
    Caution: this method does not lock the parent folder to prevent race conditions: i.e. it is possible (though unlikely) that the resulting name will have been created by another thread just as you were about to create the file yourself (if you are, in fact, intending to create it just after this call). Since you cannot currently lock a folder against child creation actions, the safe approach is to use a loop in which a free name is retrieved; an attempt is made to create that file; and upon an IOException during creation, retry the loop up to a few times before giving up.
    
    Parameters:
    
    folder - parent folder
    
    name - preferred base name of file
    
    ext - extension to use (or null)
    
    Returns:
    
    a free file name (without the extension)
  - findFreeFolderName
```
public static String findFreeFolderName(FileObject folder,
                                        String name)
```
    Finds an unused folder name similar to that requested in the same parent folder.
    See caveat for findFreeFileName.
    
    Parameters:
    
    folder - parent folder
    
    name - preferred folder name
    
    Returns:
    
    a free folder name
    
    See Also:
    
    findFreeFileName
  - getRelativePath
```
public static String getRelativePath(FileObject folder,
                                     FileObject fo)
```
    Gets a relative resource path between folder and fo.
    
    Parameters:
    
    folder - root of filesystem or any other folder in folders hierarchy
    
    fo - arbitrary FileObject in folder's tree (including folder itself)
    
    Returns:
    
    relative path between folder and fo. The returned path never starts with a '/'. It never ends with a '/'. Specifically, if folder==fo, returns "". Returns null if fo is not in folder's tree.
    
    Since:
    
    4.16
    
    See Also:
    
    FileUtil.isParentOf(org.openide.filesystems.FileObject, org.openide.filesystems.FileObject)
  - findBrother
```
public static FileObject findBrother(FileObject fo,
                                     String ext)
```
    Finds brother file with same base name but different extension.
    
    Parameters:
    
    fo - the file to find the brother for or null
    
    ext - extension for the brother file
    
    Returns:
    
    a brother file (with the requested extension and the same parent folder as the original) or null if the brother file does not exist or the original file was null
  - getMIMEType
```
@Deprecated
public static String getMIMEType(String ext)
```
    Deprecated. use FileUtil.getMIMEType(FileObject) or FileUtil.getMIMEType(FileObject, String[]) as MIME cannot be generally detected by file object extension.
    
    Obtain MIME type for a well-known extension. If there is a case-sensitive match, that is used, else will fall back to a case-insensitive match.
    
    Parameters:
    
    ext - the extension: "jar", "zip", etc.
    
    Returns:
    
    the MIME type for the extension, or null if the extension is unrecognized
  - getMIMEType
```
public static String getMIMEType(FileObject fo)
```
    Resolves MIME type. Registered resolvers are invoked and used to achieve this goal. Resolvers must subclass MIMEResolver.
    
    Parameters:
    
    fo - whose MIME type should be recognized
    
    Returns:
    
    the MIME type for the FileObject, or null if the FileObject is unrecognized. It may return content/unknown instead of null.
  - getMIMEType
```
public static String getMIMEType(FileObject fo,
                                 String... withinMIMETypes)
```
    Resolves MIME type. Registered resolvers are invoked and used to achieve this goal. Resolvers must subclass MIMEResolver. By default it is possible for the method to return content/unknown instead of null - if you want to avoid such behavior, include null in the list of requested withinMIMETypes - in such case the return value is guaranteed to be one of the values in withinMIMETypes or null.
    Example: Check if some file is Java source file or text file:
    FileUtil.getMIMEType(fo, null, "text/x-java", "text/plain") != null
    
    Parameters:
    
    fo - whose MIME type should be recognized
    
    withinMIMETypes - an array of MIME types. Only resolvers whose MIMEResolver#getMIMETypes() contain one or more of the requested MIME types will be asked if they recognize the file. It is possible for the resulting MIME type to not be a member of this list.
    
    Returns:
    
    the MIME type for the FileObject, or null if the FileObject is unrecognized.
    
    Since:
    
    7.13
  - setMIMEType
```
public static void setMIMEType(String extension,
                               String mimeType)
```
    Registers specified extension to be recognized as specified MIME type. If MIME type parameter is null, it cancels previous registration. Note that you may register a case-sensitive extension if that is relevant (for example *.C for C++) but if you register a lowercase extension it will by default apply to uppercase extensions too on Windows.
    
    Parameters:
    
    extension - the file extension to be registered
    
    mimeType - the MIME type to be registered for the extension or null to deregister
    
    See Also:
    
    FileUtil.getMIMEType(FileObject), FileUtil.getMIMETypeExtensions(String)
  - getMIMETypeExtensions
```
public static List<String> getMIMETypeExtensions(String mimeType)
```
    Returns list of file extensions associated with specified MIME type. In other words files with those extensions are recognized as specified MIME type in NetBeans' filesystem. It never returns null.
    
    Parameters:
    
    mimeType - the MIME type (e.g. image/gif)
    
    Returns:
    
    list of file extensions associated with specified MIME type, never null
    
    Since:
    
    org.openide.filesystems 7.18
    
    See Also:
    
    FileUtil.setMIMEType(String, String)
  - nbfsURLStreamHandler
```
@Deprecated
public static URLStreamHandler nbfsURLStreamHandler()
```
    Deprecated. No longer used.
  - isParentOf
```
public static boolean isParentOf(FileObject folder,
                                 FileObject fo)
```
    Recursively checks whether the file is underneath the folder. It checks whether the file and folder are located on the same filesystem, in such case it checks the parent FileObject of the file recursively until the folder is found or the root of the filesystem is reached.
    Warning: this method will return false in the case that folder == fo.
    
    Parameters:
    
    folder - the root of folders hierarchy to search in
    
    fo - the file to search for
    
    Returns:
    
    true, if fo lies somewhere underneath the folder, false otherwise
    
    Since:
    
    3.16
  - isRecursiveSymbolicLink
```
public static boolean isRecursiveSymbolicLink(FileObject fo)
                                       throws IOException
```
    Check whether some FileObject is a recursive symbolic link.
    
    Parameters:
    
    fo - FileObject to check.
    
    Returns:
    
    True if the FileObject represents a symbolic link referring to a directory that is parent of this FileObject, false otherwise.
    
    Throws:
    
    IOException - If some I/O problem occurs.
    
    Since:
    
    openide.filesystem/9.4
  - weakFileChangeListener
```
public static FileChangeListener weakFileChangeListener(FileChangeListener l,
                                                        Object source)
```
    Creates a weak implementation of FileChangeListener.
    
    Parameters:
    
    l - the listener to delegate to
    
    source - the source that the listener should detach from when listener l is freed, can be null
    
    Returns:
    
    a FileChangeListener delegating to l.
    
    Since:
    
    4.10
  - weakFileStatusListener
```
public static FileStatusListener weakFileStatusListener(FileStatusListener l,
                                                        Object source)
```
    Creates a weak implementation of FileStatusListener.
    
    Parameters:
    
    l - the listener to delegate to
    
    source - the source that the listener should detach from when listener l is freed, can be null
    
    Returns:
    
    a FileChangeListener delegating to l.
    
    Since:
    
    4.10
  - getFileDisplayName
```
public static String getFileDisplayName(FileObject fo)
```
    Get an appropriate display name for a file object. If the file corresponds to a path on disk, this will be the disk path. Otherwise the name will mention the filesystem name or archive name in case the file comes from archive and relative path. Relative path will be mentioned just in case that passed FileObject isn't root FileObject.isRoot().
    
    Parameters:
    
    fo - a file object
    
    Returns:
    
    a display name indicating where the file is
    
    Since:
    
    4.39
  - normalizePath
```
public static String normalizePath(String path)
```
    See FileUtil.normalizeFile(java.io.File) for details
    
    Parameters:
    
    path - file path to normalize
    
    Returns:
    
    normalized file path
    
    Since:
    
    7.42
  - normalizeFile
```
public static File normalizeFile(File file)
```
    Normalize a file path to a clean form. This method may for example make sure that the returned file uses the natural case on Windows; that old Windows 8.3 filenames are changed to the long form; that relative paths are changed to be absolute; that . and .. sequences are removed; etc. Unlike File.getCanonicalFile() this method will not traverse symbolic links on Unix.
    This method involves some overhead and should not be called frivolously. Generally it should be called on incoming pathnames that are gotten from user input (including filechoosers), configuration files, Ant properties, etc. Internal calculations should not need to renormalize paths since File.listFiles(), File.getParentFile(), etc. will not produce abnormal variants.
    
    Parameters:
    
    file - file to normalize
    
    Returns:
    
    normalized file
    
    Since:
    
    4.48
  - getArchiveRoot
```
public static FileObject getArchiveRoot(FileObject fo)
```
    Returns a FileObject representing the root folder of an archive. Clients may need to first call FileUtil.isArchiveFile(FileObject) to determine if the file object refers to an archive file.
    
    Parameters:
    
    fo - a java archive file, by default ZIP and JAR are supported
    
    Returns:
    
    a virtual archive root folder, or null if the file is not actually an archive
    
    Since:
    
    4.48
  - getArchiveRoot
```
public static URL getArchiveRoot(URL url)
```
    Returns a URL representing the root of an archive. Clients may need to first call FileUtil.isArchiveFile(URL) to determine if the URL refers to an archive file.
    
    Parameters:
    
    url - of a java archive file, by default ZIP and JAR are supported
    
    Returns:
    
    the archive (eg. jar) protocol URL of the root of the archive.
    
    Since:
    
    4.48
  - getArchiveFile
```
public static FileObject getArchiveFile(FileObject fo)
```
    Returns a FileObject representing an archive file containing the FileObject given by the parameter. Remember that any path within the archive is discarded so you may need to check for non-root entries.
    
    Parameters:
    
    fo - a file in an archive filesystem
    
    Returns:
    
    the file corresponding to the archive itself, or null if fo is not an archive entry
    
    Since:
    
    4.48
  - getArchiveFile
```
public static URL getArchiveFile(URL url)
```
    Returns the URL of the archive file containing the file referred to by an archive (eg. jar) protocol URL. Remember that any path within the archive is discarded so you may need to check for non-root entries.
    
    Parameters:
    
    url - a URL
    
    Returns:
    
    the embedded archive URL, or null if the URL is not an archive protocol URL containing !/
    
    Since:
    
    4.48
  - isArchiveFile
```
public static boolean isArchiveFile(FileObject fo)
```
    Tests if a file represents a java archive. By default the JAR or ZIP archives are supported.
    
    Parameters:
    
    fo - the file to be tested
    
    Returns:
    
    true if the file looks like a java archive
    
    Since:
    
    4.48
  - isArchiveFile
```
public static boolean isArchiveFile(URL url)
```
    Tests if a URL represents a java archive. By default the JAR or ZIP archives are supported. If there is no such file object, the test is done by heuristic: any URL with an extension is treated as an archive.
    
    Parameters:
    
    url - a URL to a file
    
    Returns:
    
    true if the URL seems to represent a java archive
    
    Since:
    
    4.48
  - isArchiveArtifact
```
public static boolean isArchiveArtifact(FileObject fo)
```
    Tests if an file is inside an archive.
    
    Parameters:
    
    fo - the file to be tested
    
    Returns:
    
    true if the file is inside an archive
    
    Since:
    
    9.10
  - isArchiveArtifact
```
public static boolean isArchiveArtifact(URL url)
```
    Tests if an URL denotes a file inside an archive.
    
    Parameters:
    
    url - the url to be tested
    
    Returns:
    
    true if the url points inside an archive
    
    Since:
    
    9.10
  - urlForArchiveOrDir
```
public static URL urlForArchiveOrDir(File entry)
```
    Convert a file such as would be shown in a classpath entry into a proper folder URL. If the file looks to represent a directory, a file URL will be created. If it looks to represent a ZIP archive, a jar URL will be created.
    
    Parameters:
    
    entry - a file or directory name
    
    Returns:
    
    an appropriate classpath URL which will always end in a slash (/), or null for an existing file which does not look like a valid archive
    
    Since:
    
    org.openide.filesystems 7.8
  - archiveOrDirForURL
```
public static File archiveOrDirForURL(URL entry)
```
    Convert a classpath-type URL to a corresponding file. If it is a jar URL representing the root folder of a local disk archive, that archive file will be returned. If it is a file URL representing a local disk folder, that folder will be returned.
    
    Parameters:
    
    entry - a classpath entry or similar URL
    
    Returns:
    
    a corresponding file, or null for e.g. a network URL or non-root JAR folder entry
    
    Since:
    
    org.openide.filesystems 7.8
  - preventFileChooserSymlinkTraversal
```
@Deprecated
public static void preventFileChooserSymlinkTraversal(JFileChooser chooser,
                                                                  File currentDirectory)
```
    Deprecated. Just use JFileChooser.setCurrentDirectory(java.io.File). JDK 6 does not have this bug.
    
    Make sure that a JFileChooser does not traverse symlinks on Unix.
    
    Parameters:
    
    chooser - a file chooser
    
    currentDirectory - if not null, a file to set as the current directory using JFileChooser.setCurrentDirectory(java.io.File) without canonicalizing
    
    Since:
    
    org.openide/1 4.42
    
    See Also:
    
    Issue #46459, JRE bug #4906607
  - getOrder
```
public static List<FileObject> getOrder(Collection<FileObject> children,
                                        boolean logWarnings)
                                 throws IllegalArgumentException
```
    Sorts some sibling file objects.
    Normally this is done by looking for numeric file attributes named position on the children; children with a lower position number are placed first. Now-deprecated relative ordering attributes of the form earlier/later may also be used; if the above attribute has a boolean value of true, then the file named earlier will be sorted somewhere (not necessarily directly) before the file named later. Numeric and relative attributes may also be mixed.
    
    The sort is stable at least to the extent that if there is no ordering information whatsoever, the returned list will be in the same order as the incoming collection.
    
    Parameters:
    
    children - zero or more files (or folders); must all have the same FileObject.getParent()
    
    logWarnings - true to log warnings about relative ordering attributes or other semantic problems, false to keep quiet
    
    Returns:
    
    a sorted list of the same children
    
    Throws:
    
    IllegalArgumentException - in case there are duplicates, or nulls, or the files do not have a common parent
    
    Since:
    
    org.openide.filesystems 7.2
    
    See Also:
    
    FileUtil.setOrder(java.util.List<org.openide.filesystems.FileObject>), Specification
  - setOrder
```
public static void setOrder(List<FileObject> children)
                     throws IllegalArgumentException,
                            IOException
```
    Imposes an order on some sibling file objects. After this call, if no other changes have intervened, FileUtil.getOrder(java.util.Collection<org.openide.filesystems.FileObject>, boolean) on these files should return a list in the same order. Beyond the fact that this call may manipulate the position attributes of files in the folder, and may delete deprecated relative ordering attributes on the folder, the exact means of setting the order is unspecified.
    
    Parameters:
    
    children - a list of zero or more files (or folders); must all have the same FileObject.getParent()
    
    Throws:
    
    IllegalArgumentException - in case there are duplicates, or nulls, or the files do not have a common parent
    
    IOException - if new file attributes to order the children cannot be written out
    
    Since:
    
    org.openide.filesystems 7.2
  - affectsOrder
```
public static boolean affectsOrder(FileAttributeEvent event)
```
    Checks whether a change in a given file attribute would affect the result of FileUtil.getOrder(java.util.Collection<org.openide.filesystems.FileObject>, boolean).
    
    Parameters:
    
    event - an attribute change event
    
    Returns:
    
    true if the attribute in question might affect the order of some folder
    
    Since:
    
    org.openide.filesystems 7.2
  - getConfigFile
```
public static FileObject getConfigFile(String path)
```
    Returns FileObject from the NetBeans default (system, configuration) filesystem or null if does not exist. If you wish to create the file/folder when it does not already exist, start with FileUtil.getConfigRoot() and use FileUtil.createData(FileObject, String) or FileUtil.createFolder(FileObject, String) methods.
    In environment with multiple contextual Lookups, the method may return different FileObject depending on what Lookup serves the executing thread. If the system-wide (user-independent) configuration is required instead, FileUtil.getSystemConfigFile(java.lang.String) should be called instead. If an service instance is created based on the configuration, it is important to decide whether the service instance should live for each context independently (possibly with some private means of communication between instances/users) or all users should share the same instance. In the later case, FileUtil.getSystemConfigFile(java.lang.String) must be used.
    
    Parameters:
    
    path - the path from the root of the NetBeans default (system, configuration) filesystem delimited by '/' or empty string to get root folder.
    
    Returns:
    
    a FileObject for given path in the NetBeans default (system, configuration) filesystem or null if does not exist
    
    Throws:
    
    NullPointerException - if the path is null
    
    Since:
    
    org.openide.filesystems 7.19, 9.5 support for multiuser environment
  - getSystemConfigFile
```
public static FileObject getSystemConfigFile(String path)
```
    Returns FileObject from the default filesystem, or null if the file does not exist. Unlike FileUtil.getConfigFile(java.lang.String), this call returns a FileObject from the system-wide configuration. Because default/config filesystem is used both for configuration and services, Lookup or service providers should use this method in preference to FileUtil.getConfigFile(java.lang.String) to produce singleton services even in multiple context environment.
    With the default Lookup implementation, behaviour of getSystemConfigFile and FileUtil.getConfigFile(java.lang.String) is identical.
    
    Parameters:
    
    path - the path from the root of the NetBeans default (system, configuration) filesystem delimited by '/' or empty string to get root folder.
    
    Returns:
    
    a FileObject for given path in the NetBeans default (system, configuration) filesystem or null if does not exist
    
    Throws:
    
    NullPointerException - if the path is null
    
    Since:
    
    9.5
  - getConfigObject
```
public static <T> T getConfigObject(String path,
                                    Class<T> type)
```
    Finds a config object under given path. The path contains the extension of a file e.g.:
```
 Actions/Edit/org-openide-actions-CopyAction.instance
 Services/Browsers/swing-browser.settings
 
```
    In multi-user setup, this method returns instance specific for the executing user. Important: it returns user-specific instance even though the object is configured in a XML layer, or system-wide configuration; still, the instance will be tied to the user-specific file as served by FileUtil.getConfigFile(java.lang.String).
    Parameters:
    
    path - path to .instance or .settings file
    
    type - the requested type for given object
    
    Returns:
    
    either null or instance of requrested type
    
    Since:
    
    7.49, 9.5 support for multi-user environment
  - getSystemConfigObject
```
public static <T> T getSystemConfigObject(String path,
                                          Class<T> type)
```
    Finds a config object under the given path, in system-wide configuration. In the default implementation, this method works just as FileUtil.getConfigObject(java.lang.String, java.lang.Class<T>). In multi-user setups, this method should return an instance shared between potential users; in a sense, it works as FileUtil.getConfigObject(java.lang.String, java.lang.Class<T>) prior version 9.5
    
    Parameters:
    
    path - path to .instance or .settings file
    
    type - the requested type for given object
    
    Returns:
    
    either null or instance of requrested type
    
    Since:
    
    9.5
  - getConfigRoot
```
public static FileObject getConfigRoot()
```
    Returns the root of the NetBeans default (system, configuration) filesystem. It returns configuration root using the current Repository, in the case that multiple Repository instances are created to support multiple execution contexts in the same JVM.
    
    Returns:
    
    a FileObject for the root of the NetBeans default (system, configuration) filesystem
    
    Since:
    
    org.openide.filesystems 7.19, 9.5 support for multiple local contexts
  - getSystemConfigRoot
```
public static FileObject getSystemConfigRoot()
```
    Returns the root of the NetBeans default (system, configuration) filesystem. Unlike FileUtil.getConfigRoot(), this method always provides the system-wide configuration root.
    
    Returns:
    
    a FileObject for the root of the NetBeans default (system, configuration) filesystem
    
    Since:
    
    9.5
  - isValidFileName
```
public static boolean isValidFileName(String fileName)
```
    Determines whether the string forms a valid filename (without a path component).
    
    Parameters:
    
    fileName - candidate string
    
    Returns:
    
    true, if the string can be used to name a file.
    
    Since:
    
    9.24

Class FileUtil

Method Summary

Methods inherited from class java.lang.Object

Method Detail

refreshFor

refreshAll

addFileChangeListener

removeFileChangeListener

addFileChangeListener

removeFileChangeListener

addRecursiveListener

addRecursiveListener

addRecursiveListener

removeRecursiveListener

runAtomicAction

runAtomicAction

createFolder

createData

copy

createMemoryFileSystem

copyFile

copyFile

moveFile

createFolder

createData

toFile

toPath

toFileObject

toFileObject

fromFile

copyAttributes

defaultAttributesTransformer

copyAttributes

extractJar

getExtension

findFreeFileName

findFreeFolderName

getRelativePath

findBrother

getMIMEType

getMIMEType

getMIMEType

setMIMEType

getMIMETypeExtensions

nbfsURLStreamHandler

isParentOf

isRecursiveSymbolicLink

weakFileChangeListener

weakFileStatusListener

getFileDisplayName

normalizePath

normalizeFile

getArchiveRoot

getArchiveRoot

getArchiveFile

getArchiveFile

isArchiveFile

isArchiveFile

isArchiveArtifact

isArchiveArtifact

urlForArchiveOrDir

archiveOrDirForURL

preventFileChooserSymlinkTraversal

getOrder

setOrder

affectsOrder

getConfigFile

getSystemConfigFile

getConfigObject

getSystemConfigObject

getConfigRoot

getSystemConfigRoot

isValidFileName