1 /*
   2  * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package java.nio.file;
  27 
  28 import java.nio.file.attribute.*;
  29 import java.nio.file.spi.FileSystemProvider;
  30 import java.nio.file.spi.FileTypeDetector;
  31 import java.nio.channels.SeekableByteChannel;
  32 import java.io.InputStream;
  33 import java.io.OutputStream;
  34 import java.io.Reader;
  35 import java.io.Writer;
  36 import java.io.BufferedReader;
  37 import java.io.BufferedWriter;
  38 import java.io.InputStreamReader;
  39 import java.io.OutputStreamWriter;
  40 import java.io.IOException;
  41 import java.util.*;
  42 import java.security.AccessController;
  43 import java.security.PrivilegedAction;
  44 import java.nio.charset.Charset;
  45 import java.nio.charset.CharsetDecoder;
  46 import java.nio.charset.CharsetEncoder;
  47 
  48 /**
  49  * This class consists exclusively of static methods that operate on files,
  50  * directories, or other types of files.
  51  *
  52  * <p> In most cases, the methods defined here will delegate to the associated
  53  * file system provider to perform the file operations.
  54  *
  55  * @since 1.7
  56  */
  57 
  58 public final class Files {
  59     private Files() { }
  60 
  61     /**
  62      * Returns the {@code FileSystemProvider} to delegate to.
  63      */
  64     private static FileSystemProvider provider(Path path) {
  65         return path.getFileSystem().provider();
  66     }
  67 
  68     // -- File contents --
  69 
  70     /**
  71      * Opens a file, returning an input stream to read from the file. The stream
  72      * will not be buffered, and is not required to support the {@link
  73      * InputStream#mark mark} or {@link InputStream#reset reset} methods. The
  74      * stream will be safe for access by multiple concurrent threads. Reading
  75      * commences at the beginning of the file. Whether the returned stream is
  76      * <i>asynchronously closeable</i> and/or <i>interruptible</i> is highly
  77      * file system provider specific and therefore not specified.
  78      *
  79      * <p> The {@code options} parameter determines how the file is opened.
  80      * If no options are present then it is equivalent to opening the file with
  81      * the {@link StandardOpenOption#READ READ} option. In addition to the {@code
  82      * READ} option, an implementation may also support additional implementation
  83      * specific options.
  84      *
  85      * @param   path
  86      *          the path to the file to open
  87      * @param   options
  88      *          options specifying how the file is opened
  89      *
  90      * @return  a new input stream
  91      *
  92      * @throws  IllegalArgumentException
  93      *          if an invalid combination of options is specified
  94      * @throws  UnsupportedOperationException
  95      *          if an unsupported option is specified
  96      * @throws  IOException
  97      *          if an I/O error occurs
  98      * @throws  SecurityException
  99      *          In the case of the default provider, and a security manager is
 100      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
 101      *          method is invoked to check read access to the file.
 102      */
 103     public static InputStream newInputStream(Path path, OpenOption... options)
 104         throws IOException
 105     {
 106         return provider(path).newInputStream(path, options);
 107     }
 108 
 109     /**
 110      * Opens or creates a file, returning an output stream that may be used to
 111      * write bytes to the file. The resulting stream will not be buffered. The
 112      * stream will be safe for access by multiple concurrent threads. Whether
 113      * the returned stream is <i>asynchronously closeable</i> and/or
 114      * <i>interruptible</i> is highly file system provider specific and
 115      * therefore not specified.
 116      *
 117      * <p> This method opens or creates a file in exactly the manner specified
 118      * by the {@link #newByteChannel(Path,Set,FileAttribute[]) newByteChannel}
 119      * method with the exception that the {@link StandardOpenOption#READ READ}
 120      * option may not be present in the array of options. If no options are
 121      * present then this method works as if the {@link StandardOpenOption#CREATE
 122      * CREATE}, {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING},
 123      * and {@link StandardOpenOption#WRITE WRITE} options are present. In other
 124      * words, it opens the file for writing, creating the file if it doesn't
 125      * exist, or initially truncating an existing {@link #isRegularFile
 126      * regular-file} to a size of {@code 0} if it exists.
 127      *
 128      * <p> <b>Usage Examples:</b>
 129      * <pre>
 130      *     Path path = ...
 131      *
 132      *     // truncate and overwrite an existing file, or create the file if
 133      *     // it doesn't initially exist
 134      *     OutputStream out = Files.newOutputStream(path);
 135      *
 136      *     // append to an existing file, fail if the file does not exist
 137      *     out = Files.newOutputStream(path, APPEND);
 138      *
 139      *     // append to an existing file, create file if it doesn't initially exist
 140      *     out = Files.newOutputStream(path, CREATE, APPEND);
 141      *
 142      *     // always create new file, failing if it already exists
 143      *     out = Files.newOutputStream(path, CREATE_NEW);
 144      * </pre>
 145      *
 146      * @param   path
 147      *          the path to the file to open or create
 148      * @param   options
 149      *          options specifying how the file is opened
 150      *
 151      * @return  a new output stream
 152      *
 153      * @throws  IllegalArgumentException
 154      *          if {@code options} contains an invalid combination of options
 155      * @throws  UnsupportedOperationException
 156      *          if an unsupported option is specified
 157      * @throws  IOException
 158      *          if an I/O error occurs
 159      * @throws  SecurityException
 160      *          In the case of the default provider, and a security manager is
 161      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 162      *          method is invoked to check write access to the file. The {@link
 163      *          SecurityManager#checkDelete(String) checkDelete} method is
 164      *          invoked to check delete access if the file is opened with the
 165      *          {@code DELETE_ON_CLOSE} option.
 166      */
 167     public static OutputStream newOutputStream(Path path, OpenOption... options)
 168         throws IOException
 169     {
 170         return provider(path).newOutputStream(path, options);
 171     }
 172 
 173     /**
 174      * Opens or creates a file, returning a seekable byte channel to access the
 175      * file.
 176      *
 177      * <p> The {@code options} parameter determines how the file is opened.
 178      * The {@link StandardOpenOption#READ READ} and {@link
 179      * StandardOpenOption#WRITE WRITE} options determine if the file should be
 180      * opened for reading and/or writing. If neither option (or the {@link
 181      * StandardOpenOption#APPEND APPEND} option) is present then the file is
 182      * opened for reading. By default reading or writing commence at the
 183      * beginning of the file.
 184      *
 185      * <p> In the addition to {@code READ} and {@code WRITE}, the following
 186      * options may be present:
 187      *
 188      * <table border=1 cellpadding=5 summary="">
 189      * <tr> <th>Option</th> <th>Description</th> </tr>
 190      * <tr>
 191      *   <td> {@link StandardOpenOption#APPEND APPEND} </td>
 192      *   <td> If this option is present then the file is opened for writing and
 193      *     each invocation of the channel's {@code write} method first advances
 194      *     the position to the end of the file and then writes the requested
 195      *     data. Whether the advancement of the position and the writing of the
 196      *     data are done in a single atomic operation is system-dependent and
 197      *     therefore unspecified. This option may not be used in conjunction
 198      *     with the {@code READ} or {@code TRUNCATE_EXISTING} options. </td>
 199      * </tr>
 200      * <tr>
 201      *   <td> {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING} </td>
 202      *   <td> If this option is present then the existing file is truncated to
 203      *   a size of 0 bytes. This option is ignored when the file is opened only
 204      *   for reading. </td>
 205      * </tr>
 206      * <tr>
 207      *   <td> {@link StandardOpenOption#CREATE_NEW CREATE_NEW} </td>
 208      *   <td> If this option is present then a new file is created, failing if
 209      *   the file already exists or is a symbolic link. When creating a file the
 210      *   check for the existence of the file and the creation of the file if it
 211      *   does not exist is atomic with respect to other file system operations.
 212      *   This option is ignored when the file is opened only for reading. </td>
 213      * </tr>
 214      * <tr>
 215      *   <td > {@link StandardOpenOption#CREATE CREATE} </td>
 216      *   <td> If this option is present then an existing file is opened if it
 217      *   exists, otherwise a new file is created. This option is ignored if the
 218      *   {@code CREATE_NEW} option is also present or the file is opened only
 219      *   for reading. </td>
 220      * </tr>
 221      * <tr>
 222      *   <td > {@link StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE} </td>
 223      *   <td> When this option is present then the implementation makes a
 224      *   <em>best effort</em> attempt to delete the file when closed by the
 225      *   {@link SeekableByteChannel#close close} method. If the {@code close}
 226      *   method is not invoked then a <em>best effort</em> attempt is made to
 227      *   delete the file when the Java virtual machine terminates. </td>
 228      * </tr>
 229      * <tr>
 230      *   <td>{@link StandardOpenOption#SPARSE SPARSE} </td>
 231      *   <td> When creating a new file this option is a <em>hint</em> that the
 232      *   new file will be sparse. This option is ignored when not creating
 233      *   a new file. </td>
 234      * </tr>
 235      * <tr>
 236      *   <td> {@link StandardOpenOption#SYNC SYNC} </td>
 237      *   <td> Requires that every update to the file's content or metadata be
 238      *   written synchronously to the underlying storage device. (see <a
 239      *   href="package-summary.html#integrity"> Synchronized I/O file
 240      *   integrity</a>). </td>
 241      * <tr>
 242      * <tr>
 243      *   <td> {@link StandardOpenOption#DSYNC DSYNC} </td>
 244      *   <td> Requires that every update to the file's content be written
 245      *   synchronously to the underlying storage device. (see <a
 246      *   href="package-summary.html#integrity"> Synchronized I/O file
 247      *   integrity</a>). </td>
 248      * </tr>
 249      * </table>
 250      *
 251      * <p> An implementation may also support additional implementation specific
 252      * options.
 253      *
 254      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 255      * file-attributes} to set atomically when a new file is created.
 256      *
 257      * <p> In the case of the default provider, the returned seekable byte channel
 258      * is a {@link java.nio.channels.FileChannel}.
 259      *
 260      * <p> <b>Usage Examples:</b>
 261      * <pre>
 262      *     Path path = ...
 263      *
 264      *     // open file for reading
 265      *     ReadableByteChannel rbc = Files.newByteChannel(path, EnumSet.of(READ)));
 266      *
 267      *     // open file for writing to the end of an existing file, creating
 268      *     // the file if it doesn't already exist
 269      *     WritableByteChannel wbc = Files.newByteChannel(path, EnumSet.of(CREATE,APPEND));
 270      *
 271      *     // create file with initial permissions, opening it for both reading and writing
 272      *     {@code FileAttribute<Set<PosixFilePermission>> perms = ...}
 273      *     SeekableByteChannel sbc = Files.newByteChannel(path, EnumSet.of(CREATE_NEW,READ,WRITE), perms);
 274      * </pre>
 275      *
 276      * @param   path
 277      *          the path to the file to open or create
 278      * @param   options
 279      *          options specifying how the file is opened
 280      * @param   attrs
 281      *          an optional list of file attributes to set atomically when
 282      *          creating the file
 283      *
 284      * @return  a new seekable byte channel
 285      *
 286      * @throws  IllegalArgumentException
 287      *          if the set contains an invalid combination of options
 288      * @throws  UnsupportedOperationException
 289      *          if an unsupported open option is specified or the array contains
 290      *          attributes that cannot be set atomically when creating the file
 291      * @throws  FileAlreadyExistsException
 292      *          if a file of that name already exists and the {@link
 293      *          StandardOpenOption#CREATE_NEW CREATE_NEW} option is specified
 294      *          <i>(optional specific exception)</i>
 295      * @throws  IOException
 296      *          if an I/O error occurs
 297      * @throws  SecurityException
 298      *          In the case of the default provider, and a security manager is
 299      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
 300      *          method is invoked to check read access to the path if the file is
 301      *          opened for reading. The {@link SecurityManager#checkWrite(String)
 302      *          checkWrite} method is invoked to check write access to the path
 303      *          if the file is opened for writing. The {@link
 304      *          SecurityManager#checkDelete(String) checkDelete} method is
 305      *          invoked to check delete access if the file is opened with the
 306      *          {@code DELETE_ON_CLOSE} option.
 307      *
 308      * @see java.nio.channels.FileChannel#open(Path,Set,FileAttribute[])
 309      */
 310     public static SeekableByteChannel newByteChannel(Path path,
 311                                                      Set<? extends OpenOption> options,
 312                                                      FileAttribute<?>... attrs)
 313         throws IOException
 314     {
 315         return provider(path).newByteChannel(path, options, attrs);
 316     }
 317 
 318     /**
 319      * Opens or creates a file, returning a seekable byte channel to access the
 320      * file.
 321      *
 322      * <p> This method opens or creates a file in exactly the manner specified
 323      * by the {@link #newByteChannel(Path,Set,FileAttribute[]) newByteChannel}
 324      * method.
 325      *
 326      * @param   path
 327      *          the path to the file to open or create
 328      * @param   options
 329      *          options specifying how the file is opened
 330      *
 331      * @return  a new seekable byte channel
 332      *
 333      * @throws  IllegalArgumentException
 334      *          if the set contains an invalid combination of options
 335      * @throws  UnsupportedOperationException
 336      *          if an unsupported open option is specified
 337      * @throws  FileAlreadyExistsException
 338      *          if a file of that name already exists and the {@link
 339      *          StandardOpenOption#CREATE_NEW CREATE_NEW} option is specified
 340      *          <i>(optional specific exception)</i>
 341      * @throws  IOException
 342      *          if an I/O error occurs
 343      * @throws  SecurityException
 344      *          In the case of the default provider, and a security manager is
 345      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
 346      *          method is invoked to check read access to the path if the file is
 347      *          opened for reading. The {@link SecurityManager#checkWrite(String)
 348      *          checkWrite} method is invoked to check write access to the path
 349      *          if the file is opened for writing. The {@link
 350      *          SecurityManager#checkDelete(String) checkDelete} method is
 351      *          invoked to check delete access if the file is opened with the
 352      *          {@code DELETE_ON_CLOSE} option.
 353      *
 354      * @see java.nio.channels.FileChannel#open(Path,OpenOption[])
 355      */
 356     public static SeekableByteChannel newByteChannel(Path path, OpenOption... options)
 357         throws IOException
 358     {
 359         Set<OpenOption> set = new HashSet<OpenOption>(options.length);
 360         Collections.addAll(set, options);
 361         return newByteChannel(path, set);
 362     }
 363 
 364     // -- Directories --
 365 
 366     private static class AcceptAllFilter
 367         implements DirectoryStream.Filter<Path>
 368     {
 369         private AcceptAllFilter() { }
 370 
 371         @Override
 372         public boolean accept(Path entry) { return true; }
 373 
 374         static final AcceptAllFilter FILTER = new AcceptAllFilter();
 375     }
 376 
 377     /**
 378      * Opens a directory, returning a {@link DirectoryStream} to iterate over
 379      * all entries in the directory. The elements returned by the directory
 380      * stream's {@link DirectoryStream#iterator iterator} are of type {@code
 381      * Path}, each one representing an entry in the directory. The {@code Path}
 382      * objects are obtained as if by {@link Path#resolve(Path) resolving} the
 383      * name of the directory entry against {@code dir}.
 384      *
 385      * <p> When not using the try-with-resources construct, then directory
 386      * stream's {@code close} method should be invoked after iteration is
 387      * completed so as to free any resources held for the open directory.
 388      *
 389      * <p> When an implementation supports operations on entries in the
 390      * directory that execute in a race-free manner then the returned directory
 391      * stream is a {@link SecureDirectoryStream}.
 392      *
 393      * @param   dir
 394      *          the path to the directory
 395      *
 396      * @return  a new and open {@code DirectoryStream} object
 397      *
 398      * @throws  NotDirectoryException
 399      *          if the file could not otherwise be opened because it is not
 400      *          a directory <i>(optional specific exception)</i>
 401      * @throws  IOException
 402      *          if an I/O error occurs
 403      * @throws  SecurityException
 404      *          In the case of the default provider, and a security manager is
 405      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
 406      *          method is invoked to check read access to the directory.
 407      */
 408     public static DirectoryStream<Path> newDirectoryStream(Path dir)
 409         throws IOException
 410     {
 411         return provider(dir).newDirectoryStream(dir, AcceptAllFilter.FILTER);
 412     }
 413 
 414     /**
 415      * Opens a directory, returning a {@link DirectoryStream} to iterate over
 416      * the entries in the directory. The elements returned by the directory
 417      * stream's {@link DirectoryStream#iterator iterator} are of type {@code
 418      * Path}, each one representing an entry in the directory. The {@code Path}
 419      * objects are obtained as if by {@link Path#resolve(Path) resolving} the
 420      * name of the directory entry against {@code dir}. The entries returned by
 421      * the iterator are filtered by matching the {@code String} representation
 422      * of their file names against the given <em>globbing</em> pattern.
 423      *
 424      * <p> For example, suppose we want to iterate over the files ending with
 425      * ".java" in a directory:
 426      * <pre>
 427      *     Path dir = ...
 428      *     try (DirectoryStream&lt;Path&gt; stream = Files.newDirectoryStream(dir, "*.java")) {
 429      *         :
 430      *     }
 431      * </pre>
 432      *
 433      * <p> The globbing pattern is specified by the {@link
 434      * FileSystem#getPathMatcher getPathMatcher} method.
 435      *
 436      * <p> When not using the try-with-resources construct, then directory
 437      * stream's {@code close} method should be invoked after iteration is
 438      * completed so as to free any resources held for the open directory.
 439      *
 440      * <p> When an implementation supports operations on entries in the
 441      * directory that execute in a race-free manner then the returned directory
 442      * stream is a {@link SecureDirectoryStream}.
 443      *
 444      * @param   dir
 445      *          the path to the directory
 446      * @param   glob
 447      *          the glob pattern
 448      *
 449      * @return  a new and open {@code DirectoryStream} object
 450      *
 451      * @throws  java.util.regex.PatternSyntaxException
 452      *          if the pattern is invalid
 453      * @throws  NotDirectoryException
 454      *          if the file could not otherwise be opened because it is not
 455      *          a directory <i>(optional specific exception)</i>
 456      * @throws  IOException
 457      *          if an I/O error occurs
 458      * @throws  SecurityException
 459      *          In the case of the default provider, and a security manager is
 460      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
 461      *          method is invoked to check read access to the directory.
 462      */
 463     public static DirectoryStream<Path> newDirectoryStream(Path dir, String glob)
 464         throws IOException
 465     {
 466         // avoid creating a matcher if all entries are required.
 467         if (glob.equals("*"))
 468             return newDirectoryStream(dir);
 469 
 470         // create a matcher and return a filter that uses it.
 471         FileSystem fs = dir.getFileSystem();
 472         final PathMatcher matcher = fs.getPathMatcher("glob:" + glob);
 473         DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<Path>() {
 474             @Override
 475             public boolean accept(Path entry)  {
 476                 return matcher.matches(entry.getFileName());
 477             }
 478         };
 479         return fs.provider().newDirectoryStream(dir, filter);
 480     }
 481 
 482     /**
 483      * Opens a directory, returning a {@link DirectoryStream} to iterate over
 484      * the entries in the directory. The elements returned by the directory
 485      * stream's {@link DirectoryStream#iterator iterator} are of type {@code
 486      * Path}, each one representing an entry in the directory. The {@code Path}
 487      * objects are obtained as if by {@link Path#resolve(Path) resolving} the
 488      * name of the directory entry against {@code dir}. The entries returned by
 489      * the iterator are filtered by the given {@link DirectoryStream.Filter
 490      * filter}.
 491      *
 492      * <p> When not using the try-with-resources construct, then directory
 493      * stream's {@code close} method should be invoked after iteration is
 494      * completed so as to free any resources held for the open directory.
 495      *
 496      * <p> Where the filter terminates due to an uncaught error or runtime
 497      * exception then it is propagated to the {@link Iterator#hasNext()
 498      * hasNext} or {@link Iterator#next() next} method. Where an {@code
 499      * IOException} is thrown, it results in the {@code hasNext} or {@code
 500      * next} method throwing a {@link DirectoryIteratorException} with the
 501      * {@code IOException} as the cause.
 502      *
 503      * <p> When an implementation supports operations on entries in the
 504      * directory that execute in a race-free manner then the returned directory
 505      * stream is a {@link SecureDirectoryStream}.
 506      *
 507      * <p> <b>Usage Example:</b>
 508      * Suppose we want to iterate over the files in a directory that are
 509      * larger than 8K.
 510      * <pre>
 511      *     DirectoryStream.Filter&lt;Path&gt; filter = new DirectoryStream.Filter&lt;Path&gt;() {
 512      *         public boolean accept(Path file) throws IOException {
 513      *             return (Files.size(file) > 8192L);
 514      *         }
 515      *     };
 516      *     Path dir = ...
 517      *     try (DirectoryStream&lt;Path&gt; stream = Files.newDirectoryStream(dir, filter)) {
 518      *         :
 519      *     }
 520      * </pre>
 521      *
 522      * @param   dir
 523      *          the path to the directory
 524      * @param   filter
 525      *          the directory stream filter
 526      *
 527      * @return  a new and open {@code DirectoryStream} object
 528      *
 529      * @throws  NotDirectoryException
 530      *          if the file could not otherwise be opened because it is not
 531      *          a directory <i>(optional specific exception)</i>
 532      * @throws  IOException
 533      *          if an I/O error occurs
 534      * @throws  SecurityException
 535      *          In the case of the default provider, and a security manager is
 536      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
 537      *          method is invoked to check read access to the directory.
 538      */
 539     public static DirectoryStream<Path> newDirectoryStream(Path dir,
 540                                                            DirectoryStream.Filter<? super Path> filter)
 541         throws IOException
 542     {
 543         return provider(dir).newDirectoryStream(dir, filter);
 544     }
 545 
 546     // -- Creation and deletion --
 547 
 548     /**
 549      * Creates a new and empty file, failing if the file already exists. The
 550      * check for the existence of the file and the creation of the new file if
 551      * it does not exist are a single operation that is atomic with respect to
 552      * all other filesystem activities that might affect the directory.
 553      *
 554      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 555      * file-attributes} to set atomically when creating the file. Each attribute
 556      * is identified by its {@link FileAttribute#name name}. If more than one
 557      * attribute of the same name is included in the array then all but the last
 558      * occurrence is ignored.
 559      *
 560      * @param   path
 561      *          the path to the file to create
 562      * @param   attrs
 563      *          an optional list of file attributes to set atomically when
 564      *          creating the file
 565      *
 566      * @return  the file
 567      *
 568      * @throws  UnsupportedOperationException
 569      *          if the array contains an attribute that cannot be set atomically
 570      *          when creating the file
 571      * @throws  FileAlreadyExistsException
 572      *          if a file of that name already exists
 573      *          <i>(optional specific exception)</i>
 574      * @throws  IOException
 575      *          if an I/O error occurs or the parent directory does not exist
 576      * @throws  SecurityException
 577      *          In the case of the default provider, and a security manager is
 578      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 579      *          method is invoked to check write access to the new file.
 580      */
 581     public static Path createFile(Path path, FileAttribute<?>... attrs)
 582         throws IOException
 583     {
 584         EnumSet<StandardOpenOption> options =
 585             EnumSet.<StandardOpenOption>of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE);
 586         newByteChannel(path, options, attrs).close();
 587         return path;
 588     }
 589 
 590     /**
 591      * Creates a new directory. The check for the existence of the file and the
 592      * creation of the directory if it does not exist are a single operation
 593      * that is atomic with respect to all other filesystem activities that might
 594      * affect the directory. The {@link #createDirectories createDirectories}
 595      * method should be used where it is required to create all nonexistent
 596      * parent directories first.
 597      *
 598      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 599      * file-attributes} to set atomically when creating the directory. Each
 600      * attribute is identified by its {@link FileAttribute#name name}. If more
 601      * than one attribute of the same name is included in the array then all but
 602      * the last occurrence is ignored.
 603      *
 604      * @param   dir
 605      *          the directory to create
 606      * @param   attrs
 607      *          an optional list of file attributes to set atomically when
 608      *          creating the directory
 609      *
 610      * @return  the directory
 611      *
 612      * @throws  UnsupportedOperationException
 613      *          if the array contains an attribute that cannot be set atomically
 614      *          when creating the directory
 615      * @throws  FileAlreadyExistsException
 616      *          if a directory could not otherwise be created because a file of
 617      *          that name already exists <i>(optional specific exception)</i>
 618      * @throws  IOException
 619      *          if an I/O error occurs or the parent directory does not exist
 620      * @throws  SecurityException
 621      *          In the case of the default provider, and a security manager is
 622      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 623      *          method is invoked to check write access to the new directory.
 624      */
 625     public static Path createDirectory(Path dir, FileAttribute<?>... attrs)
 626         throws IOException
 627     {
 628         provider(dir).createDirectory(dir, attrs);
 629         return dir;
 630     }
 631 
 632     /**
 633      * Creates a directory by creating all nonexistent parent directories first.
 634      * Unlike the {@link #createDirectory createDirectory} method, an exception
 635      * is not thrown if the directory could not be created because it already
 636      * exists.
 637      *
 638      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 639      * file-attributes} to set atomically when creating the nonexistent
 640      * directories. Each file attribute is identified by its {@link
 641      * FileAttribute#name name}. If more than one attribute of the same name is
 642      * included in the array then all but the last occurrence is ignored.
 643      *
 644      * <p> If this method fails, then it may do so after creating some, but not
 645      * all, of the parent directories.
 646      *
 647      * @param   dir
 648      *          the directory to create
 649      *
 650      * @param   attrs
 651      *          an optional list of file attributes to set atomically when
 652      *          creating the directory
 653      *
 654      * @return  the directory
 655      *
 656      * @throws  UnsupportedOperationException
 657      *          if the array contains an attribute that cannot be set atomically
 658      *          when creating the directory
 659      * @throws  FileAlreadyExistsException
 660      *          if {@code dir} exists but is not a directory <i>(optional specific
 661      *          exception)</i>
 662      * @throws  IOException
 663      *          if an I/O error occurs
 664      * @throws  SecurityException
 665      *          in the case of the default provider, and a security manager is
 666      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 667      *          method is invoked prior to attempting to create a directory and
 668      *          its {@link SecurityManager#checkRead(String) checkRead} is
 669      *          invoked for each parent directory that is checked. If {@code
 670      *          dir} is not an absolute path then its {@link Path#toAbsolutePath
 671      *          toAbsolutePath} may need to be invoked to get its absolute path.
 672      *          This may invoke the security manager's {@link
 673      *          SecurityManager#checkPropertyAccess(String) checkPropertyAccess}
 674      *          method to check access to the system property {@code user.dir}
 675      */
 676     public static Path createDirectories(Path dir, FileAttribute<?>... attrs)
 677         throws IOException
 678     {
 679         // attempt to create the directory
 680         try {
 681             createAndCheckIsDirectory(dir, attrs);
 682             return dir;
 683         } catch (FileAlreadyExistsException x) {
 684             // file exists and is not a directory
 685             throw x;
 686         } catch (IOException x) {
 687             // parent may not exist or other reason
 688         }
 689         SecurityException se = null;
 690         try {
 691             dir = dir.toAbsolutePath();
 692         } catch (SecurityException x) {
 693             // don't have permission to get absolute path
 694             se = x;
 695         }
 696         // find a decendent that exists
 697         Path parent = dir.getParent();
 698         while (parent != null) {
 699             try {
 700                 provider(parent).checkAccess(parent);
 701                 break;
 702             } catch (NoSuchFileException x) {
 703                 // does not exist
 704             }
 705             parent = parent.getParent();
 706         }
 707         if (parent == null) {
 708             // unable to find existing parent
 709             if (se != null)
 710                 throw se;
 711             throw new IOException("Root directory does not exist");
 712         }
 713 
 714         // create directories
 715         Path child = parent;
 716         for (Path name: parent.relativize(dir)) {
 717             child = child.resolve(name);
 718             createAndCheckIsDirectory(child, attrs);
 719         }
 720         return dir;
 721     }
 722 
 723     /**
 724      * Used by createDirectories to attempt to create a directory. A no-op
 725      * if the directory already exists.
 726      */
 727     private static void createAndCheckIsDirectory(Path dir,
 728                                                   FileAttribute<?>... attrs)
 729         throws IOException
 730     {
 731         try {
 732             createDirectory(dir, attrs);
 733         } catch (FileAlreadyExistsException x) {
 734             if (!isDirectory(dir, LinkOption.NOFOLLOW_LINKS))
 735                 throw x;
 736         }
 737     }
 738 
 739     /**
 740      * Creates a new empty file in the specified directory, using the given
 741      * prefix and suffix strings to generate its name. The resulting
 742      * {@code Path} is associated with the same {@code FileSystem} as the given
 743      * directory.
 744      *
 745      * <p> The details as to how the name of the file is constructed is
 746      * implementation dependent and therefore not specified. Where possible
 747      * the {@code prefix} and {@code suffix} are used to construct candidate
 748      * names in the same manner as the {@link
 749      * java.io.File#createTempFile(String,String,File)} method.
 750      *
 751      * <p> As with the {@code File.createTempFile} methods, this method is only
 752      * part of a temporary-file facility. Where used as a <em>work files</em>,
 753      * the resulting file may be opened using the {@link
 754      * StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE} option so that the
 755      * file is deleted when the appropriate {@code close} method is invoked.
 756      * Alternatively, a {@link Runtime#addShutdownHook shutdown-hook}, or the
 757      * {@link java.io.File#deleteOnExit} mechanism may be used to delete the
 758      * file automatically.
 759      *
 760      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 761      * file-attributes} to set atomically when creating the file. Each attribute
 762      * is identified by its {@link FileAttribute#name name}. If more than one
 763      * attribute of the same name is included in the array then all but the last
 764      * occurrence is ignored. When no file attributes are specified, then the
 765      * resulting file may have more restrictive access permissions to files
 766      * created by the {@link java.io.File#createTempFile(String,String,File)}
 767      * method.
 768      *
 769      * @param   dir
 770      *          the path to directory in which to create the file
 771      * @param   prefix
 772      *          the prefix string to be used in generating the file's name;
 773      *          may be {@code null}
 774      * @param   suffix
 775      *          the suffix string to be used in generating the file's name;
 776      *          may be {@code null}, in which case "{@code .tmp}" is used
 777      * @param   attrs
 778      *          an optional list of file attributes to set atomically when
 779      *          creating the file
 780      *
 781      * @return  the path to the newly created file that did not exist before
 782      *          this method was invoked
 783      *
 784      * @throws  IllegalArgumentException
 785      *          if the prefix or suffix parameters cannot be used to generate
 786      *          a candidate file name
 787      * @throws  UnsupportedOperationException
 788      *          if the array contains an attribute that cannot be set atomically
 789      *          when creating the directory
 790      * @throws  IOException
 791      *          if an I/O error occurs or {@code dir} does not exist
 792      * @throws  SecurityException
 793      *          In the case of the default provider, and a security manager is
 794      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 795      *          method is invoked to check write access to the file.
 796      */
 797     public static Path createTempFile(Path dir,
 798                                       String prefix,
 799                                       String suffix,
 800                                       FileAttribute<?>... attrs)
 801         throws IOException
 802     {
 803         return TempFileHelper.createTempFile(Objects.requireNonNull(dir),
 804                                              prefix, suffix, attrs);
 805     }
 806 
 807     /**
 808      * Creates an empty file in the default temporary-file directory, using
 809      * the given prefix and suffix to generate its name. The resulting {@code
 810      * Path} is associated with the default {@code FileSystem}.
 811      *
 812      * <p> This method works in exactly the manner specified by the
 813      * {@link #createTempFile(Path,String,String,FileAttribute[])} method for
 814      * the case that the {@code dir} parameter is the temporary-file directory.
 815      *
 816      * @param   prefix
 817      *          the prefix string to be used in generating the file's name;
 818      *          may be {@code null}
 819      * @param   suffix
 820      *          the suffix string to be used in generating the file's name;
 821      *          may be {@code null}, in which case "{@code .tmp}" is used
 822      * @param   attrs
 823      *          an optional list of file attributes to set atomically when
 824      *          creating the file
 825      *
 826      * @return  the path to the newly created file that did not exist before
 827      *          this method was invoked
 828      *
 829      * @throws  IllegalArgumentException
 830      *          if the prefix or suffix parameters cannot be used to generate
 831      *          a candidate file name
 832      * @throws  UnsupportedOperationException
 833      *          if the array contains an attribute that cannot be set atomically
 834      *          when creating the directory
 835      * @throws  IOException
 836      *          if an I/O error occurs or the temporary-file directory does not
 837      *          exist
 838      * @throws  SecurityException
 839      *          In the case of the default provider, and a security manager is
 840      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 841      *          method is invoked to check write access to the file.
 842      */
 843     public static Path createTempFile(String prefix,
 844                                       String suffix,
 845                                       FileAttribute<?>... attrs)
 846         throws IOException
 847     {
 848         return TempFileHelper.createTempFile(null, prefix, suffix, attrs);
 849     }
 850 
 851     /**
 852      * Creates a new directory in the specified directory, using the given
 853      * prefix to generate its name.  The resulting {@code Path} is associated
 854      * with the same {@code FileSystem} as the given directory.
 855      *
 856      * <p> The details as to how the name of the directory is constructed is
 857      * implementation dependent and therefore not specified. Where possible
 858      * the {@code prefix} is used to construct candidate names.
 859      *
 860      * <p> As with the {@code createTempFile} methods, this method is only
 861      * part of a temporary-file facility. A {@link Runtime#addShutdownHook
 862      * shutdown-hook}, or the {@link java.io.File#deleteOnExit} mechanism may be
 863      * used to delete the directory automatically.
 864      *
 865      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 866      * file-attributes} to set atomically when creating the directory. Each
 867      * attribute is identified by its {@link FileAttribute#name name}. If more
 868      * than one attribute of the same name is included in the array then all but
 869      * the last occurrence is ignored.
 870      *
 871      * @param   dir
 872      *          the path to directory in which to create the directory
 873      * @param   prefix
 874      *          the prefix string to be used in generating the directory's name;
 875      *          may be {@code null}
 876      * @param   attrs
 877      *          an optional list of file attributes to set atomically when
 878      *          creating the directory
 879      *
 880      * @return  the path to the newly created directory that did not exist before
 881      *          this method was invoked
 882      *
 883      * @throws  IllegalArgumentException
 884      *          if the prefix cannot be used to generate a candidate directory name
 885      * @throws  UnsupportedOperationException
 886      *          if the array contains an attribute that cannot be set atomically
 887      *          when creating the directory
 888      * @throws  IOException
 889      *          if an I/O error occurs or {@code dir} does not exist
 890      * @throws  SecurityException
 891      *          In the case of the default provider, and a security manager is
 892      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 893      *          method is invoked to check write access when creating the
 894      *          directory.
 895      */
 896     public static Path createTempDirectory(Path dir,
 897                                            String prefix,
 898                                            FileAttribute<?>... attrs)
 899         throws IOException
 900     {
 901         return TempFileHelper.createTempDirectory(Objects.requireNonNull(dir),
 902                                                   prefix, attrs);
 903     }
 904 
 905     /**
 906      * Creates a new directory in the default temporary-file directory, using
 907      * the given prefix to generate its name. The resulting {@code Path} is
 908      * associated with the default {@code FileSystem}.
 909      *
 910      * <p> This method works in exactly the manner specified by {@link
 911      * #createTempDirectory(Path,String,FileAttribute[])} method for the case
 912      * that the {@code dir} parameter is the temporary-file directory.
 913      *
 914      * @param   prefix
 915      *          the prefix string to be used in generating the directory's name;
 916      *          may be {@code null}
 917      * @param   attrs
 918      *          an optional list of file attributes to set atomically when
 919      *          creating the directory
 920      *
 921      * @return  the path to the newly created directory that did not exist before
 922      *          this method was invoked
 923      *
 924      * @throws  IllegalArgumentException
 925      *          if the prefix cannot be used to generate a candidate directory name
 926      * @throws  UnsupportedOperationException
 927      *          if the array contains an attribute that cannot be set atomically
 928      *          when creating the directory
 929      * @throws  IOException
 930      *          if an I/O error occurs or the temporary-file directory does not
 931      *          exist
 932      * @throws  SecurityException
 933      *          In the case of the default provider, and a security manager is
 934      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 935      *          method is invoked to check write access when creating the
 936      *          directory.
 937      */
 938     public static Path createTempDirectory(String prefix,
 939                                            FileAttribute<?>... attrs)
 940         throws IOException
 941     {
 942         return TempFileHelper.createTempDirectory(null, prefix, attrs);
 943     }
 944 
 945     /**
 946      * Creates a symbolic link to a target <i>(optional operation)</i>.
 947      *
 948      * <p> The {@code target} parameter is the target of the link. It may be an
 949      * {@link Path#isAbsolute absolute} or relative path and may not exist. When
 950      * the target is a relative path then file system operations on the resulting
 951      * link are relative to the path of the link.
 952      *
 953      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 954      * attributes} to set atomically when creating the link. Each attribute is
 955      * identified by its {@link FileAttribute#name name}. If more than one attribute
 956      * of the same name is included in the array then all but the last occurrence
 957      * is ignored.
 958      *
 959      * <p> Where symbolic links are supported, but the underlying {@link FileStore}
 960      * does not support symbolic links, then this may fail with an {@link
 961      * IOException}. Additionally, some operating systems may require that the
 962      * Java virtual machine be started with implementation specific privileges to
 963      * create symbolic links, in which case this method may throw {@code IOException}.
 964      *
 965      * @param   link
 966      *          the path of the symbolic link to create
 967      * @param   target
 968      *          the target of the symbolic link
 969      * @param   attrs
 970      *          the array of attributes to set atomically when creating the
 971      *          symbolic link
 972      *
 973      * @return  the path to the symbolic link
 974      *
 975      * @throws  UnsupportedOperationException
 976      *          if the implementation does not support symbolic links or the
 977      *          array contains an attribute that cannot be set atomically when
 978      *          creating the symbolic link
 979      * @throws  FileAlreadyExistsException
 980      *          if a file with the name already exists <i>(optional specific
 981      *          exception)</i>
 982      * @throws  IOException
 983      *          if an I/O error occurs
 984      * @throws  SecurityException
 985      *          In the case of the default provider, and a security manager
 986      *          is installed, it denies {@link LinkPermission}<tt>("symbolic")</tt>
 987      *          or its {@link SecurityManager#checkWrite(String) checkWrite}
 988      *          method denies write access to the path of the symbolic link.
 989      */
 990     public static Path createSymbolicLink(Path link, Path target,
 991                                           FileAttribute<?>... attrs)
 992         throws IOException
 993     {
 994         provider(link).createSymbolicLink(link, target, attrs);
 995         return link;
 996     }
 997 
 998     /**
 999      * Creates a new link (directory entry) for an existing file <i>(optional
1000      * operation)</i>.
1001      *
1002      * <p> The {@code link} parameter locates the directory entry to create.
1003      * The {@code existing} parameter is the path to an existing file. This
1004      * method creates a new directory entry for the file so that it can be
1005      * accessed using {@code link} as the path. On some file systems this is
1006      * known as creating a "hard link". Whether the file attributes are
1007      * maintained for the file or for each directory entry is file system
1008      * specific and therefore not specified. Typically, a file system requires
1009      * that all links (directory entries) for a file be on the same file system.
1010      * Furthermore, on some platforms, the Java virtual machine may require to
1011      * be started with implementation specific privileges to create hard links
1012      * or to create links to directories.
1013      *
1014      * @param   link
1015      *          the link (directory entry) to create
1016      * @param   existing
1017      *          a path to an existing file
1018      *
1019      * @return  the path to the link (directory entry)
1020      *
1021      * @throws  UnsupportedOperationException
1022      *          if the implementation does not support adding an existing file
1023      *          to a directory
1024      * @throws  FileAlreadyExistsException
1025      *          if the entry could not otherwise be created because a file of
1026      *          that name already exists <i>(optional specific exception)</i>
1027      * @throws  IOException
1028      *          if an I/O error occurs
1029      * @throws  SecurityException
1030      *          In the case of the default provider, and a security manager
1031      *          is installed, it denies {@link LinkPermission}<tt>("hard")</tt>
1032      *          or its {@link SecurityManager#checkWrite(String) checkWrite}
1033      *          method denies write access to either the link or the
1034      *          existing file.
1035      */
1036     public static Path createLink(Path link, Path existing) throws IOException {
1037         provider(link).createLink(link, existing);
1038         return link;
1039     }
1040 
1041     /**
1042      * Deletes a file.
1043      *
1044      * <p> An implementation may require to examine the file to determine if the
1045      * file is a directory. Consequently this method may not be atomic with respect
1046      * to other file system operations.  If the file is a symbolic link then the
1047      * symbolic link itself, not the final target of the link, is deleted.
1048      *
1049      * <p> If the file is a directory then the directory must be empty. In some
1050      * implementations a directory has entries for special files or links that
1051      * are created when the directory is created. In such implementations a
1052      * directory is considered empty when only the special entries exist.
1053      * This method can be used with the {@link #walkFileTree walkFileTree}
1054      * method to delete a directory and all entries in the directory, or an
1055      * entire <i>file-tree</i> where required.
1056      *
1057      * <p> On some operating systems it may not be possible to remove a file when
1058      * it is open and in use by this Java virtual machine or other programs.
1059      *
1060      * @param   path
1061      *          the path to the file to delete
1062      *
1063      * @throws  NoSuchFileException
1064      *          if the file does not exist <i>(optional specific exception)</i>
1065      * @throws  DirectoryNotEmptyException
1066      *          if the file is a directory and could not otherwise be deleted
1067      *          because the directory is not empty <i>(optional specific
1068      *          exception)</i>
1069      * @throws  IOException
1070      *          if an I/O error occurs
1071      * @throws  SecurityException
1072      *          In the case of the default provider, and a security manager is
1073      *          installed, the {@link SecurityManager#checkDelete(String)} method
1074      *          is invoked to check delete access to the file
1075      */
1076     public static void delete(Path path) throws IOException {
1077         provider(path).delete(path);
1078     }
1079 
1080     /**
1081      * Deletes a file if it exists.
1082      *
1083      * <p> As with the {@link #delete(Path) delete(Path)} method, an
1084      * implementation may need to examine the file to determine if the file is a
1085      * directory. Consequently this method may not be atomic with respect to
1086      * other file system operations.  If the file is a symbolic link, then the
1087      * symbolic link itself, not the final target of the link, is deleted.
1088      *
1089      * <p> If the file is a directory then the directory must be empty. In some
1090      * implementations a directory has entries for special files or links that
1091      * are created when the directory is created. In such implementations a
1092      * directory is considered empty when only the special entries exist.
1093      *
1094      * <p> On some operating systems it may not be possible to remove a file when
1095      * it is open and in use by this Java virtual machine or other programs.
1096      *
1097      * @param   path
1098      *          the path to the file to delete
1099      *
1100      * @return  {@code true} if the file was deleted by this method; {@code
1101      *          false} if the file could not be deleted because it did not
1102      *          exist
1103      *
1104      * @throws  DirectoryNotEmptyException
1105      *          if the file is a directory and could not otherwise be deleted
1106      *          because the directory is not empty <i>(optional specific
1107      *          exception)</i>
1108      * @throws  IOException
1109      *          if an I/O error occurs
1110      * @throws  SecurityException
1111      *          In the case of the default provider, and a security manager is
1112      *          installed, the {@link SecurityManager#checkDelete(String)} method
1113      *          is invoked to check delete access to the file.
1114      */
1115     public static boolean deleteIfExists(Path path) throws IOException {
1116         return provider(path).deleteIfExists(path);
1117     }
1118 
1119     // -- Copying and moving files --
1120 
1121     /**
1122      * Copy a file to a target file.
1123      *
1124      * <p> This method copies a file to the target file with the {@code
1125      * options} parameter specifying how the copy is performed. By default, the
1126      * copy fails if the target file already exists or is a symbolic link,
1127      * except if the source and target are the {@link #isSameFile same} file, in
1128      * which case the method completes without copying the file. File attributes
1129      * are not required to be copied to the target file. If symbolic links are
1130      * supported, and the file is a symbolic link, then the final target of the
1131      * link is copied. If the file is a directory then it creates an empty
1132      * directory in the target location (entries in the directory are not
1133      * copied). This method can be used with the {@link #walkFileTree
1134      * walkFileTree} method to copy a directory and all entries in the directory,
1135      * or an entire <i>file-tree</i> where required.
1136      *
1137      * <p> The {@code options} parameter may include any of the following:
1138      *
1139      * <table border=1 cellpadding=5 summary="">
1140      * <tr> <th>Option</th> <th>Description</th> </tr>
1141      * <tr>
1142      *   <td> {@link StandardCopyOption#REPLACE_EXISTING REPLACE_EXISTING} </td>
1143      *   <td> If the target file exists, then the target file is replaced if it
1144      *     is not a non-empty directory. If the target file exists and is a
1145      *     symbolic link, then the symbolic link itself, not the target of
1146      *     the link, is replaced. </td>
1147      * </tr>
1148      * <tr>
1149      *   <td> {@link StandardCopyOption#COPY_ATTRIBUTES COPY_ATTRIBUTES} </td>
1150      *   <td> Attempts to copy the file attributes associated with this file to
1151      *     the target file. The exact file attributes that are copied is platform
1152      *     and file system dependent and therefore unspecified. Minimally, the
1153      *     {@link BasicFileAttributes#lastModifiedTime last-modified-time} is
1154      *     copied to the target file if supported by both the source and target
1155      *     file store. Copying of file timestamps may result in precision
1156      *     loss. </td>
1157      * </tr>
1158      * <tr>
1159      *   <td> {@link LinkOption#NOFOLLOW_LINKS NOFOLLOW_LINKS} </td>
1160      *   <td> Symbolic links are not followed. If the file is a symbolic link,
1161      *     then the symbolic link itself, not the target of the link, is copied.
1162      *     It is implementation specific if file attributes can be copied to the
1163      *     new link. In other words, the {@code COPY_ATTRIBUTES} option may be
1164      *     ignored when copying a symbolic link. </td>
1165      * </tr>
1166      * </table>
1167      *
1168      * <p> An implementation of this interface may support additional
1169      * implementation specific options.
1170      *
1171      * <p> Copying a file is not an atomic operation. If an {@link IOException}
1172      * is thrown then it possible that the target file is incomplete or some of
1173      * its file attributes have not been copied from the source file. When the
1174      * {@code REPLACE_EXISTING} option is specified and the target file exists,
1175      * then the target file is replaced. The check for the existence of the file
1176      * and the creation of the new file may not be atomic with respect to other
1177      * file system activities.
1178      *
1179      * <p> <b>Usage Example:</b>
1180      * Suppose we want to copy a file into a directory, giving it the same file
1181      * name as the source file:
1182      * <pre>
1183      *     Path source = ...
1184      *     Path newdir = ...
1185      *     Files.copy(source, newdir.resolve(source.getFileName());
1186      * </pre>
1187      *
1188      * @param   source
1189      *          the path to the file to copy
1190      * @param   target
1191      *          the path to the target file (may be associated with a different
1192      *          provider to the source path)
1193      * @param   options
1194      *          options specifying how the copy should be done
1195      *
1196      * @return  the path to the target file
1197      *
1198      * @throws  UnsupportedOperationException
1199      *          if the array contains a copy option that is not supported
1200      * @throws  FileAlreadyExistsException
1201      *          if the target file exists but cannot be replaced because the
1202      *          {@code REPLACE_EXISTING} option is not specified <i>(optional
1203      *          specific exception)</i>
1204      * @throws  DirectoryNotEmptyException
1205      *          the {@code REPLACE_EXISTING} option is specified but the file
1206      *          cannot be replaced because it is a non-empty directory
1207      *          <i>(optional specific exception)</i>
1208      * @throws  IOException
1209      *          if an I/O error occurs
1210      * @throws  SecurityException
1211      *          In the case of the default provider, and a security manager is
1212      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
1213      *          method is invoked to check read access to the source file, the
1214      *          {@link SecurityManager#checkWrite(String) checkWrite} is invoked
1215      *          to check write access to the target file. If a symbolic link is
1216      *          copied the security manager is invoked to check {@link
1217      *          LinkPermission}{@code ("symbolic")}.
1218      */
1219     public static Path copy(Path source, Path target, CopyOption... options)
1220         throws IOException
1221     {
1222         FileSystemProvider provider = provider(source);
1223         if (provider(target) == provider) {
1224             // same provider
1225             provider.copy(source, target, options);
1226         } else {
1227             // different providers
1228             CopyMoveHelper.copyToForeignTarget(source, target, options);
1229         }
1230         return target;
1231     }
1232 
1233     /**
1234      * Move or rename a file to a target file.
1235      *
1236      * <p> By default, this method attempts to move the file to the target
1237      * file, failing if the target file exists except if the source and
1238      * target are the {@link #isSameFile same} file, in which case this method
1239      * has no effect. If the file is a symbolic link then the symbolic link
1240      * itself, not the target of the link, is moved. This method may be
1241      * invoked to move an empty directory. In some implementations a directory
1242      * has entries for special files or links that are created when the
1243      * directory is created. In such implementations a directory is considered
1244      * empty when only the special entries exist. When invoked to move a
1245      * directory that is not empty then the directory is moved if it does not
1246      * require moving the entries in the directory.  For example, renaming a
1247      * directory on the same {@link FileStore} will usually not require moving
1248      * the entries in the directory. When moving a directory requires that its
1249      * entries be moved then this method fails (by throwing an {@code
1250      * IOException}). To move a <i>file tree</i> may involve copying rather
1251      * than moving directories and this can be done using the {@link
1252      * #copy copy} method in conjunction with the {@link
1253      * #walkFileTree Files.walkFileTree} utility method.
1254      *
1255      * <p> The {@code options} parameter may include any of the following:
1256      *
1257      * <table border=1 cellpadding=5 summary="">
1258      * <tr> <th>Option</th> <th>Description</th> </tr>
1259      * <tr>
1260      *   <td> {@link StandardCopyOption#REPLACE_EXISTING REPLACE_EXISTING} </td>
1261      *   <td> If the target file exists, then the target file is replaced if it
1262      *     is not a non-empty directory. If the target file exists and is a
1263      *     symbolic link, then the symbolic link itself, not the target of
1264      *     the link, is replaced. </td>
1265      * </tr>
1266      * <tr>
1267      *   <td> {@link StandardCopyOption#ATOMIC_MOVE ATOMIC_MOVE} </td>
1268      *   <td> The move is performed as an atomic file system operation and all
1269      *     other options are ignored. If the target file exists then it is
1270      *     implementation specific if the existing file is replaced or this method
1271      *     fails by throwing an {@link IOException}. If the move cannot be
1272      *     performed as an atomic file system operation then {@link
1273      *     AtomicMoveNotSupportedException} is thrown. This can arise, for
1274      *     example, when the target location is on a different {@code FileStore}
1275      *     and would require that the file be copied, or target location is
1276      *     associated with a different provider to this object. </td>
1277      * </table>
1278      *
1279      * <p> An implementation of this interface may support additional
1280      * implementation specific options.
1281      *
1282      * <p> Where the move requires that the file be copied then the {@link
1283      * BasicFileAttributes#lastModifiedTime last-modified-time} is copied to the
1284      * new file. An implementation may also attempt to copy other file
1285      * attributes but is not required to fail if the file attributes cannot be
1286      * copied. When the move is performed as a non-atomic operation, and a {@code
1287      * IOException} is thrown, then the state of the files is not defined. The
1288      * original file and the target file may both exist, the target file may be
1289      * incomplete or some of its file attributes may not been copied from the
1290      * original file.
1291      *
1292      * <p> <b>Usage Examples:</b>
1293      * Suppose we want to rename a file to "newname", keeping the file in the
1294      * same directory:
1295      * <pre>
1296      *     Path source = ...
1297      *     Files.move(source, source.resolveSibling("newname"));
1298      * </pre>
1299      * Alternatively, suppose we want to move a file to new directory, keeping
1300      * the same file name, and replacing any existing file of that name in the
1301      * directory:
1302      * <pre>
1303      *     Path source = ...
1304      *     Path newdir = ...
1305      *     Files.move(source, newdir.resolve(source.getFileName()), REPLACE_EXISTING);
1306      * </pre>
1307      *
1308      * @param   source
1309      *          the path to the file to move
1310      * @param   target
1311      *          the path to the target file (may be associated with a different
1312      *          provider to the source path)
1313      * @param   options
1314      *          options specifying how the move should be done
1315      *
1316      * @return  the path to the target file
1317      *
1318      * @throws  UnsupportedOperationException
1319      *          if the array contains a copy option that is not supported
1320      * @throws  FileAlreadyExistsException
1321      *          if the target file exists but cannot be replaced because the
1322      *          {@code REPLACE_EXISTING} option is not specified <i>(optional
1323      *          specific exception)</i>
1324      * @throws  DirectoryNotEmptyException
1325      *          the {@code REPLACE_EXISTING} option is specified but the file
1326      *          cannot be replaced because it is a non-empty directory
1327      *          <i>(optional specific exception)</i>
1328      * @throws  AtomicMoveNotSupportedException
1329      *          if the options array contains the {@code ATOMIC_MOVE} option but
1330      *          the file cannot be moved as an atomic file system operation.
1331      * @throws  IOException
1332      *          if an I/O error occurs
1333      * @throws  SecurityException
1334      *          In the case of the default provider, and a security manager is
1335      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
1336      *          method is invoked to check write access to both the source and
1337      *          target file.
1338      */
1339     public static Path move(Path source, Path target, CopyOption... options)
1340         throws IOException
1341     {
1342         FileSystemProvider provider = provider(source);
1343         if (provider(target) == provider) {
1344             // same provider
1345             provider.move(source, target, options);
1346         } else {
1347             // different providers
1348             CopyMoveHelper.moveToForeignTarget(source, target, options);
1349         }
1350         return target;
1351     }
1352 
1353     // -- Miscellenous --
1354 
1355     /**
1356      * Reads the target of a symbolic link <i>(optional operation)</i>.
1357      *
1358      * <p> If the file system supports <a href="package-summary.html#links">symbolic
1359      * links</a> then this method is used to read the target of the link, failing
1360      * if the file is not a symbolic link. The target of the link need not exist.
1361      * The returned {@code Path} object will be associated with the same file
1362      * system as {@code link}.
1363      *
1364      * @param   link
1365      *          the path to the symbolic link
1366      *
1367      * @return  a {@code Path} object representing the target of the link
1368      *
1369      * @throws  UnsupportedOperationException
1370      *          if the implementation does not support symbolic links
1371      * @throws  NotLinkException
1372      *          if the target could otherwise not be read because the file
1373      *          is not a symbolic link <i>(optional specific exception)</i>
1374      * @throws  IOException
1375      *          if an I/O error occurs
1376      * @throws  SecurityException
1377      *          In the case of the default provider, and a security manager
1378      *          is installed, it checks that {@code FilePermission} has been
1379      *          granted with the "{@code readlink}" action to read the link.
1380      */
1381     public static Path readSymbolicLink(Path link) throws IOException {
1382         return provider(link).readSymbolicLink(link);
1383     }
1384 
1385     /**
1386      * Returns the {@link FileStore} representing the file store where a file
1387      * is located.
1388      *
1389      * <p> Once a reference to the {@code FileStore} is obtained it is
1390      * implementation specific if operations on the returned {@code FileStore},
1391      * or {@link FileStoreAttributeView} objects obtained from it, continue
1392      * to depend on the existence of the file. In particular the behavior is not
1393      * defined for the case that the file is deleted or moved to a different
1394      * file store.
1395      *
1396      * @param   path
1397      *          the path to the file
1398      *
1399      * @return  the file store where the file is stored
1400      *
1401      * @throws  IOException
1402      *          if an I/O error occurs
1403      * @throws  SecurityException
1404      *          In the case of the default provider, and a security manager is
1405      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
1406      *          method is invoked to check read access to the file, and in
1407      *          addition it checks {@link RuntimePermission}<tt>
1408      *          ("getFileStoreAttributes")</tt>
1409      */
1410     public static FileStore getFileStore(Path path) throws IOException {
1411         return provider(path).getFileStore(path);
1412     }
1413 
1414     /**
1415      * Tests if two paths locate the same file.
1416      *
1417      * <p> If both {@code Path} objects are {@link Path#equals(Object) equal}
1418      * then this method returns {@code true} without checking if the file exists.
1419      * If the two {@code Path} objects are associated with different providers
1420      * then this method returns {@code false}. Otherwise, this method checks if
1421      * both {@code Path} objects locate the same file, and depending on the
1422      * implementation, may require to open or access both files.
1423      *
1424      * <p> If the file system and files remain static, then this method implements
1425      * an equivalence relation for non-null {@code Paths}.
1426      * <ul>
1427      * <li>It is <i>reflexive</i>: for {@code Path} {@code f},
1428      *     {@code isSameFile(f,f)} should return {@code true}.
1429      * <li>It is <i>symmetric</i>: for two {@code Paths} {@code f} and {@code g},
1430      *     {@code isSameFile(f,g)} will equal {@code isSameFile(g,f)}.
1431      * <li>It is <i>transitive</i>: for three {@code Paths}
1432      *     {@code f}, {@code g}, and {@code h}, if {@code isSameFile(f,g)} returns
1433      *     {@code true} and {@code isSameFile(g,h)} returns {@code true}, then
1434      *     {@code isSameFile(f,h)} will return return {@code true}.
1435      * </ul>
1436      *
1437      * @param   path
1438      *          one path to the file
1439      * @param   path2
1440      *          the other path
1441      *
1442      * @return  {@code true} if, and only if, the two paths locate the same file
1443      *
1444      * @throws  IOException
1445      *          if an I/O error occurs
1446      * @throws  SecurityException
1447      *          In the case of the default provider, and a security manager is
1448      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
1449      *          method is invoked to check read access to both files.
1450      *
1451      * @see java.nio.file.attribute.BasicFileAttributes#fileKey
1452      */
1453     public static boolean isSameFile(Path path, Path path2) throws IOException {
1454         return provider(path).isSameFile(path, path2);
1455     }
1456 
1457     /**
1458      * Tells whether or not a file is considered <em>hidden</em>. The exact
1459      * definition of hidden is platform or provider dependent. On UNIX for
1460      * example a file is considered to be hidden if its name begins with a
1461      * period character ('.'). On Windows a file is considered hidden if it
1462      * isn't a directory and the DOS {@link DosFileAttributes#isHidden hidden}
1463      * attribute is set.
1464      *
1465      * <p> Depending on the implementation this method may require to access
1466      * the file system to determine if the file is considered hidden.
1467      *
1468      * @param   path
1469      *          the path to the file to test
1470      *
1471      * @return  {@code true} if the file is considered hidden
1472      *
1473      * @throws  IOException
1474      *          if an I/O error occurs
1475      * @throws  SecurityException
1476      *          In the case of the default provider, and a security manager is
1477      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
1478      *          method is invoked to check read access to the file.
1479      */
1480     public static boolean isHidden(Path path) throws IOException {
1481         return provider(path).isHidden(path);
1482     }
1483 
1484     // lazy loading of default and installed file type detectors
1485     private static class FileTypeDetectors{
1486         static final FileTypeDetector defaultFileTypeDetector =
1487             sun.nio.fs.DefaultFileTypeDetector.create();
1488         static final List<FileTypeDetector> installeDetectors =
1489             loadInstalledDetectors();
1490 
1491         // loads all installed file type detectors
1492         private static List<FileTypeDetector> loadInstalledDetectors() {
1493             return AccessController
1494                 .doPrivileged(new PrivilegedAction<List<FileTypeDetector>>() {
1495                     @Override public List<FileTypeDetector> run() {
1496                         List<FileTypeDetector> list = new ArrayList<>();
1497                         ServiceLoader<FileTypeDetector> loader = ServiceLoader
1498                             .load(FileTypeDetector.class, ClassLoader.getSystemClassLoader());
1499                         for (FileTypeDetector detector: loader) {
1500                             list.add(detector);
1501                         }
1502                         return list;
1503                 }});
1504         }
1505     }
1506 
1507     /**
1508      * Probes the content type of a file.
1509      *
1510      * <p> This method uses the installed {@link FileTypeDetector} implementations
1511      * to probe the given file to determine its content type. Each file type
1512      * detector's {@link FileTypeDetector#probeContentType probeContentType} is
1513      * invoked, in turn, to probe the file type. If the file is recognized then
1514      * the content type is returned. If the file is not recognized by any of the
1515      * installed file type detectors then a system-default file type detector is
1516      * invoked to guess the content type.
1517      *
1518      * <p> A given invocation of the Java virtual machine maintains a system-wide
1519      * list of file type detectors. Installed file type detectors are loaded
1520      * using the service-provider loading facility defined by the {@link ServiceLoader}
1521      * class. Installed file type detectors are loaded using the system class
1522      * loader. If the system class loader cannot be found then the extension class
1523      * loader is used; If the extension class loader cannot be found then the
1524      * bootstrap class loader is used. File type detectors are typically installed
1525      * by placing them in a JAR file on the application class path or in the
1526      * extension directory, the JAR file contains a provider-configuration file
1527      * named {@code java.nio.file.spi.FileTypeDetector} in the resource directory
1528      * {@code META-INF/services}, and the file lists one or more fully-qualified
1529      * names of concrete subclass of {@code FileTypeDetector } that have a zero
1530      * argument constructor. If the process of locating or instantiating the
1531      * installed file type detectors fails then an unspecified error is thrown.
1532      * The ordering that installed providers are located is implementation
1533      * specific.
1534      *
1535      * <p> The return value of this method is the string form of the value of a
1536      * Multipurpose Internet Mail Extension (MIME) content type as
1537      * defined by <a href="http://www.ietf.org/rfc/rfc2045.txt"><i>RFC&nbsp;2045:
1538      * Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet
1539      * Message Bodies</i></a>. The string is guaranteed to be parsable according
1540      * to the grammar in the RFC.
1541      *
1542      * @param   path
1543      *          the path to the file to probe
1544      *
1545      * @return  The content type of the file, or {@code null} if the content
1546      *          type cannot be determined
1547      *
1548      * @throws  IOException
1549      *          if an I/O error occurs
1550      * @throws  SecurityException
1551      *          If a security manager is installed and it denies an unspecified
1552      *          permission required by a file type detector implementation.
1553      */
1554     public static String probeContentType(Path path)
1555         throws IOException
1556     {
1557         // try installed file type detectors
1558         for (FileTypeDetector detector: FileTypeDetectors.installeDetectors) {
1559             String result = detector.probeContentType(path);
1560             if (result != null)
1561                 return result;
1562         }
1563 
1564         // fallback to default
1565         return FileTypeDetectors.defaultFileTypeDetector.probeContentType(path);
1566     }
1567 
1568     // -- File Attributes --
1569 
1570     /**
1571      * Returns a file attribute view of a given type.
1572      *
1573      * <p> A file attribute view provides a read-only or updatable view of a
1574      * set of file attributes. This method is intended to be used where the file
1575      * attribute view defines type-safe methods to read or update the file
1576      * attributes. The {@code type} parameter is the type of the attribute view
1577      * required and the method returns an instance of that type if supported.
1578      * The {@link BasicFileAttributeView} type supports access to the basic
1579      * attributes of a file. Invoking this method to select a file attribute
1580      * view of that type will always return an instance of that class.
1581      *
1582      * <p> The {@code options} array may be used to indicate how symbolic links
1583      * are handled by the resulting file attribute view for the case that the
1584      * file is a symbolic link. By default, symbolic links are followed. If the
1585      * option {@link LinkOption#NOFOLLOW_LINKS NOFOLLOW_LINKS} is present then
1586      * symbolic links are not followed. This option is ignored by implementations
1587      * that do not support symbolic links.
1588      *
1589      * <p> <b>Usage Example:</b>
1590      * Suppose we want read or set a file's ACL, if supported:
1591      * <pre>
1592      *     Path path = ...
1593      *     AclFileAttributeView view = Files.getFileAttributeView(path, AclFileAttributeView.class);
1594      *     if (view != null) {
1595      *         List&lt;AclEntry&gt acl = view.getAcl();
1596      *         :
1597      *     }
1598      * </pre>
1599      *
1600      *
1601      * @param   path
1602      *          the path to the file
1603      * @param   type
1604      *          the {@code Class} object corresponding to the file attribute view
1605      * @param   options
1606      *          options indicating how symbolic links are handled
1607      *
1608      * @return  a file attribute view of the specified type, or {@code null} if
1609      *          the attribute view type is not available
1610      */
1611     public static <V extends FileAttributeView> V getFileAttributeView(Path path,
1612                                                                        Class<V> type,
1613                                                                        LinkOption... options)
1614     {
1615         return provider(path).getFileAttributeView(path, type, options);
1616     }
1617 
1618     /**
1619      * Reads a file's attributes as a bulk operation.
1620      *
1621      * <p> The {@code type} parameter is the type of the attributes required
1622      * and this method returns an instance of that type if supported. All
1623      * implementations support a basic set of file attributes and so invoking
1624      * this method with a  {@code type} parameter of {@code
1625      * BasicFileAttributes.class} will not throw {@code
1626      * UnsupportedOperationException}.
1627      *
1628      * <p> The {@code options} array may be used to indicate how symbolic links
1629      * are handled for the case that the file is a symbolic link. By default,
1630      * symbolic links are followed and the file attribute of the final target
1631      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
1632      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
1633      *
1634      * <p> It is implementation specific if all file attributes are read as an
1635      * atomic operation with respect to other file system operations.
1636      *
1637      * <p> <b>Usage Example:</b>
1638      * Suppose we want to read a file's attributes in bulk:
1639      * <pre>
1640      *    Path path = ...
1641      *    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
1642      * </pre>
1643      * Alternatively, suppose we want to read file's POSIX attributes without
1644      * following symbolic links:
1645      * <pre>
1646      *    PosixFileAttributes attrs = Files.readAttributes(path, PosixFileAttributes.class, NOFOLLOW_LINKS);
1647      * </pre>
1648      *
1649      * @param   path
1650      *          the path to the file
1651      * @param   type
1652      *          the {@code Class} of the file attributes required
1653      *          to read
1654      * @param   options
1655      *          options indicating how symbolic links are handled
1656      *
1657      * @return  the file attributes
1658      *
1659      * @throws  UnsupportedOperationException
1660      *          if an attributes of the given type are not supported
1661      * @throws  IOException
1662      *          if an I/O error occurs
1663      * @throws  SecurityException
1664      *          In the case of the default provider, a security manager is
1665      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
1666      *          method is invoked to check read access to the file. If this
1667      *          method is invoked to read security sensitive attributes then the
1668      *          security manager may be invoke to check for additional permissions.
1669      */
1670     public static <A extends BasicFileAttributes> A readAttributes(Path path,
1671                                                                    Class<A> type,
1672                                                                    LinkOption... options)
1673         throws IOException
1674     {
1675         return provider(path).readAttributes(path, type, options);
1676     }
1677 
1678     /**
1679      * Sets the value of a file attribute.
1680      *
1681      * <p> The {@code attribute} parameter identifies the attribute to be set
1682      * and takes the form:
1683      * <blockquote>
1684      * [<i>view-name</i><b>:</b>]<i>attribute-name</i>
1685      * </blockquote>
1686      * where square brackets [...] delineate an optional component and the
1687      * character {@code ':'} stands for itself.
1688      *
1689      * <p> <i>view-name</i> is the {@link FileAttributeView#name name} of a {@link
1690      * FileAttributeView} that identifies a set of file attributes. If not
1691      * specified then it defaults to {@code "basic"}, the name of the file
1692      * attribute view that identifies the basic set of file attributes common to
1693      * many file systems. <i>attribute-name</i> is the name of the attribute
1694      * within the set.
1695      *
1696      * <p> The {@code options} array may be used to indicate how symbolic links
1697      * are handled for the case that the file is a symbolic link. By default,
1698      * symbolic links are followed and the file attribute of the final target
1699      * of the link is set. If the option {@link LinkOption#NOFOLLOW_LINKS
1700      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
1701      *
1702      * <p> <b>Usage Example:</b>
1703      * Suppose we want to set the DOS "hidden" attribute:
1704      * <pre>
1705      *    Path path = ...
1706      *    Files.setAttribute(path, "dos:hidden", true);
1707      * </pre>
1708      *
1709      * @param   path
1710      *          the path to the file
1711      * @param   attribute
1712      *          the attribute to set
1713      * @param   value
1714      *          the attribute value
1715      * @param   options
1716      *          options indicating how symbolic links are handled
1717      *
1718      * @return  the {@code path} parameter
1719      *
1720      * @throws  UnsupportedOperationException
1721      *          if the attribute view is not available
1722      * @throws  IllegalArgumentException
1723      *          if the attribute name is not specified, or is not recognized, or
1724      *          the attribute value is of the correct type but has an
1725      *          inappropriate value
1726      * @throws  ClassCastException
1727      *          if the attribute value is not of the expected type or is a
1728      *          collection containing elements that are not of the expected
1729      *          type
1730      * @throws  IOException
1731      *          if an I/O error occurs
1732      * @throws  SecurityException
1733      *          In the case of the default provider, and a security manager is
1734      *          installed, its {@link SecurityManager#checkWrite(String) checkWrite}
1735      *          method denies write access to the file. If this method is invoked
1736      *          to set security sensitive attributes then the security manager
1737      *          may be invoked to check for additional permissions.
1738      */
1739     public static Path setAttribute(Path path, String attribute, Object value,
1740                                     LinkOption... options)
1741         throws IOException
1742     {
1743         provider(path).setAttribute(path, attribute, value, options);
1744         return path;
1745     }
1746 
1747     /**
1748      * Reads the value of a file attribute.
1749      *
1750      * <p> The {@code attribute} parameter identifies the attribute to be read
1751      * and takes the form:
1752      * <blockquote>
1753      * [<i>view-name</i><b>:</b>]<i>attribute-name</i>
1754      * </blockquote>
1755      * where square brackets [...] delineate an optional component and the
1756      * character {@code ':'} stands for itself.
1757      *
1758      * <p> <i>view-name</i> is the {@link FileAttributeView#name name} of a {@link
1759      * FileAttributeView} that identifies a set of file attributes. If not
1760      * specified then it defaults to {@code "basic"}, the name of the file
1761      * attribute view that identifies the basic set of file attributes common to
1762      * many file systems. <i>attribute-name</i> is the name of the attribute.
1763      *
1764      * <p> The {@code options} array may be used to indicate how symbolic links
1765      * are handled for the case that the file is a symbolic link. By default,
1766      * symbolic links are followed and the file attribute of the final target
1767      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
1768      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
1769      *
1770      * <p> <b>Usage Example:</b>
1771      * Suppose we require the user ID of the file owner on a system that
1772      * supports a "{@code unix}" view:
1773      * <pre>
1774      *    Path path = ...
1775      *    int uid = (Integer)Files.getAttribute(path, "unix:uid");
1776      * </pre>
1777      *
1778      * @param   path
1779      *          the path to the file
1780      * @param   attribute
1781      *          the attribute to read
1782      * @param   options
1783      *          options indicating how symbolic links are handled
1784      *
1785      * @return  the attribute value
1786      *
1787      * @throws  UnsupportedOperationException
1788      *          if the attribute view is not available
1789      * @throws  IllegalArgumentException
1790      *          if the attribute name is not specified or is not recognized
1791      * @throws  IOException
1792      *          if an I/O error occurs
1793      * @throws  SecurityException
1794      *          In the case of the default provider, and a security manager is
1795      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
1796      *          method denies read access to the file. If this method is invoked
1797      *          to read security sensitive attributes then the security manager
1798      *          may be invoked to check for additional permissions.
1799      */
1800     public static Object getAttribute(Path path, String attribute,
1801                                       LinkOption... options)
1802         throws IOException
1803     {
1804         // only one attribute should be read
1805         if (attribute.indexOf('*') >= 0 || attribute.indexOf(',') >= 0)
1806             throw new IllegalArgumentException(attribute);
1807         Map<String,Object> map = readAttributes(path, attribute, options);
1808         assert map.size() == 1;
1809         String name;
1810         int pos = attribute.indexOf(':');
1811         if (pos == -1) {
1812             name = attribute;
1813         } else {
1814             name = (pos == attribute.length()) ? "" : attribute.substring(pos+1);
1815         }
1816         return map.get(name);
1817     }
1818 
1819     /**
1820      * Reads a set of file attributes as a bulk operation.
1821      *
1822      * <p> The {@code attributes} parameter identifies the attributes to be read
1823      * and takes the form:
1824      * <blockquote>
1825      * [<i>view-name</i><b>:</b>]<i>attribute-list</i>
1826      * </blockquote>
1827      * where square brackets [...] delineate an optional component and the
1828      * character {@code ':'} stands for itself.
1829      *
1830      * <p> <i>view-name</i> is the {@link FileAttributeView#name name} of a {@link
1831      * FileAttributeView} that identifies a set of file attributes. If not
1832      * specified then it defaults to {@code "basic"}, the name of the file
1833      * attribute view that identifies the basic set of file attributes common to
1834      * many file systems.
1835      *
1836      * <p> The <i>attribute-list</i> component is a comma separated list of
1837      * zero or more names of attributes to read. If the list contains the value
1838      * {@code "*"} then all attributes are read. Attributes that are not supported
1839      * are ignored and will not be present in the returned map. It is
1840      * implementation specific if all attributes are read as an atomic operation
1841      * with respect to other file system operations.
1842      *
1843      * <p> The following examples demonstrate possible values for the {@code
1844      * attributes} parameter:
1845      *
1846      * <blockquote>
1847      * <table border="0">
1848      * <tr>
1849      *   <td> {@code "*"} </td>
1850      *   <td> Read all {@link BasicFileAttributes basic-file-attributes}. </td>
1851      * </tr>
1852      * <tr>
1853      *   <td> {@code "size,lastModifiedTime,lastAccessTime"} </td>
1854      *   <td> Reads the file size, last modified time, and last access time
1855      *     attributes. </td>
1856      * </tr>
1857      * <tr>
1858      *   <td> {@code "posix:*"} </td>
1859      *   <td> Read all {@link PosixFileAttributes POSIX-file-attributes}. </td>
1860      * </tr>
1861      * <tr>
1862      *   <td> {@code "posix:permissions,owner,size"} </td>
1863      *   <td> Reads the POSX file permissions, owner, and file size. </td>
1864      * </tr>
1865      * </table>
1866      * </blockquote>
1867      *
1868      * <p> The {@code options} array may be used to indicate how symbolic links
1869      * are handled for the case that the file is a symbolic link. By default,
1870      * symbolic links are followed and the file attribute of the final target
1871      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
1872      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
1873      *
1874      * @param   path
1875      *          the path to the file
1876      * @param   attributes
1877      *          the attributes to read
1878      * @param   options
1879      *          options indicating how symbolic links are handled
1880      *
1881      * @return  a map of the attributes returned; The map's keys are the
1882      *          attribute names, its values are the attribute values
1883      *
1884      * @throws  UnsupportedOperationException
1885      *          if the attribute view is not available
1886      * @throws  IllegalArgumentException
1887      *          if no attributes are specified or an unrecognized attributes is
1888      *          specified
1889      * @throws  IOException
1890      *          if an I/O error occurs
1891      * @throws  SecurityException
1892      *          In the case of the default provider, and a security manager is
1893      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
1894      *          method denies read access to the file. If this method is invoked
1895      *          to read security sensitive attributes then the security manager
1896      *          may be invoke to check for additional permissions.
1897      */
1898     public static Map<String,Object> readAttributes(Path path, String attributes,
1899                                                     LinkOption... options)
1900         throws IOException
1901     {
1902         return provider(path).readAttributes(path, attributes, options);
1903     }
1904 
1905     /**
1906      * Returns a file's POSIX file permissions.
1907      *
1908      * <p> The {@code path} parameter is associated with a {@code FileSystem}
1909      * that supports the {@link PosixFileAttributeView}. This attribute view
1910      * provides access to file attributes commonly associated with files on file
1911      * systems used by operating systems that implement the Portable Operating
1912      * System Interface (POSIX) family of standards.
1913      *
1914      * <p> The {@code options} array may be used to indicate how symbolic links
1915      * are handled for the case that the file is a symbolic link. By default,
1916      * symbolic links are followed and the file attribute of the final target
1917      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
1918      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
1919      *
1920      * @param   path
1921      *          the path to the file
1922      * @param   options
1923      *          options indicating how symbolic links are handled
1924      *
1925      * @return  the file permissions
1926      *
1927      * @throws  UnsupportedOperationException
1928      *          if the associated file system does not support the {@code
1929      *          PosixFileAttributeView}
1930      * @throws  IOException
1931      *          if an I/O error occurs
1932      * @throws  SecurityException
1933      *          In the case of the default provider, a security manager is
1934      *          installed, and it denies {@link RuntimePermission}<tt>("accessUserInformation")</tt>
1935      *          or its {@link SecurityManager#checkRead(String) checkRead} method
1936      *          denies read access to the file.
1937      */
1938     public static Set<PosixFilePermission> getPosixFilePermissions(Path path,
1939                                                                    LinkOption... options)
1940         throws IOException
1941     {
1942         return readAttributes(path, PosixFileAttributes.class, options).permissions();
1943     }
1944 
1945     /**
1946      * Sets a file's POSIX permissions.
1947      *
1948      * <p> The {@code path} parameter is associated with a {@code FileSystem}
1949      * that supports the {@link PosixFileAttributeView}. This attribute view
1950      * provides access to file attributes commonly associated with files on file
1951      * systems used by operating systems that implement the Portable Operating
1952      * System Interface (POSIX) family of standards.
1953      *
1954      * @param   path
1955      *          A file reference that locates the file
1956      * @param   perms
1957      *          The new set of permissions
1958      *
1959      * @throws  UnsupportedOperationException
1960      *          if the associated file system does not support the {@code
1961      *          PosixFileAttributeView}
1962      * @throws  ClassCastException
1963      *          if the sets contains elements that are not of type {@code
1964      *          PosixFilePermission}
1965      * @throws  IOException
1966      *          if an I/O error occurs
1967      * @throws  SecurityException
1968      *          In the case of the default provider, and a security manager is
1969      *          installed, it denies {@link RuntimePermission}<tt>("accessUserInformation")</tt>
1970      *          or its {@link SecurityManager#checkWrite(String) checkWrite}
1971      *          method denies write access to the file.
1972      */
1973     public static Path setPosixFilePermissions(Path path,
1974                                                Set<PosixFilePermission> perms)
1975         throws IOException
1976     {
1977         PosixFileAttributeView view =
1978             getFileAttributeView(path, PosixFileAttributeView.class);
1979         if (view == null)
1980             throw new UnsupportedOperationException();
1981         view.setPermissions(perms);
1982         return path;
1983     }
1984 
1985     /**
1986      * Returns the owner of a file.
1987      *
1988      * <p> The {@code path} parameter is associated with a file system that
1989      * supports {@link FileOwnerAttributeView}. This file attribute view provides
1990      * access to a file attribute that is the owner of the file.
1991      *
1992      * @param   path
1993      *          A file reference that locates the file
1994      * @param   options
1995      *          options indicating how symbolic links are handled
1996      *
1997      * @return  A user principal representing the owner of the file
1998      *
1999      * @throws  UnsupportedOperationException
2000      *          if the associated file system does not support the {@code
2001      *          FileOwnerAttributeView}
2002      * @throws  IOException
2003      *          if an I/O error occurs
2004      * @throws  SecurityException
2005      *          In the case of the default provider, and a security manager is
2006      *          installed, it denies {@link RuntimePermission}<tt>("accessUserInformation")</tt>
2007      *          or its {@link SecurityManager#checkRead(String) checkRead} method
2008      *          denies read access to the file.
2009      */
2010     public static UserPrincipal getOwner(Path path, LinkOption... options) throws IOException {
2011         FileOwnerAttributeView view =
2012             getFileAttributeView(path, FileOwnerAttributeView.class, options);
2013         if (view == null)
2014             throw new UnsupportedOperationException();
2015         return view.getOwner();
2016     }
2017 
2018     /**
2019      * Updates the file owner.
2020      *
2021      * <p> The {@code path} parameter is associated with a file system that
2022      * supports {@link FileOwnerAttributeView}. This file attribute view provides
2023      * access to a file attribute that is the owner of the file.
2024      *
2025      * <p> <b>Usage Example:</b>
2026      * Suppose we want to make "joe" the owner of a file:
2027      * <pre>
2028      *     Path path = ...
2029      *     UserPrincipalLookupService lookupService =
2030      *         provider(path).getUserPrincipalLookupService();
2031      *     UserPrincipal joe = lookupService.lookupPrincipalByName("joe");
2032      *     Files.setOwner(path, joe);
2033      * </pre>
2034      *
2035      * @param   path
2036      *          A file reference that locates the file
2037      * @param   owner
2038      *          The new file owner
2039      *
2040      * @throws  UnsupportedOperationException
2041      *          if the associated file system does not support the {@code
2042      *          FileOwnerAttributeView}
2043      * @throws  IOException
2044      *          if an I/O error occurs
2045      * @throws  SecurityException
2046      *          In the case of the default provider, and a security manager is
2047      *          installed, it denies {@link RuntimePermission}<tt>("accessUserInformation")</tt>
2048      *          or its {@link SecurityManager#checkWrite(String) checkWrite}
2049      *          method denies write access to the file.
2050      *
2051      * @see FileSystem#getUserPrincipalLookupService
2052      * @see java.nio.file.attribute.UserPrincipalLookupService
2053      */
2054     public static Path setOwner(Path path, UserPrincipal owner)
2055         throws IOException
2056     {
2057         FileOwnerAttributeView view =
2058             getFileAttributeView(path, FileOwnerAttributeView.class);
2059         if (view == null)
2060             throw new UnsupportedOperationException();
2061         view.setOwner(owner);
2062         return path;
2063     }
2064 
2065     /**
2066      * Tests whether a file is a symbolic link.
2067      *
2068      * <p> Where is it required to distinguish an I/O exception from the case
2069      * that the file is not a symbolic link then the file attributes can be
2070      * read with the {@link #readAttributes(Path,Class,LinkOption[])
2071      * readAttributes} method and the file type tested with the {@link
2072      * BasicFileAttributes#isSymbolicLink} method.
2073      *
2074      * @return  {@code true} if the file is a symbolic link; {@code false} if
2075      *          the file does not exist, is not a symbolic link, or it cannot
2076      *          be determined if the file is a symbolic link or not.
2077      *
2078      * @throws  SecurityException
2079      *          In the case of the default provider, and a security manager is
2080      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
2081      *          method denies read access to the file.
2082      */
2083     public static boolean isSymbolicLink(Path path) {
2084         try {
2085             return readAttributes(path,
2086                                   BasicFileAttributes.class,
2087                                   LinkOption.NOFOLLOW_LINKS).isSymbolicLink();
2088         } catch (IOException ioe) {
2089             return false;
2090         }
2091     }
2092 
2093     /**
2094      * Tests whether a file is a directory.
2095      *
2096      * <p> The {@code options} array may be used to indicate how symbolic links
2097      * are handled for the case that the file is a symbolic link. By default,
2098      * symbolic links are followed and the file attribute of the final target
2099      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
2100      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
2101      *
2102      * <p> Where is it required to distinguish an I/O exception from the case
2103      * that the file is not a directory then the file attributes can be
2104      * read with the {@link #readAttributes(Path,Class,LinkOption[])
2105      * readAttributes} method and the file type tested with the {@link
2106      * BasicFileAttributes#isDirectory} method.
2107      *
2108      * @param   path
2109      *          the path to the file to test
2110      * @param   options
2111      *          options indicating how symbolic links are handled
2112      *
2113      * @return  {@code true} if the file is a directory; {@code false} if
2114      *          the file does not exist, is not a directory, or it cannot
2115      *          be determined if the file is a directory or not.
2116      *
2117      * @throws  SecurityException
2118      *          In the case of the default provider, and a security manager is
2119      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
2120      *          method denies read access to the file.
2121      */
2122     public static boolean isDirectory(Path path, LinkOption... options) {
2123         try {
2124             return readAttributes(path, BasicFileAttributes.class, options).isDirectory();
2125         } catch (IOException ioe) {
2126             return false;
2127         }
2128     }
2129 
2130     /**
2131      * Tests whether a file is a regular file with opaque content.
2132      *
2133      * <p> The {@code options} array may be used to indicate how symbolic links
2134      * are handled for the case that the file is a symbolic link. By default,
2135      * symbolic links are followed and the file attribute of the final target
2136      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
2137      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
2138      *
2139      * <p> Where is it required to distinguish an I/O exception from the case
2140      * that the file is not a regular file then the file attributes can be
2141      * read with the {@link #readAttributes(Path,Class,LinkOption[])
2142      * readAttributes} method and the file type tested with the {@link
2143      * BasicFileAttributes#isRegularFile} method.
2144      *
2145      * @param   path
2146      *          the path to the file
2147      * @param   options
2148      *          options indicating how symbolic links are handled
2149      *
2150      * @return  {@code true} if the file is a regular file; {@code false} if
2151      *          the file does not exist, is not a regular file, or it
2152      *          cannot be determined if the file is a regular file or not.
2153      *
2154      * @throws  SecurityException
2155      *          In the case of the default provider, and a security manager is
2156      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
2157      *          method denies read access to the file.
2158      */
2159     public static boolean isRegularFile(Path path, LinkOption... options) {
2160         try {
2161             return readAttributes(path, BasicFileAttributes.class, options).isRegularFile();
2162         } catch (IOException ioe) {
2163             return false;
2164         }
2165     }
2166 
2167     /**
2168      * Returns a file's last modified time.
2169      *
2170      * <p> The {@code options} array may be used to indicate how symbolic links
2171      * are handled for the case that the file is a symbolic link. By default,
2172      * symbolic links are followed and the file attribute of the final target
2173      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
2174      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
2175      *
2176      * @param   path
2177      *          the path to the file
2178      * @param   options
2179      *          options indicating how symbolic links are handled
2180      *
2181      * @return  a {@code FileTime} representing the time the file was last
2182      *          modified, or an implementation specific default when a time
2183      *          stamp to indicate the time of last modification is not supported
2184      *          by the file system
2185      *
2186      * @throws  IOException
2187      *          if an I/O error occurs
2188      * @throws  SecurityException
2189      *          In the case of the default provider, and a security manager is
2190      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
2191      *          method denies read access to the file.
2192      *
2193      * @see BasicFileAttributes#lastModifiedTime
2194      */
2195     public static FileTime getLastModifiedTime(Path path, LinkOption... options)
2196         throws IOException
2197     {
2198         return readAttributes(path, BasicFileAttributes.class, options).lastModifiedTime();
2199     }
2200 
2201     /**
2202      * Updates a file's last modified time attribute. The file time is converted
2203      * to the epoch and precision supported by the file system. Converting from
2204      * finer to coarser granularities result in precision loss. The behavior of
2205      * this method when attempting to set the last modified time when it is not
2206      * supported by the file system or is outside the range supported by the
2207      * underlying file store is not defined. It may or not fail by throwing an
2208      * {@code IOException}.
2209      *
2210      * <p> <b>Usage Example:</b>
2211      * Suppose we want to set the last modified time to the current time:
2212      * <pre>
2213      *    Path path = ...
2214      *    FileTime now = FileTime.fromMillis(System.currentTimeMillis());
2215      *    Files.setLastModifiedTime(path, now);
2216      * </pre>
2217      *
2218      * @param   path
2219      *          the path to the file
2220      * @param   time
2221      *          the new last modified time
2222      *
2223      * @return  the file
2224      *
2225      * @throws  IOException
2226      *          if an I/O error occurs
2227      * @throws  SecurityException
2228      *          In the case of the default provider, the security manager's {@link
2229      *          SecurityManager#checkWrite(String) checkWrite} method is invoked
2230      *          to check write access to file
2231      *
2232      * @see BasicFileAttributeView#setTimes
2233      */
2234     public static Path setLastModifiedTime(Path path, FileTime time)
2235         throws IOException
2236     {
2237         getFileAttributeView(path, BasicFileAttributeView.class)
2238             .setTimes(time, null, null);
2239         return path;
2240     }
2241 
2242     /**
2243      * Returns the size of a file (in bytes). The size may differ from the
2244      * actual size on the file system due to compression, support for sparse
2245      * files, or other reasons. The size of files that are not {@link
2246      * #isRegularFile regular} files is implementation specific and
2247      * therefore unspecified.
2248      *
2249      * @param   path
2250      *          the path to the file
2251      *
2252      * @return  the file size, in bytes
2253      *
2254      * @throws  IOException
2255      *          if an I/O error occurs
2256      * @throws  SecurityException
2257      *          In the case of the default provider, and a security manager is
2258      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
2259      *          method denies read access to the file.
2260      *
2261      * @see BasicFileAttributes#size
2262      */
2263     public static long size(Path path) throws IOException {
2264         return readAttributes(path, BasicFileAttributes.class).size();
2265     }
2266 
2267     // -- Accessibility --
2268 
2269     /**
2270      * Returns {@code false} if NOFOLLOW_LINKS is present.
2271      */
2272     private static boolean followLinks(LinkOption... options) {
2273         boolean followLinks = true;
2274         for (LinkOption opt: options) {
2275             if (opt == LinkOption.NOFOLLOW_LINKS) {
2276                 followLinks = false;
2277                 continue;
2278             }
2279             if (opt == null)
2280                 throw new NullPointerException();
2281             throw new AssertionError("Should not get here");
2282         }
2283         return followLinks;
2284     }
2285 
2286     /**
2287      * Tests whether a file exists.
2288      *
2289      * <p> The {@code options} parameter may be used to indicate how symbolic links
2290      * are handled for the case that the file is a symbolic link. By default,
2291      * symbolic links are followed. If the option {@link LinkOption#NOFOLLOW_LINKS
2292      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
2293      *
2294      * <p> Note that the result of this method is immediately outdated. If this
2295      * method indicates the file exists then there is no guarantee that a
2296      * subsequence access will succeed. Care should be taken when using this
2297      * method in security sensitive applications.
2298      *
2299      * @param   path
2300      *          the path to the file to test
2301      * @param   options
2302      *          options indicating how symbolic links are handled
2303      * .
2304      * @return  {@code true} if the file exists; {@code false} if the file does
2305      *          not exist or its existence cannot be determined.
2306      *
2307      * @throws  SecurityException
2308      *          In the case of the default provider, the {@link
2309      *          SecurityManager#checkRead(String)} is invoked to check
2310      *          read access to the file.
2311      *
2312      * @see #notExists
2313      */
2314     public static boolean exists(Path path, LinkOption... options) {
2315         try {
2316             if (followLinks(options)) {
2317                 provider(path).checkAccess(path);
2318             } else {
2319                 // attempt to read attributes without following links
2320                 readAttributes(path, BasicFileAttributes.class,
2321                                LinkOption.NOFOLLOW_LINKS);
2322             }
2323             // file exists
2324             return true;
2325         } catch (IOException x) {
2326             // does not exist or unable to determine if file exists
2327             return false;
2328         }
2329 
2330     }
2331 
2332     /**
2333      * Tests whether the file located by this path does not exist. This method
2334      * is intended for cases where it is required to take action when it can be
2335      * confirmed that a file does not exist.
2336      *
2337      * <p> The {@code options} parameter may be used to indicate how symbolic links
2338      * are handled for the case that the file is a symbolic link. By default,
2339      * symbolic links are followed. If the option {@link LinkOption#NOFOLLOW_LINKS
2340      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
2341      *
2342      * <p> Note that this method is not the complement of the {@link #exists
2343      * exists} method. Where it is not possible to determine if a file exists
2344      * or not then both methods return {@code false}. As with the {@code exists}
2345      * method, the result of this method is immediately outdated. If this
2346      * method indicates the file does exist then there is no guarantee that a
2347      * subsequence attempt to create the file will succeed. Care should be taken
2348      * when using this method in security sensitive applications.
2349      *
2350      * @param   path
2351      *          the path to the file to test
2352      * @param   options
2353      *          options indicating how symbolic links are handled
2354      *
2355      * @return  {@code true} if the file does not exist; {@code false} if the
2356      *          file exists or its existence cannot be determined
2357      *
2358      * @throws  SecurityException
2359      *          In the case of the default provider, the {@link
2360      *          SecurityManager#checkRead(String)} is invoked to check
2361      *          read access to the file.
2362      */
2363     public static boolean notExists(Path path, LinkOption... options) {
2364         try {
2365             if (followLinks(options)) {
2366                 provider(path).checkAccess(path);
2367             } else {
2368                 // attempt to read attributes without following links
2369                 readAttributes(path, BasicFileAttributes.class,
2370                                LinkOption.NOFOLLOW_LINKS);
2371             }
2372             // file exists
2373             return false;
2374         } catch (NoSuchFileException x) {
2375             // file confirmed not to exist
2376             return true;
2377         } catch (IOException x) {
2378             return false;
2379         }
2380     }
2381 
2382     /**
2383      * Used by isReadbale, isWritable, isExecutable to test access to a file.
2384      */
2385     private static boolean isAccessible(Path path, AccessMode... modes) {
2386         try {
2387             provider(path).checkAccess(path, modes);
2388             return true;
2389         } catch (IOException x) {
2390             return false;
2391         }
2392     }
2393 
2394     /**
2395      * Tests whether a file is readable. This method checks that a file exists
2396      * and that this Java virtual machine has appropriate privileges that would
2397      * allow it open the file for reading. Depending on the implementation, this
2398      * method may require to read file permissions, access control lists, or
2399      * other file attributes in order to check the effective access to the file.
2400      * Consequently, this method may not be atomic with respect to other file
2401      * system operations.
2402      *
2403      * <p> Note that the result of this method is immediately outdated, there is
2404      * no guarantee that a subsequent attempt to open the file for reading will
2405      * succeed (or even that it will access the same file). Care should be taken
2406      * when using this method in security sensitive applications.
2407      *
2408      * @param   path
2409      *          the path to the file to check
2410      *
2411      * @return  {@code true} if the file exists and is readable; {@code false}
2412      *          if the file does not exist, read access would be denied because
2413      *          the Java virtual machine has insufficient privileges, or access
2414      *          cannot be determined
2415      *
2416      * @throws  SecurityException
2417      *          In the case of the default provider, and a security manager is
2418      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
2419      *          is invoked to check read access to the file.
2420      */
2421     public static boolean isReadable(Path path) {
2422         return isAccessible(path, AccessMode.READ);
2423     }
2424 
2425     /**
2426      * Tests whether a file is writable. This method checks that a file exists
2427      * and that this Java virtual machine has appropriate privileges that would
2428      * allow it open the file for writing. Depending on the implementation, this
2429      * method may require to read file permissions, access control lists, or
2430      * other file attributes in order to check the effective access to the file.
2431      * Consequently, this method may not be atomic with respect to other file
2432      * system operations.
2433      *
2434      * <p> Note that result of this method is immediately outdated, there is no
2435      * guarantee that a subsequent attempt to open the file for writing will
2436      * succeed (or even that it will access the same file). Care should be taken
2437      * when using this method in security sensitive applications.
2438      *
2439      * @param   path
2440      *          the path to the file to check
2441      *
2442      * @return  {@code true} if the file exists and is writable; {@code false}
2443      *          if the file does not exist, write access would be denied because
2444      *          the Java virtual machine has insufficient privileges, or access
2445      *          cannot be determined
2446      *
2447      * @throws  SecurityException
2448      *          In the case of the default provider, and a security manager is
2449      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
2450      *          is invoked to check write access to the file.
2451      */
2452     public static boolean isWritable(Path path) {
2453         return isAccessible(path, AccessMode.WRITE);
2454     }
2455 
2456     /**
2457      * Tests whether a file is executable. This method checks that a file exists
2458      * and that this Java virtual machine has appropriate privileges to {@link
2459      * Runtime#exec execute} the file. The semantics may differ when checking
2460      * access to a directory. For example, on UNIX systems, checking for
2461      * execute access checks that the Java virtual machine has permission to
2462      * search the directory in order to access file or subdirectories.
2463      *
2464      * <p> Depending on the implementation, this method may require to read file
2465      * permissions, access control lists, or other file attributes in order to
2466      * check the effective access to the file. Consequently, this method may not
2467      * be atomic with respect to other file system operations.
2468      *
2469      * <p> Note that the result of this method is immediately outdated, there is
2470      * no guarantee that a subsequent attempt to execute the file will succeed
2471      * (or even that it will access the same file). Care should be taken when
2472      * using this method in security sensitive applications.
2473      *
2474      * @param   path
2475      *          the path to the file to check
2476      *
2477      * @return  {@code true} if the file exists and is executable; {@code false}
2478      *          if the file does not exist, execute access would be denied because
2479      *          the Java virtual machine has insufficient privileges, or access
2480      *          cannot be determined
2481      *
2482      * @throws  SecurityException
2483      *          In the case of the default provider, and a security manager is
2484      *          installed, the {@link SecurityManager#checkExec(String)
2485      *          checkExec} is invoked to check execute access to the file.
2486      */
2487     public static boolean isExecutable(Path path) {
2488        return isAccessible(path, AccessMode.EXECUTE);
2489     }
2490 
2491     // -- Recursive operations --
2492 
2493     /**
2494      * Walks a file tree.
2495      *
2496      * <p> This method walks a file tree rooted at a given starting file. The
2497      * file tree traversal is <em>depth-first</em> with the given {@link
2498      * FileVisitor} invoked for each file encountered. File tree traversal
2499      * completes when all accessible files in the tree have been visited, or a
2500      * visit method returns a result of {@link FileVisitResult#TERMINATE
2501      * TERMINATE}. Where a visit method terminates due an {@code IOException},
2502      * an uncaught error, or runtime exception, then the traversal is terminated
2503      * and the error or exception is propagated to the caller of this method.
2504      *
2505      * <p> For each file encountered this method attempts to read its {@link
2506      * java.nio.file.attribute.BasicFileAttributes}. If the file is not a
2507      * directory then the {@link FileVisitor#visitFile visitFile} method is
2508      * invoked with the file attributes. If the file attributes cannot be read,
2509      * due to an I/O exception, then the {@link FileVisitor#visitFileFailed
2510      * visitFileFailed} method is invoked with the I/O exception.
2511      *
2512      * <p> Where the file is a directory, and the directory could not be opened,
2513      * then the {@code visitFileFailed} method is invoked with the I/O exception,
2514      * after which, the file tree walk continues, by default, at the next
2515      * <em>sibling</em> of the directory.
2516      *
2517      * <p> Where the directory is opened successfully, then the entries in the
2518      * directory, and their <em>descendants</em> are visited. When all entries
2519      * have been visited, or an I/O error occurs during iteration of the
2520      * directory, then the directory is closed and the visitor's {@link
2521      * FileVisitor#postVisitDirectory postVisitDirectory} method is invoked.
2522      * The file tree walk then continues, by default, at the next <em>sibling</em>
2523      * of the directory.
2524      *
2525      * <p> By default, symbolic links are not automatically followed by this
2526      * method. If the {@code options} parameter contains the {@link
2527      * FileVisitOption#FOLLOW_LINKS FOLLOW_LINKS} option then symbolic links are
2528      * followed. When following links, and the attributes of the target cannot
2529      * be read, then this method attempts to get the {@code BasicFileAttributes}
2530      * of the link. If they can be read then the {@code visitFile} method is
2531      * invoked with the attributes of the link (otherwise the {@code visitFileFailed}
2532      * method is invoked as specified above).
2533      *
2534      * <p> If the {@code options} parameter contains the {@link
2535      * FileVisitOption#FOLLOW_LINKS FOLLOW_LINKS} option then this method keeps
2536      * track of directories visited so that cycles can be detected. A cycle
2537      * arises when there is an entry in a directory that is an ancestor of the
2538      * directory. Cycle detection is done by recording the {@link
2539      * java.nio.file.attribute.BasicFileAttributes#fileKey file-key} of directories,
2540      * or if file keys are not available, by invoking the {@link #isSameFile
2541      * isSameFile} method to test if a directory is the same file as an
2542      * ancestor. When a cycle is detected it is treated as an I/O error, and the
2543      * {@link FileVisitor#visitFileFailed visitFileFailed} method is invoked with
2544      * an instance of {@link FileSystemLoopException}.
2545      *
2546      * <p> The {@code maxDepth} parameter is the maximum number of levels of
2547      * directories to visit. A value of {@code 0} means that only the starting
2548      * file is visited, unless denied by the security manager. A value of
2549      * {@link Integer#MAX_VALUE MAX_VALUE} may be used to indicate that all
2550      * levels should be visited. The {@code visitFile} method is invoked for all
2551      * files, including directories, encountered at {@code maxDepth}, unless the
2552      * basic file attributes cannot be read, in which case the {@code
2553      * visitFileFailed} method is invoked.
2554      *
2555      * <p> If a visitor returns a result of {@code null} then {@code
2556      * NullPointerException} is thrown.
2557      *
2558      * <p> When a security manager is installed and it denies access to a file
2559      * (or directory), then it is ignored and the visitor is not invoked for
2560      * that file (or directory).
2561      *
2562      * @param   start
2563      *          the starting file
2564      * @param   options
2565      *          options to configure the traversal
2566      * @param   maxDepth
2567      *          the maximum number of directory levels to visit
2568      * @param   visitor
2569      *          the file visitor to invoke for each file
2570      *
2571      * @return  the starting file
2572      *
2573      * @throws  IllegalArgumentException
2574      *          if the {@code maxDepth} parameter is negative
2575      * @throws  SecurityException
2576      *          If the security manager denies access to the starting file.
2577      *          In the case of the default provider, the {@link
2578      *          SecurityManager#checkRead(String) checkRead} method is invoked
2579      *          to check read access to the directory.
2580      * @throws  IOException
2581      *          if an I/O error is thrown by a visitor method
2582      */
2583     public static Path walkFileTree(Path start,
2584                                     Set<FileVisitOption> options,
2585                                     int maxDepth,
2586                                     FileVisitor<? super Path> visitor)
2587         throws IOException
2588     {
2589         if (maxDepth < 0)
2590             throw new IllegalArgumentException("'maxDepth' is negative");
2591         new FileTreeWalker(options, visitor, maxDepth).walk(start);
2592         return start;
2593     }
2594 
2595     /**
2596      * Walks a file tree.
2597      *
2598      * <p> This method works as if invoking it were equivalent to evaluating the
2599      * expression:
2600      * <blockquote><pre>
2601      * walkFileTree(start, EnumSet.noneOf(FileVisitOption.class), Integer.MAX_VALUE, visitor)
2602      * </pre></blockquote>
2603      * In other words, it does not follow symbolic links, and visits all levels
2604      * of the file tree.
2605      *
2606      * @param   start
2607      *          the starting file
2608      * @param   visitor
2609      *          the file visitor to invoke for each file
2610      *
2611      * @return  the starting file
2612      *
2613      * @throws  SecurityException
2614      *          If the security manager denies access to the starting file.
2615      *          In the case of the default provider, the {@link
2616      *          SecurityManager#checkRead(String) checkRead} method is invoked
2617      *          to check read access to the directory.
2618      * @throws  IOException
2619      *          if an I/O error is thrown by a visitor method
2620      */
2621     public static Path walkFileTree(Path start, FileVisitor<? super Path> visitor)
2622         throws IOException
2623     {
2624         return walkFileTree(start,
2625                             EnumSet.noneOf(FileVisitOption.class),
2626                             Integer.MAX_VALUE,
2627                             visitor);
2628     }
2629 
2630 
2631     // -- Utility methods for simple usages --
2632 
2633     // buffer size used for reading and writing
2634     private static final int BUFFER_SIZE = 8192;
2635 
2636     /**
2637      * Opens a file for reading, returning a {@code BufferedReader} that may be
2638      * used to read text from the file in an efficient manner. Bytes from the
2639      * file are decoded into characters using the specified charset. Reading
2640      * commences at the beginning of the file.
2641      *
2642      * <p> The {@code Reader} methods that read from the file throw {@code
2643      * IOException} if a malformed or unmappable byte sequence is read.
2644      *
2645      * @param   path
2646      *          the path to the file
2647      * @param   cs
2648      *          the charset to use for decoding
2649      *
2650      * @return  a new buffered reader, with default buffer size, to read text
2651      *          from the file
2652      *
2653      * @throws  IOException
2654      *          if an I/O error occurs opening the file
2655      * @throws  SecurityException
2656      *          In the case of the default provider, and a security manager is
2657      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
2658      *          method is invoked to check read access to the file.
2659      *
2660      * @see #readAllLines
2661      */
2662     public static BufferedReader newBufferedReader(Path path, Charset cs)
2663         throws IOException
2664     {
2665         CharsetDecoder decoder = cs.newDecoder();
2666         Reader reader = new InputStreamReader(newInputStream(path), decoder);
2667         return new BufferedReader(reader);
2668     }
2669 
2670     /**
2671      * Opens or creates a file for writing, returning a {@code BufferedWriter}
2672      * that may be used to write text to the file in an efficient manner.
2673      * The {@code options} parameter specifies how the the file is created or
2674      * opened. If no options are present then this method works as if the {@link
2675      * StandardOpenOption#CREATE CREATE}, {@link
2676      * StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING}, and {@link
2677      * StandardOpenOption#WRITE WRITE} options are present. In other words, it
2678      * opens the file for writing, creating the file if it doesn't exist, or
2679      * initially truncating an existing {@link #isRegularFile regular-file} to
2680      * a size of {@code 0} if it exists.
2681      *
2682      * <p> The {@code Writer} methods to write text throw {@code IOException}
2683      * if the text cannot be encoded using the specified charset.
2684      *
2685      * @param   path
2686      *          the path to the file
2687      * @param   cs
2688      *          the charset to use for encoding
2689      * @param   options
2690      *          options specifying how the file is opened
2691      *
2692      * @return  a new buffered writer, with default buffer size, to write text
2693      *          to the file
2694      *
2695      * @throws  IOException
2696      *          if an I/O error occurs opening or creating the file
2697      * @throws  UnsupportedOperationException
2698      *          if an unsupported option is specified
2699      * @throws  SecurityException
2700      *          In the case of the default provider, and a security manager is
2701      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
2702      *          method is invoked to check write access to the file.
2703      *
2704      * @see #write(Path,Iterable,Charset,OpenOption[])
2705      */
2706     public static BufferedWriter newBufferedWriter(Path path, Charset cs,
2707                                                    OpenOption... options)
2708         throws IOException
2709     {
2710         CharsetEncoder encoder = cs.newEncoder();
2711         Writer writer = new OutputStreamWriter(newOutputStream(path, options), encoder);
2712         return new BufferedWriter(writer);
2713     }
2714 
2715     /**
2716      * Reads all bytes from an input stream and writes them to an output stream.
2717      */
2718     private static long copy(InputStream source, OutputStream sink)
2719         throws IOException
2720     {
2721         long nread = 0L;
2722         byte[] buf = new byte[BUFFER_SIZE];
2723         int n;
2724         while ((n = source.read(buf)) > 0) {
2725             sink.write(buf, 0, n);
2726             nread += n;
2727         }
2728         return nread;
2729     }
2730 
2731     /**
2732      * Copies all bytes from an input stream to a file. On return, the input
2733      * stream will be at end of stream.
2734      *
2735      * <p> By default, the copy fails if the target file already exists or is a
2736      * symbolic link. If the {@link StandardCopyOption#REPLACE_EXISTING
2737      * REPLACE_EXISTING} option is specified, and the target file already exists,
2738      * then it is replaced if it is not a non-empty directory. If the target
2739      * file exists and is a symbolic link, then the symbolic link is replaced.
2740      * In this release, the {@code REPLACE_EXISTING} option is the only option
2741      * required to be supported by this method. Additional options may be
2742      * supported in future releases.
2743      *
2744      * <p>  If an I/O error occurs reading from the input stream or writing to
2745      * the file, then it may do so after the target file has been created and
2746      * after some bytes have been read or written. Consequently the input
2747      * stream may not be at end of stream and may be in an inconsistent state.
2748      * It is strongly recommended that the input stream be promptly closed if an
2749      * I/O error occurs.
2750      *
2751      * <p> This method may block indefinitely reading from the input stream (or
2752      * writing to the file). The behavior for the case that the input stream is
2753      * <i>asynchronously closed</i> or the thread interrupted during the copy is
2754      * highly input stream and file system provider specific and therefore not
2755      * specified.
2756      *
2757      * <p> <b>Usage example</b>: Suppose we want to capture a web page and save
2758      * it to a file:
2759      * <pre>
2760      *     Path path = ...
2761      *     URI u = URI.create("http://java.sun.com/");
2762      *     try (InputStream in = u.toURL().openStream()) {
2763      *         Files.copy(in, path);
2764      *     }
2765      * </pre>
2766      *
2767      * @param   in
2768      *          the input stream to read from
2769      * @param   target
2770      *          the path to the file
2771      * @param   options
2772      *          options specifying how the copy should be done
2773      *
2774      * @return  the number of bytes read or written
2775      *
2776      * @throws  IOException
2777      *          if an I/O error occurs when reading or writing
2778      * @throws  FileAlreadyExistsException
2779      *          if the target file exists but cannot be replaced because the
2780      *          {@code REPLACE_EXISTING} option is not specified <i>(optional
2781      *          specific exception)</i>
2782      * @throws  DirectoryNotEmptyException
2783      *          the {@code REPLACE_EXISTING} option is specified but the file
2784      *          cannot be replaced because it is a non-empty directory
2785      *          <i>(optional specific exception)</i>     *
2786      * @throws  UnsupportedOperationException
2787      *          if {@code options} contains a copy option that is not supported
2788      * @throws  SecurityException
2789      *          In the case of the default provider, and a security manager is
2790      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
2791      *          method is invoked to check write access to the file. Where the
2792      *          {@code REPLACE_EXISTING} option is specified, the security
2793      *          manager's {@link SecurityManager#checkDelete(String) checkDelete}
2794      *          method is invoked to check that an existing file can be deleted.
2795      */
2796     public static long copy(InputStream in, Path target, CopyOption... options)
2797         throws IOException
2798     {
2799         // ensure not null before opening file
2800         Objects.requireNonNull(in);
2801 
2802         // check for REPLACE_EXISTING
2803         boolean replaceExisting = false;
2804         for (CopyOption opt: options) {
2805             if (opt == StandardCopyOption.REPLACE_EXISTING) {
2806                 replaceExisting = true;
2807             } else {
2808                 if (opt == null) {
2809                     throw new NullPointerException("options contains 'null'");
2810                 }  else {
2811                     throw new UnsupportedOperationException(opt + " not supported");
2812                 }
2813             }
2814         }
2815 
2816         // attempt to delete an existing file
2817         SecurityException se = null;
2818         if (replaceExisting) {
2819             try {
2820                 deleteIfExists(target);
2821             } catch (SecurityException x) {
2822                 se = x;
2823             }
2824         }
2825 
2826         // attempt to create target file. If it fails with
2827         // FileAlreadyExistsException then it may be because the security
2828         // manager prevented us from deleting the file, in which case we just
2829         // throw the SecurityException.
2830         OutputStream ostream;
2831         try {
2832             ostream = newOutputStream(target, StandardOpenOption.CREATE_NEW,
2833                                               StandardOpenOption.WRITE);
2834         } catch (FileAlreadyExistsException x) {
2835             if (se != null)
2836                 throw se;
2837             // someone else won the race and created the file
2838             throw x;
2839         }
2840 
2841         // do the copy
2842         try (OutputStream out = ostream) {
2843             return copy(in, out);
2844         }
2845     }
2846 
2847     /**
2848      * Copies all bytes from a file to an output stream.
2849      *
2850      * <p> If an I/O error occurs reading from the file or writing to the output
2851      * stream, then it may do so after some bytes have been read or written.
2852      * Consequently the output stream may be in an inconsistent state. It is
2853      * strongly recommended that the output stream be promptly closed if an I/O
2854      * error occurs.
2855      *
2856      * <p> This method may block indefinitely writing to the output stream (or
2857      * reading from the file). The behavior for the case that the output stream
2858      * is <i>asynchronously closed</i> or the thread interrupted during the copy
2859      * is highly output stream and file system provider specific and therefore
2860      * not specified.
2861      *
2862      * <p> Note that if the given output stream is {@link java.io.Flushable}
2863      * then its {@link java.io.Flushable#flush flush} method may need to invoked
2864      * after this method completes so as to flush any buffered output.
2865      *
2866      * @param   source
2867      *          the  path to the file
2868      * @param   out
2869      *          the output stream to write to
2870      *
2871      * @return  the number of bytes read or written
2872      *
2873      * @throws  IOException
2874      *          if an I/O error occurs when reading or writing
2875      * @throws  SecurityException
2876      *          In the case of the default provider, and a security manager is
2877      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
2878      *          method is invoked to check read access to the file.
2879      */
2880     public static long copy(Path source, OutputStream out) throws IOException {
2881         // ensure not null before opening file
2882         Objects.requireNonNull(out);
2883 
2884         try (InputStream in = newInputStream(source)) {
2885             return copy(in, out);
2886         }
2887     }
2888 
2889     /**
2890      * Read all the bytes from an input stream. The {@code initialSize}
2891      * parameter indicates the initial size of the byte[] to allocate.
2892      */
2893     private static byte[] read(InputStream source, int initialSize)
2894         throws IOException
2895     {
2896         int capacity = initialSize;
2897         byte[] buf = new byte[capacity];
2898         int nread = 0;
2899         int rem = buf.length;
2900         int n;
2901         // read to EOF which may read more or less than initialSize (eg: file
2902         // is truncated while we are reading)
2903         while ((n = source.read(buf, nread, rem)) > 0) {
2904             nread += n;
2905             rem -= n;
2906             assert rem >= 0;
2907             if (rem == 0) {
2908                 // need larger buffer
2909                 int newCapacity = capacity << 1;
2910                 if (newCapacity < 0) {
2911                     if (capacity == Integer.MAX_VALUE)
2912                         throw new OutOfMemoryError("Required array size too large");
2913                     newCapacity = Integer.MAX_VALUE;
2914                 }
2915                 rem = newCapacity - capacity;
2916                 buf = Arrays.copyOf(buf, newCapacity);
2917                 capacity = newCapacity;
2918             }
2919         }
2920         return (capacity == nread) ? buf : Arrays.copyOf(buf, nread);
2921     }
2922 
2923     /**
2924      * Read all the bytes from a file. The method ensures that the file is
2925      * closed when all bytes have been read or an I/O error, or other runtime
2926      * exception, is thrown.
2927      *
2928      * <p> Note that this method is intended for simple cases where it is
2929      * convenient to read all bytes into a byte array. It is not intended for
2930      * reading in large files.
2931      *
2932      * @param   path
2933      *          the path to the file
2934      *
2935      * @return  a byte array containing the bytes read from the file
2936      *
2937      * @throws  IOException
2938      *          if an I/O error occurs reading from the stream
2939      * @throws  OutOfMemoryError
2940      *          if an array of the required size cannot be allocated, for
2941      *          example the file is larger that {@code 2GB}
2942      * @throws  SecurityException
2943      *          In the case of the default provider, and a security manager is
2944      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
2945      *          method is invoked to check read access to the file.
2946      */
2947     public static byte[] readAllBytes(Path path) throws IOException {
2948         long size = size(path);
2949         if (size > (long)Integer.MAX_VALUE)
2950             throw new OutOfMemoryError("Required array size too large");
2951 
2952         try (InputStream in = newInputStream(path)) {
2953              return read(in, (int)size);
2954         }
2955     }
2956 
2957     /**
2958      * Read all lines from a file. This method ensures that the file is
2959      * closed when all bytes have been read or an I/O error, or other runtime
2960      * exception, is thrown. Bytes from the file are decoded into characters
2961      * using the specified charset.
2962      *
2963      * <p> This method recognizes the following as line terminators:
2964      * <ul>
2965      *   <li> <code>&#92;u000D</code> followed by <code>&#92;u000A</code>,
2966      *     CARRIAGE RETURN followed by LINE FEED </li>
2967      *   <li> <code>&#92;u000A</code>, LINE FEED </li>
2968      *   <li> <code>&#92;u000D</code>, CARRIAGE RETURN </li>
2969      * </ul>
2970      * <p> Additional Unicode line terminators may be recognized in future
2971      * releases.
2972      *
2973      * <p> Note that this method is intended for simple cases where it is
2974      * convenient to read all lines in a single operation. It is not intended
2975      * for reading in large files.
2976      *
2977      * @param   path
2978      *          the path to the file
2979      * @param   cs
2980      *          the charset to use for decoding
2981      *
2982      * @return  the lines from the file as a {@code List}; whether the {@code
2983      *          List} is modifiable or not is implementation dependent and
2984      *          therefore not specified
2985      *
2986      * @throws  IOException
2987      *          if an I/O error occurs reading from the file or a malformed or
2988      *          unmappable byte sequence is read
2989      * @throws  SecurityException
2990      *          In the case of the default provider, and a security manager is
2991      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
2992      *          method is invoked to check read access to the file.
2993      *
2994      * @see #newBufferedReader
2995      */
2996     public static List<String> readAllLines(Path path, Charset cs)
2997         throws IOException
2998     {
2999         try (BufferedReader reader = newBufferedReader(path, cs)) {
3000             List<String> result = new ArrayList<>();
3001             for (;;) {
3002                 String line = reader.readLine();
3003                 if (line == null)
3004                     break;
3005                 result.add(line);
3006             }
3007             return result;
3008         }
3009     }
3010 
3011     /**
3012      * Writes bytes to a file. The {@code options} parameter specifies how the
3013      * the file is created or opened. If no options are present then this method
3014      * works as if the {@link StandardOpenOption#CREATE CREATE}, {@link
3015      * StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING}, and {@link
3016      * StandardOpenOption#WRITE WRITE} options are present. In other words, it
3017      * opens the file for writing, creating the file if it doesn't exist, or
3018      * initially truncating an existing {@link #isRegularFile regular-file} to
3019      * a size of {@code 0}. All bytes in the byte array are written to the file.
3020      * The method ensures that the file is closed when all bytes have been
3021      * written (or an I/O error or other runtime exception is thrown). If an I/O
3022      * error occurs then it may do so after the file has created or truncated,
3023      * or after some bytes have been written to the file.
3024      *
3025      * <p> <b>Usage example</b>: By default the method creates a new file or
3026      * overwrites an existing file. Suppose you instead want to append bytes
3027      * to an existing file:
3028      * <pre>
3029      *     Path path = ...
3030      *     byte[] bytes = ...
3031      *     Files.write(path, bytes, StandardOpenOption.APPEND);
3032      * </pre>
3033      *
3034      * @param   path
3035      *          the path to the file
3036      * @param   bytes
3037      *          the byte array with the bytes to write
3038      * @param   options
3039      *          options specifying how the file is opened
3040      *
3041      * @return  the path
3042      *
3043      * @throws  IOException
3044      *          if an I/O error occurs writing to or creating the file
3045      * @throws  UnsupportedOperationException
3046      *          if an unsupported option is specified
3047      * @throws  SecurityException
3048      *          In the case of the default provider, and a security manager is
3049      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
3050      *          method is invoked to check write access to the file.
3051      */
3052     public static Path write(Path path, byte[] bytes, OpenOption... options)
3053         throws IOException
3054     {
3055         // ensure bytes is not null before opening file
3056         Objects.requireNonNull(bytes);
3057 
3058         try (OutputStream out = Files.newOutputStream(path, options)) {
3059             int len = bytes.length;
3060             int rem = len;
3061             while (rem > 0) {
3062                 int n = Math.min(rem, BUFFER_SIZE);
3063                 out.write(bytes, (len-rem), n);
3064                 rem -= n;
3065             }
3066         }
3067         return path;
3068     }
3069 
3070     /**
3071      * Write lines of text to a file. Each line is a char sequence and is
3072      * written to the file in sequence with each line terminated by the
3073      * platform's line separator, as defined by the system property {@code
3074      * line.separator}. Characters are encoded into bytes using the specified
3075      * charset.
3076      *
3077      * <p> The {@code options} parameter specifies how the the file is created
3078      * or opened. If no options are present then this method works as if the
3079      * {@link StandardOpenOption#CREATE CREATE}, {@link
3080      * StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING}, and {@link
3081      * StandardOpenOption#WRITE WRITE} options are present. In other words, it
3082      * opens the file for writing, creating the file if it doesn't exist, or
3083      * initially truncating an existing {@link #isRegularFile regular-file} to
3084      * a size of {@code 0}. The method ensures that the file is closed when all
3085      * lines have been written (or an I/O error or other runtime exception is
3086      * thrown). If an I/O error occurs then it may do so after the file has
3087      * created or truncated, or after some bytes have been written to the file.
3088      *
3089      * @param   path
3090      *          the path to the file
3091      * @param   lines
3092      *          an object to iterate over the char sequences
3093      * @param   cs
3094      *          the charset to use for encoding
3095      * @param   options
3096      *          options specifying how the file is opened
3097      *
3098      * @return  the path
3099      *
3100      * @throws  IOException
3101      *          if an I/O error occurs writing to or creating the file, or the
3102      *          text cannot be encoded using the specified charset
3103      * @throws  UnsupportedOperationException
3104      *          if an unsupported option is specified
3105      * @throws  SecurityException
3106      *          In the case of the default provider, and a security manager is
3107      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
3108      *          method is invoked to check write access to the file.
3109      */
3110     public static Path write(Path path, Iterable<? extends CharSequence> lines,
3111                              Charset cs, OpenOption... options)
3112         throws IOException
3113     {
3114         // ensure lines is not null before opening file
3115         Objects.requireNonNull(lines);
3116         CharsetEncoder encoder = cs.newEncoder();
3117         OutputStream out = newOutputStream(path, options);
3118         try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out, encoder))) {
3119             for (CharSequence line: lines) {
3120                 writer.append(line);
3121                 writer.newLine();
3122             }
3123         }
3124         return path;
3125     }
3126 }
--- EOF ---