rev 51958 : 8211122: Reduce the number of internal classes made accessible to jdk.unsupported
Reviewed-by: alanb, dfuchs, kvn

   1 /*
   2  * Copyright (c) 2007, 2018, 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.io.BufferedReader;
  29 import java.io.BufferedWriter;
  30 import java.io.Closeable;
  31 import java.io.File;
  32 import java.io.IOException;
  33 import java.io.InputStream;
  34 import java.io.InputStreamReader;
  35 import java.io.OutputStream;
  36 import java.io.OutputStreamWriter;
  37 import java.io.Reader;
  38 import java.io.UncheckedIOException;
  39 import java.io.Writer;
  40 import java.nio.channels.Channels;
  41 import java.nio.channels.FileChannel;
  42 import java.nio.channels.SeekableByteChannel;
  43 import java.nio.charset.Charset;
  44 import java.nio.charset.CharsetDecoder;
  45 import java.nio.charset.CharsetEncoder;
  46 import java.nio.charset.StandardCharsets;
  47 import java.nio.file.attribute.BasicFileAttributeView;
  48 import java.nio.file.attribute.BasicFileAttributes;
  49 import java.nio.file.attribute.DosFileAttributes;   // javadoc
  50 import java.nio.file.attribute.FileAttribute;
  51 import java.nio.file.attribute.FileAttributeView;
  52 import java.nio.file.attribute.FileOwnerAttributeView;
  53 import java.nio.file.attribute.FileStoreAttributeView;
  54 import java.nio.file.attribute.FileTime;
  55 import java.nio.file.attribute.PosixFileAttributeView;
  56 import java.nio.file.attribute.PosixFileAttributes;
  57 import java.nio.file.attribute.PosixFilePermission;
  58 import java.nio.file.attribute.UserPrincipal;
  59 import java.nio.file.spi.FileSystemProvider;
  60 import java.nio.file.spi.FileTypeDetector;
  61 import java.security.AccessController;
  62 import java.security.PrivilegedAction;
  63 import java.util.ArrayList;
  64 import java.util.Arrays;
  65 import java.util.Collections;
  66 import java.util.EnumSet;
  67 import java.util.HashSet;
  68 import java.util.Iterator;
  69 import java.util.List;
  70 import java.util.Map;
  71 import java.util.Objects;
  72 import java.util.ServiceLoader;
  73 import java.util.Set;
  74 import java.util.Spliterator;
  75 import java.util.Spliterators;
  76 import java.util.function.BiPredicate;
  77 import java.util.stream.Stream;
  78 import java.util.stream.StreamSupport;
  79 
  80 import sun.nio.ch.FileChannelImpl;
  81 import sun.nio.fs.AbstractFileSystemProvider;
  82 
  83 /**
  84  * This class consists exclusively of static methods that operate on files,
  85  * directories, or other types of files.
  86  *
  87  * <p> In most cases, the methods defined here will delegate to the associated
  88  * file system provider to perform the file operations.
  89  *
  90  * @since 1.7
  91  */
  92 
  93 public final class Files {
  94     private Files() { }
  95 
  96     /**
  97      * Returns the {@code FileSystemProvider} to delegate to.
  98      */
  99     private static FileSystemProvider provider(Path path) {
 100         return path.getFileSystem().provider();
 101     }
 102 
 103     /**
 104      * Convert a Closeable to a Runnable by converting checked IOException
 105      * to UncheckedIOException
 106      */
 107     private static Runnable asUncheckedRunnable(Closeable c) {
 108         return () -> {
 109             try {
 110                 c.close();
 111             } catch (IOException e) {
 112                 throw new UncheckedIOException(e);
 113             }
 114         };
 115     }
 116 
 117     // -- File contents --
 118 
 119     /**
 120      * Opens a file, returning an input stream to read from the file. The stream
 121      * will not be buffered, and is not required to support the {@link
 122      * InputStream#mark mark} or {@link InputStream#reset reset} methods. The
 123      * stream will be safe for access by multiple concurrent threads. Reading
 124      * commences at the beginning of the file. Whether the returned stream is
 125      * <i>asynchronously closeable</i> and/or <i>interruptible</i> is highly
 126      * file system provider specific and therefore not specified.
 127      *
 128      * <p> The {@code options} parameter determines how the file is opened.
 129      * If no options are present then it is equivalent to opening the file with
 130      * the {@link StandardOpenOption#READ READ} option. In addition to the {@code
 131      * READ} option, an implementation may also support additional implementation
 132      * specific options.
 133      *
 134      * @param   path
 135      *          the path to the file to open
 136      * @param   options
 137      *          options specifying how the file is opened
 138      *
 139      * @return  a new input stream
 140      *
 141      * @throws  IllegalArgumentException
 142      *          if an invalid combination of options is specified
 143      * @throws  UnsupportedOperationException
 144      *          if an unsupported option is specified
 145      * @throws  IOException
 146      *          if an I/O error occurs
 147      * @throws  SecurityException
 148      *          In the case of the default provider, and a security manager is
 149      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
 150      *          method is invoked to check read access to the file.
 151      */
 152     public static InputStream newInputStream(Path path, OpenOption... options)
 153         throws IOException
 154     {
 155         return provider(path).newInputStream(path, options);
 156     }
 157 
 158     /**
 159      * Opens or creates a file, returning an output stream that may be used to
 160      * write bytes to the file. The resulting stream will not be buffered. The
 161      * stream will be safe for access by multiple concurrent threads. Whether
 162      * the returned stream is <i>asynchronously closeable</i> and/or
 163      * <i>interruptible</i> is highly file system provider specific and
 164      * therefore not specified.
 165      *
 166      * <p> This method opens or creates a file in exactly the manner specified
 167      * by the {@link #newByteChannel(Path,Set,FileAttribute[]) newByteChannel}
 168      * method with the exception that the {@link StandardOpenOption#READ READ}
 169      * option may not be present in the array of options. If no options are
 170      * present then this method works as if the {@link StandardOpenOption#CREATE
 171      * CREATE}, {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING},
 172      * and {@link StandardOpenOption#WRITE WRITE} options are present. In other
 173      * words, it opens the file for writing, creating the file if it doesn't
 174      * exist, or initially truncating an existing {@link #isRegularFile
 175      * regular-file} to a size of {@code 0} if it exists.
 176      *
 177      * <p> <b>Usage Examples:</b>
 178      * <pre>
 179      *     Path path = ...
 180      *
 181      *     // truncate and overwrite an existing file, or create the file if
 182      *     // it doesn't initially exist
 183      *     OutputStream out = Files.newOutputStream(path);
 184      *
 185      *     // append to an existing file, fail if the file does not exist
 186      *     out = Files.newOutputStream(path, APPEND);
 187      *
 188      *     // append to an existing file, create file if it doesn't initially exist
 189      *     out = Files.newOutputStream(path, CREATE, APPEND);
 190      *
 191      *     // always create new file, failing if it already exists
 192      *     out = Files.newOutputStream(path, CREATE_NEW);
 193      * </pre>
 194      *
 195      * @param   path
 196      *          the path to the file to open or create
 197      * @param   options
 198      *          options specifying how the file is opened
 199      *
 200      * @return  a new output stream
 201      *
 202      * @throws  IllegalArgumentException
 203      *          if {@code options} contains an invalid combination of options
 204      * @throws  UnsupportedOperationException
 205      *          if an unsupported option is specified
 206      * @throws  IOException
 207      *          if an I/O error occurs
 208      * @throws  SecurityException
 209      *          In the case of the default provider, and a security manager is
 210      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 211      *          method is invoked to check write access to the file. The {@link
 212      *          SecurityManager#checkDelete(String) checkDelete} method is
 213      *          invoked to check delete access if the file is opened with the
 214      *          {@code DELETE_ON_CLOSE} option.
 215      */
 216     public static OutputStream newOutputStream(Path path, OpenOption... options)
 217         throws IOException
 218     {
 219         return provider(path).newOutputStream(path, options);
 220     }
 221 
 222     /**
 223      * Opens or creates a file, returning a seekable byte channel to access the
 224      * file.
 225      *
 226      * <p> The {@code options} parameter determines how the file is opened.
 227      * The {@link StandardOpenOption#READ READ} and {@link
 228      * StandardOpenOption#WRITE WRITE} options determine if the file should be
 229      * opened for reading and/or writing. If neither option (or the {@link
 230      * StandardOpenOption#APPEND APPEND} option) is present then the file is
 231      * opened for reading. By default reading or writing commence at the
 232      * beginning of the file.
 233      *
 234      * <p> In the addition to {@code READ} and {@code WRITE}, the following
 235      * options may be present:
 236      *
 237      * <table class="striped">
 238      * <caption style="display:none">Options</caption>
 239      * <thead>
 240      * <tr> <th scope="col">Option</th> <th scope="col">Description</th> </tr>
 241      * </thead>
 242      * <tbody>
 243      * <tr>
 244      *   <th scope="row"> {@link StandardOpenOption#APPEND APPEND} </th>
 245      *   <td> If this option is present then the file is opened for writing and
 246      *     each invocation of the channel's {@code write} method first advances
 247      *     the position to the end of the file and then writes the requested
 248      *     data. Whether the advancement of the position and the writing of the
 249      *     data are done in a single atomic operation is system-dependent and
 250      *     therefore unspecified. This option may not be used in conjunction
 251      *     with the {@code READ} or {@code TRUNCATE_EXISTING} options. </td>
 252      * </tr>
 253      * <tr>
 254      *   <th scope="row"> {@link StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING} </th>
 255      *   <td> If this option is present then the existing file is truncated to
 256      *   a size of 0 bytes. This option is ignored when the file is opened only
 257      *   for reading. </td>
 258      * </tr>
 259      * <tr>
 260      *   <th scope="row"> {@link StandardOpenOption#CREATE_NEW CREATE_NEW} </th>
 261      *   <td> If this option is present then a new file is created, failing if
 262      *   the file already exists or is a symbolic link. When creating a file the
 263      *   check for the existence of the file and the creation of the file if it
 264      *   does not exist is atomic with respect to other file system operations.
 265      *   This option is ignored when the file is opened only for reading. </td>
 266      * </tr>
 267      * <tr>
 268      *   <th scope="row" > {@link StandardOpenOption#CREATE CREATE} </th>
 269      *   <td> If this option is present then an existing file is opened if it
 270      *   exists, otherwise a new file is created. This option is ignored if the
 271      *   {@code CREATE_NEW} option is also present or the file is opened only
 272      *   for reading. </td>
 273      * </tr>
 274      * <tr>
 275      *   <th scope="row" > {@link StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE} </th>
 276      *   <td> When this option is present then the implementation makes a
 277      *   <em>best effort</em> attempt to delete the file when closed by the
 278      *   {@link SeekableByteChannel#close close} method. If the {@code close}
 279      *   method is not invoked then a <em>best effort</em> attempt is made to
 280      *   delete the file when the Java virtual machine terminates. </td>
 281      * </tr>
 282      * <tr>
 283      *   <th scope="row">{@link StandardOpenOption#SPARSE SPARSE} </th>
 284      *   <td> When creating a new file this option is a <em>hint</em> that the
 285      *   new file will be sparse. This option is ignored when not creating
 286      *   a new file. </td>
 287      * </tr>
 288      * <tr>
 289      *   <th scope="row"> {@link StandardOpenOption#SYNC SYNC} </th>
 290      *   <td> Requires that every update to the file's content or metadata be
 291      *   written synchronously to the underlying storage device. (see <a
 292      *   href="package-summary.html#integrity"> Synchronized I/O file
 293      *   integrity</a>). </td>
 294      * </tr>
 295      * <tr>
 296      *   <th scope="row"> {@link StandardOpenOption#DSYNC DSYNC} </th>
 297      *   <td> Requires that every update to the file's content be written
 298      *   synchronously to the underlying storage device. (see <a
 299      *   href="package-summary.html#integrity"> Synchronized I/O file
 300      *   integrity</a>). </td>
 301      * </tr>
 302      * </tbody>
 303      * </table>
 304      *
 305      * <p> An implementation may also support additional implementation specific
 306      * options.
 307      *
 308      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 309      * file-attributes} to set atomically when a new file is created.
 310      *
 311      * <p> In the case of the default provider, the returned seekable byte channel
 312      * is a {@link java.nio.channels.FileChannel}.
 313      *
 314      * <p> <b>Usage Examples:</b>
 315      * <pre>{@code
 316      *     Path path = ...
 317      *
 318      *     // open file for reading
 319      *     ReadableByteChannel rbc = Files.newByteChannel(path, EnumSet.of(READ)));
 320      *
 321      *     // open file for writing to the end of an existing file, creating
 322      *     // the file if it doesn't already exist
 323      *     WritableByteChannel wbc = Files.newByteChannel(path, EnumSet.of(CREATE,APPEND));
 324      *
 325      *     // create file with initial permissions, opening it for both reading and writing
 326      *     FileAttribute<Set<PosixFilePermission>> perms = ...
 327      *     SeekableByteChannel sbc =
 328      *         Files.newByteChannel(path, EnumSet.of(CREATE_NEW,READ,WRITE), perms);
 329      * }</pre>
 330      *
 331      * @param   path
 332      *          the path to the file to open or create
 333      * @param   options
 334      *          options specifying how the file is opened
 335      * @param   attrs
 336      *          an optional list of file attributes to set atomically when
 337      *          creating the file
 338      *
 339      * @return  a new seekable byte channel
 340      *
 341      * @throws  IllegalArgumentException
 342      *          if the set contains an invalid combination of options
 343      * @throws  UnsupportedOperationException
 344      *          if an unsupported open option is specified or the array contains
 345      *          attributes that cannot be set atomically when creating the file
 346      * @throws  FileAlreadyExistsException
 347      *          if a file of that name already exists and the {@link
 348      *          StandardOpenOption#CREATE_NEW CREATE_NEW} option is specified
 349      *          <i>(optional specific exception)</i>
 350      * @throws  IOException
 351      *          if an I/O error occurs
 352      * @throws  SecurityException
 353      *          In the case of the default provider, and a security manager is
 354      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
 355      *          method is invoked to check read access to the path if the file is
 356      *          opened for reading. The {@link SecurityManager#checkWrite(String)
 357      *          checkWrite} method is invoked to check write access to the path
 358      *          if the file is opened for writing. The {@link
 359      *          SecurityManager#checkDelete(String) checkDelete} method is
 360      *          invoked to check delete access if the file is opened with the
 361      *          {@code DELETE_ON_CLOSE} option.
 362      *
 363      * @see java.nio.channels.FileChannel#open(Path,Set,FileAttribute[])
 364      */
 365     public static SeekableByteChannel newByteChannel(Path path,
 366                                                      Set<? extends OpenOption> options,
 367                                                      FileAttribute<?>... attrs)
 368         throws IOException
 369     {
 370         return provider(path).newByteChannel(path, options, attrs);
 371     }
 372 
 373     /**
 374      * Opens or creates a file, returning a seekable byte channel to access the
 375      * file.
 376      *
 377      * <p> This method opens or creates a file in exactly the manner specified
 378      * by the {@link #newByteChannel(Path,Set,FileAttribute[]) newByteChannel}
 379      * method.
 380      *
 381      * @param   path
 382      *          the path to the file to open or create
 383      * @param   options
 384      *          options specifying how the file is opened
 385      *
 386      * @return  a new seekable byte channel
 387      *
 388      * @throws  IllegalArgumentException
 389      *          if the set contains an invalid combination of options
 390      * @throws  UnsupportedOperationException
 391      *          if an unsupported open option is specified
 392      * @throws  FileAlreadyExistsException
 393      *          if a file of that name already exists and the {@link
 394      *          StandardOpenOption#CREATE_NEW CREATE_NEW} option is specified
 395      *          <i>(optional specific exception)</i>
 396      * @throws  IOException
 397      *          if an I/O error occurs
 398      * @throws  SecurityException
 399      *          In the case of the default provider, and a security manager is
 400      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
 401      *          method is invoked to check read access to the path if the file is
 402      *          opened for reading. The {@link SecurityManager#checkWrite(String)
 403      *          checkWrite} method is invoked to check write access to the path
 404      *          if the file is opened for writing. The {@link
 405      *          SecurityManager#checkDelete(String) checkDelete} method is
 406      *          invoked to check delete access if the file is opened with the
 407      *          {@code DELETE_ON_CLOSE} option.
 408      *
 409      * @see java.nio.channels.FileChannel#open(Path,OpenOption[])
 410      */
 411     public static SeekableByteChannel newByteChannel(Path path, OpenOption... options)
 412         throws IOException
 413     {
 414         Set<OpenOption> set;
 415         if (options.length == 0) {
 416             set = Collections.emptySet();
 417         } else {
 418             set = new HashSet<>();
 419             Collections.addAll(set, options);
 420         }
 421         return newByteChannel(path, set);
 422     }
 423 
 424     // -- Directories --
 425 
 426     private static class AcceptAllFilter
 427         implements DirectoryStream.Filter<Path>
 428     {
 429         private AcceptAllFilter() { }
 430 
 431         @Override
 432         public boolean accept(Path entry) { return true; }
 433 
 434         static final AcceptAllFilter FILTER = new AcceptAllFilter();
 435     }
 436 
 437     /**
 438      * Opens a directory, returning a {@link DirectoryStream} to iterate over
 439      * all entries in the directory. The elements returned by the directory
 440      * stream's {@link DirectoryStream#iterator iterator} are of type {@code
 441      * Path}, each one representing an entry in the directory. The {@code Path}
 442      * objects are obtained as if by {@link Path#resolve(Path) resolving} the
 443      * name of the directory entry against {@code dir}.
 444      *
 445      * <p> When not using the try-with-resources construct, then directory
 446      * stream's {@code close} method should be invoked after iteration is
 447      * completed so as to free any resources held for the open directory.
 448      *
 449      * <p> When an implementation supports operations on entries in the
 450      * directory that execute in a race-free manner then the returned directory
 451      * stream is a {@link SecureDirectoryStream}.
 452      *
 453      * @param   dir
 454      *          the path to the directory
 455      *
 456      * @return  a new and open {@code DirectoryStream} object
 457      *
 458      * @throws  NotDirectoryException
 459      *          if the file could not otherwise be opened because it is not
 460      *          a directory <i>(optional specific exception)</i>
 461      * @throws  IOException
 462      *          if an I/O error occurs
 463      * @throws  SecurityException
 464      *          In the case of the default provider, and a security manager is
 465      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
 466      *          method is invoked to check read access to the directory.
 467      */
 468     public static DirectoryStream<Path> newDirectoryStream(Path dir)
 469         throws IOException
 470     {
 471         return provider(dir).newDirectoryStream(dir, AcceptAllFilter.FILTER);
 472     }
 473 
 474     /**
 475      * Opens a directory, returning a {@link DirectoryStream} to iterate over
 476      * the entries in the directory. The elements returned by the directory
 477      * stream's {@link DirectoryStream#iterator iterator} are of type {@code
 478      * Path}, each one representing an entry in the directory. The {@code Path}
 479      * objects are obtained as if by {@link Path#resolve(Path) resolving} the
 480      * name of the directory entry against {@code dir}. The entries returned by
 481      * the iterator are filtered by matching the {@code String} representation
 482      * of their file names against the given <em>globbing</em> pattern.
 483      *
 484      * <p> For example, suppose we want to iterate over the files ending with
 485      * ".java" in a directory:
 486      * <pre>
 487      *     Path dir = ...
 488      *     try (DirectoryStream&lt;Path&gt; stream = Files.newDirectoryStream(dir, "*.java")) {
 489      *         :
 490      *     }
 491      * </pre>
 492      *
 493      * <p> The globbing pattern is specified by the {@link
 494      * FileSystem#getPathMatcher getPathMatcher} method.
 495      *
 496      * <p> When not using the try-with-resources construct, then directory
 497      * stream's {@code close} method should be invoked after iteration is
 498      * completed so as to free any resources held for the open directory.
 499      *
 500      * <p> When an implementation supports operations on entries in the
 501      * directory that execute in a race-free manner then the returned directory
 502      * stream is a {@link SecureDirectoryStream}.
 503      *
 504      * @param   dir
 505      *          the path to the directory
 506      * @param   glob
 507      *          the glob pattern
 508      *
 509      * @return  a new and open {@code DirectoryStream} object
 510      *
 511      * @throws  java.util.regex.PatternSyntaxException
 512      *          if the pattern is invalid
 513      * @throws  NotDirectoryException
 514      *          if the file could not otherwise be opened because it is not
 515      *          a directory <i>(optional specific exception)</i>
 516      * @throws  IOException
 517      *          if an I/O error occurs
 518      * @throws  SecurityException
 519      *          In the case of the default provider, and a security manager is
 520      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
 521      *          method is invoked to check read access to the directory.
 522      */
 523     public static DirectoryStream<Path> newDirectoryStream(Path dir, String glob)
 524         throws IOException
 525     {
 526         // avoid creating a matcher if all entries are required.
 527         if (glob.equals("*"))
 528             return newDirectoryStream(dir);
 529 
 530         // create a matcher and return a filter that uses it.
 531         FileSystem fs = dir.getFileSystem();
 532         final PathMatcher matcher = fs.getPathMatcher("glob:" + glob);
 533         DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<>() {
 534             @Override
 535             public boolean accept(Path entry)  {
 536                 return matcher.matches(entry.getFileName());
 537             }
 538         };
 539         return fs.provider().newDirectoryStream(dir, filter);
 540     }
 541 
 542     /**
 543      * Opens a directory, returning a {@link DirectoryStream} to iterate over
 544      * the entries in the directory. The elements returned by the directory
 545      * stream's {@link DirectoryStream#iterator iterator} are of type {@code
 546      * Path}, each one representing an entry in the directory. The {@code Path}
 547      * objects are obtained as if by {@link Path#resolve(Path) resolving} the
 548      * name of the directory entry against {@code dir}. The entries returned by
 549      * the iterator are filtered by the given {@link DirectoryStream.Filter
 550      * filter}.
 551      *
 552      * <p> When not using the try-with-resources construct, then directory
 553      * stream's {@code close} method should be invoked after iteration is
 554      * completed so as to free any resources held for the open directory.
 555      *
 556      * <p> Where the filter terminates due to an uncaught error or runtime
 557      * exception then it is propagated to the {@link Iterator#hasNext()
 558      * hasNext} or {@link Iterator#next() next} method. Where an {@code
 559      * IOException} is thrown, it results in the {@code hasNext} or {@code
 560      * next} method throwing a {@link DirectoryIteratorException} with the
 561      * {@code IOException} as the cause.
 562      *
 563      * <p> When an implementation supports operations on entries in the
 564      * directory that execute in a race-free manner then the returned directory
 565      * stream is a {@link SecureDirectoryStream}.
 566      *
 567      * <p> <b>Usage Example:</b>
 568      * Suppose we want to iterate over the files in a directory that are
 569      * larger than 8K.
 570      * <pre>
 571      *     DirectoryStream.Filter&lt;Path&gt; filter = new DirectoryStream.Filter&lt;Path&gt;() {
 572      *         public boolean accept(Path file) throws IOException {
 573      *             return (Files.size(file) &gt; 8192L);
 574      *         }
 575      *     };
 576      *     Path dir = ...
 577      *     try (DirectoryStream&lt;Path&gt; stream = Files.newDirectoryStream(dir, filter)) {
 578      *         :
 579      *     }
 580      * </pre>
 581      *
 582      * @param   dir
 583      *          the path to the directory
 584      * @param   filter
 585      *          the directory stream filter
 586      *
 587      * @return  a new and open {@code DirectoryStream} object
 588      *
 589      * @throws  NotDirectoryException
 590      *          if the file could not otherwise be opened because it is not
 591      *          a directory <i>(optional specific exception)</i>
 592      * @throws  IOException
 593      *          if an I/O error occurs
 594      * @throws  SecurityException
 595      *          In the case of the default provider, and a security manager is
 596      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
 597      *          method is invoked to check read access to the directory.
 598      */
 599     public static DirectoryStream<Path> newDirectoryStream(Path dir,
 600                                                            DirectoryStream.Filter<? super Path> filter)
 601         throws IOException
 602     {
 603         return provider(dir).newDirectoryStream(dir, filter);
 604     }
 605 
 606     // -- Creation and deletion --
 607 
 608     private static final Set<OpenOption> DEFAULT_CREATE_OPTIONS =
 609         Set.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE);
 610 
 611     /**
 612      * Creates a new and empty file, failing if the file already exists. The
 613      * check for the existence of the file and the creation of the new file if
 614      * it does not exist are a single operation that is atomic with respect to
 615      * all other filesystem activities that might affect the directory.
 616      *
 617      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 618      * file-attributes} to set atomically when creating the file. Each attribute
 619      * is identified by its {@link FileAttribute#name name}. If more than one
 620      * attribute of the same name is included in the array then all but the last
 621      * occurrence is ignored.
 622      *
 623      * @param   path
 624      *          the path to the file to create
 625      * @param   attrs
 626      *          an optional list of file attributes to set atomically when
 627      *          creating the file
 628      *
 629      * @return  the file
 630      *
 631      * @throws  UnsupportedOperationException
 632      *          if the array contains an attribute that cannot be set atomically
 633      *          when creating the file
 634      * @throws  FileAlreadyExistsException
 635      *          if a file of that name already exists
 636      *          <i>(optional specific exception)</i>
 637      * @throws  IOException
 638      *          if an I/O error occurs or the parent directory does not exist
 639      * @throws  SecurityException
 640      *          In the case of the default provider, and a security manager is
 641      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 642      *          method is invoked to check write access to the new file.
 643      */
 644     public static Path createFile(Path path, FileAttribute<?>... attrs)
 645         throws IOException
 646     {
 647         newByteChannel(path, DEFAULT_CREATE_OPTIONS, attrs).close();
 648         return path;
 649     }
 650 
 651     /**
 652      * Creates a new directory. The check for the existence of the file and the
 653      * creation of the directory if it does not exist are a single operation
 654      * that is atomic with respect to all other filesystem activities that might
 655      * affect the directory. The {@link #createDirectories createDirectories}
 656      * method should be used where it is required to create all nonexistent
 657      * parent directories first.
 658      *
 659      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 660      * file-attributes} to set atomically when creating the directory. Each
 661      * attribute is identified by its {@link FileAttribute#name name}. If more
 662      * than one attribute of the same name is included in the array then all but
 663      * the last occurrence is ignored.
 664      *
 665      * @param   dir
 666      *          the directory to create
 667      * @param   attrs
 668      *          an optional list of file attributes to set atomically when
 669      *          creating the directory
 670      *
 671      * @return  the directory
 672      *
 673      * @throws  UnsupportedOperationException
 674      *          if the array contains an attribute that cannot be set atomically
 675      *          when creating the directory
 676      * @throws  FileAlreadyExistsException
 677      *          if a directory could not otherwise be created because a file of
 678      *          that name already exists <i>(optional specific exception)</i>
 679      * @throws  IOException
 680      *          if an I/O error occurs or the parent directory does not exist
 681      * @throws  SecurityException
 682      *          In the case of the default provider, and a security manager is
 683      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 684      *          method is invoked to check write access to the new directory.
 685      */
 686     public static Path createDirectory(Path dir, FileAttribute<?>... attrs)
 687         throws IOException
 688     {
 689         provider(dir).createDirectory(dir, attrs);
 690         return dir;
 691     }
 692 
 693     /**
 694      * Creates a directory by creating all nonexistent parent directories first.
 695      * Unlike the {@link #createDirectory createDirectory} method, an exception
 696      * is not thrown if the directory could not be created because it already
 697      * exists.
 698      *
 699      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 700      * file-attributes} to set atomically when creating the nonexistent
 701      * directories. Each file attribute is identified by its {@link
 702      * FileAttribute#name name}. If more than one attribute of the same name is
 703      * included in the array then all but the last occurrence is ignored.
 704      *
 705      * <p> If this method fails, then it may do so after creating some, but not
 706      * all, of the parent directories.
 707      *
 708      * @param   dir
 709      *          the directory to create
 710      *
 711      * @param   attrs
 712      *          an optional list of file attributes to set atomically when
 713      *          creating the directory
 714      *
 715      * @return  the directory
 716      *
 717      * @throws  UnsupportedOperationException
 718      *          if the array contains an attribute that cannot be set atomically
 719      *          when creating the directory
 720      * @throws  FileAlreadyExistsException
 721      *          if {@code dir} exists but is not a directory <i>(optional specific
 722      *          exception)</i>
 723      * @throws  IOException
 724      *          if an I/O error occurs
 725      * @throws  SecurityException
 726      *          in the case of the default provider, and a security manager is
 727      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 728      *          method is invoked prior to attempting to create a directory and
 729      *          its {@link SecurityManager#checkRead(String) checkRead} is
 730      *          invoked for each parent directory that is checked. If {@code
 731      *          dir} is not an absolute path then its {@link Path#toAbsolutePath
 732      *          toAbsolutePath} may need to be invoked to get its absolute path.
 733      *          This may invoke the security manager's {@link
 734      *          SecurityManager#checkPropertyAccess(String) checkPropertyAccess}
 735      *          method to check access to the system property {@code user.dir}
 736      */
 737     public static Path createDirectories(Path dir, FileAttribute<?>... attrs)
 738         throws IOException
 739     {
 740         // attempt to create the directory
 741         try {
 742             createAndCheckIsDirectory(dir, attrs);
 743             return dir;
 744         } catch (FileAlreadyExistsException x) {
 745             // file exists and is not a directory
 746             throw x;
 747         } catch (IOException x) {
 748             // parent may not exist or other reason
 749         }
 750         SecurityException se = null;
 751         try {
 752             dir = dir.toAbsolutePath();
 753         } catch (SecurityException x) {
 754             // don't have permission to get absolute path
 755             se = x;
 756         }
 757         // find a descendant that exists
 758         Path parent = dir.getParent();
 759         while (parent != null) {
 760             try {
 761                 provider(parent).checkAccess(parent);
 762                 break;
 763             } catch (NoSuchFileException x) {
 764                 // does not exist
 765             }
 766             parent = parent.getParent();
 767         }
 768         if (parent == null) {
 769             // unable to find existing parent
 770             if (se == null) {
 771                 throw new FileSystemException(dir.toString(), null,
 772                     "Unable to determine if root directory exists");
 773             } else {
 774                 throw se;
 775             }
 776         }
 777 
 778         // create directories
 779         Path child = parent;
 780         for (Path name: parent.relativize(dir)) {
 781             child = child.resolve(name);
 782             createAndCheckIsDirectory(child, attrs);
 783         }
 784         return dir;
 785     }
 786 
 787     /**
 788      * Used by createDirectories to attempt to create a directory. A no-op
 789      * if the directory already exists.
 790      */
 791     private static void createAndCheckIsDirectory(Path dir,
 792                                                   FileAttribute<?>... attrs)
 793         throws IOException
 794     {
 795         try {
 796             createDirectory(dir, attrs);
 797         } catch (FileAlreadyExistsException x) {
 798             if (!isDirectory(dir, LinkOption.NOFOLLOW_LINKS))
 799                 throw x;
 800         }
 801     }
 802 
 803     /**
 804      * Creates a new empty file in the specified directory, using the given
 805      * prefix and suffix strings to generate its name. The resulting
 806      * {@code Path} is associated with the same {@code FileSystem} as the given
 807      * directory.
 808      *
 809      * <p> The details as to how the name of the file is constructed is
 810      * implementation dependent and therefore not specified. Where possible
 811      * the {@code prefix} and {@code suffix} are used to construct candidate
 812      * names in the same manner as the {@link
 813      * java.io.File#createTempFile(String,String,File)} method.
 814      *
 815      * <p> As with the {@code File.createTempFile} methods, this method is only
 816      * part of a temporary-file facility. Where used as a <em>work files</em>,
 817      * the resulting file may be opened using the {@link
 818      * StandardOpenOption#DELETE_ON_CLOSE DELETE_ON_CLOSE} option so that the
 819      * file is deleted when the appropriate {@code close} method is invoked.
 820      * Alternatively, a {@link Runtime#addShutdownHook shutdown-hook}, or the
 821      * {@link java.io.File#deleteOnExit} mechanism may be used to delete the
 822      * file automatically.
 823      *
 824      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 825      * file-attributes} to set atomically when creating the file. Each attribute
 826      * is identified by its {@link FileAttribute#name name}. If more than one
 827      * attribute of the same name is included in the array then all but the last
 828      * occurrence is ignored. When no file attributes are specified, then the
 829      * resulting file may have more restrictive access permissions to files
 830      * created by the {@link java.io.File#createTempFile(String,String,File)}
 831      * method.
 832      *
 833      * @param   dir
 834      *          the path to directory in which to create the file
 835      * @param   prefix
 836      *          the prefix string to be used in generating the file's name;
 837      *          may be {@code null}
 838      * @param   suffix
 839      *          the suffix string to be used in generating the file's name;
 840      *          may be {@code null}, in which case "{@code .tmp}" is used
 841      * @param   attrs
 842      *          an optional list of file attributes to set atomically when
 843      *          creating the file
 844      *
 845      * @return  the path to the newly created file that did not exist before
 846      *          this method was invoked
 847      *
 848      * @throws  IllegalArgumentException
 849      *          if the prefix or suffix parameters cannot be used to generate
 850      *          a candidate file name
 851      * @throws  UnsupportedOperationException
 852      *          if the array contains an attribute that cannot be set atomically
 853      *          when creating the directory
 854      * @throws  IOException
 855      *          if an I/O error occurs or {@code dir} does not exist
 856      * @throws  SecurityException
 857      *          In the case of the default provider, and a security manager is
 858      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 859      *          method is invoked to check write access to the file.
 860      */
 861     public static Path createTempFile(Path dir,
 862                                       String prefix,
 863                                       String suffix,
 864                                       FileAttribute<?>... attrs)
 865         throws IOException
 866     {
 867         return TempFileHelper.createTempFile(Objects.requireNonNull(dir),
 868                                              prefix, suffix, attrs);
 869     }
 870 
 871     /**
 872      * Creates an empty file in the default temporary-file directory, using
 873      * the given prefix and suffix to generate its name. The resulting {@code
 874      * Path} is associated with the default {@code FileSystem}.
 875      *
 876      * <p> This method works in exactly the manner specified by the
 877      * {@link #createTempFile(Path,String,String,FileAttribute[])} method for
 878      * the case that the {@code dir} parameter is the temporary-file directory.
 879      *
 880      * @param   prefix
 881      *          the prefix string to be used in generating the file's name;
 882      *          may be {@code null}
 883      * @param   suffix
 884      *          the suffix string to be used in generating the file's name;
 885      *          may be {@code null}, in which case "{@code .tmp}" is used
 886      * @param   attrs
 887      *          an optional list of file attributes to set atomically when
 888      *          creating the file
 889      *
 890      * @return  the path to the newly created file that did not exist before
 891      *          this method was invoked
 892      *
 893      * @throws  IllegalArgumentException
 894      *          if the prefix or suffix parameters cannot be used to generate
 895      *          a candidate file name
 896      * @throws  UnsupportedOperationException
 897      *          if the array contains an attribute that cannot be set atomically
 898      *          when creating the directory
 899      * @throws  IOException
 900      *          if an I/O error occurs or the temporary-file directory does not
 901      *          exist
 902      * @throws  SecurityException
 903      *          In the case of the default provider, and a security manager is
 904      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 905      *          method is invoked to check write access to the file.
 906      */
 907     public static Path createTempFile(String prefix,
 908                                       String suffix,
 909                                       FileAttribute<?>... attrs)
 910         throws IOException
 911     {
 912         return TempFileHelper.createTempFile(null, prefix, suffix, attrs);
 913     }
 914 
 915     /**
 916      * Creates a new directory in the specified directory, using the given
 917      * prefix to generate its name.  The resulting {@code Path} is associated
 918      * with the same {@code FileSystem} as the given directory.
 919      *
 920      * <p> The details as to how the name of the directory is constructed is
 921      * implementation dependent and therefore not specified. Where possible
 922      * the {@code prefix} is used to construct candidate names.
 923      *
 924      * <p> As with the {@code createTempFile} methods, this method is only
 925      * part of a temporary-file facility. A {@link Runtime#addShutdownHook
 926      * shutdown-hook}, or the {@link java.io.File#deleteOnExit} mechanism may be
 927      * used to delete the directory automatically.
 928      *
 929      * <p> The {@code attrs} parameter is optional {@link FileAttribute
 930      * file-attributes} to set atomically when creating the directory. Each
 931      * attribute is identified by its {@link FileAttribute#name name}. If more
 932      * than one attribute of the same name is included in the array then all but
 933      * the last occurrence is ignored.
 934      *
 935      * @param   dir
 936      *          the path to directory in which to create the directory
 937      * @param   prefix
 938      *          the prefix string to be used in generating the directory's name;
 939      *          may be {@code null}
 940      * @param   attrs
 941      *          an optional list of file attributes to set atomically when
 942      *          creating the directory
 943      *
 944      * @return  the path to the newly created directory that did not exist before
 945      *          this method was invoked
 946      *
 947      * @throws  IllegalArgumentException
 948      *          if the prefix cannot be used to generate a candidate directory name
 949      * @throws  UnsupportedOperationException
 950      *          if the array contains an attribute that cannot be set atomically
 951      *          when creating the directory
 952      * @throws  IOException
 953      *          if an I/O error occurs or {@code dir} does not exist
 954      * @throws  SecurityException
 955      *          In the case of the default provider, and a security manager is
 956      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 957      *          method is invoked to check write access when creating the
 958      *          directory.
 959      */
 960     public static Path createTempDirectory(Path dir,
 961                                            String prefix,
 962                                            FileAttribute<?>... attrs)
 963         throws IOException
 964     {
 965         return TempFileHelper.createTempDirectory(Objects.requireNonNull(dir),
 966                                                   prefix, attrs);
 967     }
 968 
 969     /**
 970      * Creates a new directory in the default temporary-file directory, using
 971      * the given prefix to generate its name. The resulting {@code Path} is
 972      * associated with the default {@code FileSystem}.
 973      *
 974      * <p> This method works in exactly the manner specified by {@link
 975      * #createTempDirectory(Path,String,FileAttribute[])} method for the case
 976      * that the {@code dir} parameter is the temporary-file directory.
 977      *
 978      * @param   prefix
 979      *          the prefix string to be used in generating the directory's name;
 980      *          may be {@code null}
 981      * @param   attrs
 982      *          an optional list of file attributes to set atomically when
 983      *          creating the directory
 984      *
 985      * @return  the path to the newly created directory that did not exist before
 986      *          this method was invoked
 987      *
 988      * @throws  IllegalArgumentException
 989      *          if the prefix cannot be used to generate a candidate directory name
 990      * @throws  UnsupportedOperationException
 991      *          if the array contains an attribute that cannot be set atomically
 992      *          when creating the directory
 993      * @throws  IOException
 994      *          if an I/O error occurs or the temporary-file directory does not
 995      *          exist
 996      * @throws  SecurityException
 997      *          In the case of the default provider, and a security manager is
 998      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
 999      *          method is invoked to check write access when creating the
1000      *          directory.
1001      */
1002     public static Path createTempDirectory(String prefix,
1003                                            FileAttribute<?>... attrs)
1004         throws IOException
1005     {
1006         return TempFileHelper.createTempDirectory(null, prefix, attrs);
1007     }
1008 
1009     /**
1010      * Creates a symbolic link to a target <i>(optional operation)</i>.
1011      *
1012      * <p> The {@code target} parameter is the target of the link. It may be an
1013      * {@link Path#isAbsolute absolute} or relative path and may not exist. When
1014      * the target is a relative path then file system operations on the resulting
1015      * link are relative to the path of the link.
1016      *
1017      * <p> The {@code attrs} parameter is optional {@link FileAttribute
1018      * attributes} to set atomically when creating the link. Each attribute is
1019      * identified by its {@link FileAttribute#name name}. If more than one attribute
1020      * of the same name is included in the array then all but the last occurrence
1021      * is ignored.
1022      *
1023      * <p> Where symbolic links are supported, but the underlying {@link FileStore}
1024      * does not support symbolic links, then this may fail with an {@link
1025      * IOException}. Additionally, some operating systems may require that the
1026      * Java virtual machine be started with implementation specific privileges to
1027      * create symbolic links, in which case this method may throw {@code IOException}.
1028      *
1029      * @param   link
1030      *          the path of the symbolic link to create
1031      * @param   target
1032      *          the target of the symbolic link
1033      * @param   attrs
1034      *          the array of attributes to set atomically when creating the
1035      *          symbolic link
1036      *
1037      * @return  the path to the symbolic link
1038      *
1039      * @throws  UnsupportedOperationException
1040      *          if the implementation does not support symbolic links or the
1041      *          array contains an attribute that cannot be set atomically when
1042      *          creating the symbolic link
1043      * @throws  FileAlreadyExistsException
1044      *          if a file with the name already exists <i>(optional specific
1045      *          exception)</i>
1046      * @throws  IOException
1047      *          if an I/O error occurs
1048      * @throws  SecurityException
1049      *          In the case of the default provider, and a security manager
1050      *          is installed, it denies {@link LinkPermission}{@code ("symbolic")}
1051      *          or its {@link SecurityManager#checkWrite(String) checkWrite}
1052      *          method denies write access to the path of the symbolic link.
1053      */
1054     public static Path createSymbolicLink(Path link, Path target,
1055                                           FileAttribute<?>... attrs)
1056         throws IOException
1057     {
1058         provider(link).createSymbolicLink(link, target, attrs);
1059         return link;
1060     }
1061 
1062     /**
1063      * Creates a new link (directory entry) for an existing file <i>(optional
1064      * operation)</i>.
1065      *
1066      * <p> The {@code link} parameter locates the directory entry to create.
1067      * The {@code existing} parameter is the path to an existing file. This
1068      * method creates a new directory entry for the file so that it can be
1069      * accessed using {@code link} as the path. On some file systems this is
1070      * known as creating a "hard link". Whether the file attributes are
1071      * maintained for the file or for each directory entry is file system
1072      * specific and therefore not specified. Typically, a file system requires
1073      * that all links (directory entries) for a file be on the same file system.
1074      * Furthermore, on some platforms, the Java virtual machine may require to
1075      * be started with implementation specific privileges to create hard links
1076      * or to create links to directories.
1077      *
1078      * @param   link
1079      *          the link (directory entry) to create
1080      * @param   existing
1081      *          a path to an existing file
1082      *
1083      * @return  the path to the link (directory entry)
1084      *
1085      * @throws  UnsupportedOperationException
1086      *          if the implementation does not support adding an existing file
1087      *          to a directory
1088      * @throws  FileAlreadyExistsException
1089      *          if the entry could not otherwise be created because a file of
1090      *          that name already exists <i>(optional specific exception)</i>
1091      * @throws  IOException
1092      *          if an I/O error occurs
1093      * @throws  SecurityException
1094      *          In the case of the default provider, and a security manager
1095      *          is installed, it denies {@link LinkPermission}{@code ("hard")}
1096      *          or its {@link SecurityManager#checkWrite(String) checkWrite}
1097      *          method denies write access to either the link or the
1098      *          existing file.
1099      */
1100     public static Path createLink(Path link, Path existing) throws IOException {
1101         provider(link).createLink(link, existing);
1102         return link;
1103     }
1104 
1105     /**
1106      * Deletes a file.
1107      *
1108      * <p> An implementation may require to examine the file to determine if the
1109      * file is a directory. Consequently this method may not be atomic with respect
1110      * to other file system operations.  If the file is a symbolic link then the
1111      * symbolic link itself, not the final target of the link, is deleted.
1112      *
1113      * <p> If the file is a directory then the directory must be empty. In some
1114      * implementations a directory has entries for special files or links that
1115      * are created when the directory is created. In such implementations a
1116      * directory is considered empty when only the special entries exist.
1117      * This method can be used with the {@link #walkFileTree walkFileTree}
1118      * method to delete a directory and all entries in the directory, or an
1119      * entire <i>file-tree</i> where required.
1120      *
1121      * <p> On some operating systems it may not be possible to remove a file when
1122      * it is open and in use by this Java virtual machine or other programs.
1123      *
1124      * @param   path
1125      *          the path to the file to delete
1126      *
1127      * @throws  NoSuchFileException
1128      *          if the file does not exist <i>(optional specific exception)</i>
1129      * @throws  DirectoryNotEmptyException
1130      *          if the file is a directory and could not otherwise be deleted
1131      *          because the directory is not empty <i>(optional specific
1132      *          exception)</i>
1133      * @throws  IOException
1134      *          if an I/O error occurs
1135      * @throws  SecurityException
1136      *          In the case of the default provider, and a security manager is
1137      *          installed, the {@link SecurityManager#checkDelete(String)} method
1138      *          is invoked to check delete access to the file
1139      */
1140     public static void delete(Path path) throws IOException {
1141         provider(path).delete(path);
1142     }
1143 
1144     /**
1145      * Deletes a file if it exists.
1146      *
1147      * <p> As with the {@link #delete(Path) delete(Path)} method, an
1148      * implementation may need to examine the file to determine if the file is a
1149      * directory. Consequently this method may not be atomic with respect to
1150      * other file system operations.  If the file is a symbolic link, then the
1151      * symbolic link itself, not the final target of the link, is deleted.
1152      *
1153      * <p> If the file is a directory then the directory must be empty. In some
1154      * implementations a directory has entries for special files or links that
1155      * are created when the directory is created. In such implementations a
1156      * directory is considered empty when only the special entries exist.
1157      *
1158      * <p> On some operating systems it may not be possible to remove a file when
1159      * it is open and in use by this Java virtual machine or other programs.
1160      *
1161      * @param   path
1162      *          the path to the file to delete
1163      *
1164      * @return  {@code true} if the file was deleted by this method; {@code
1165      *          false} if the file could not be deleted because it did not
1166      *          exist
1167      *
1168      * @throws  DirectoryNotEmptyException
1169      *          if the file is a directory and could not otherwise be deleted
1170      *          because the directory is not empty <i>(optional specific
1171      *          exception)</i>
1172      * @throws  IOException
1173      *          if an I/O error occurs
1174      * @throws  SecurityException
1175      *          In the case of the default provider, and a security manager is
1176      *          installed, the {@link SecurityManager#checkDelete(String)} method
1177      *          is invoked to check delete access to the file.
1178      */
1179     public static boolean deleteIfExists(Path path) throws IOException {
1180         return provider(path).deleteIfExists(path);
1181     }
1182 
1183     // -- Copying and moving files --
1184 
1185     /**
1186      * Copy a file to a target file.
1187      *
1188      * <p> This method copies a file to the target file with the {@code
1189      * options} parameter specifying how the copy is performed. By default, the
1190      * copy fails if the target file already exists or is a symbolic link,
1191      * except if the source and target are the {@link #isSameFile same} file, in
1192      * which case the method completes without copying the file. File attributes
1193      * are not required to be copied to the target file. If symbolic links are
1194      * supported, and the file is a symbolic link, then the final target of the
1195      * link is copied. If the file is a directory then it creates an empty
1196      * directory in the target location (entries in the directory are not
1197      * copied). This method can be used with the {@link #walkFileTree
1198      * walkFileTree} method to copy a directory and all entries in the directory,
1199      * or an entire <i>file-tree</i> where required.
1200      *
1201      * <p> The {@code options} parameter may include any of the following:
1202      *
1203      * <table class="striped">
1204      * <caption style="display:none">Options</caption>
1205      * <thead>
1206      * <tr> <th scope="col">Option</th> <th scope="col">Description</th> </tr>
1207      * </thead>
1208      * <tbody>
1209      * <tr>
1210      *   <th scope="row"> {@link StandardCopyOption#REPLACE_EXISTING REPLACE_EXISTING} </th>
1211      *   <td> If the target file exists, then the target file is replaced if it
1212      *     is not a non-empty directory. If the target file exists and is a
1213      *     symbolic link, then the symbolic link itself, not the target of
1214      *     the link, is replaced. </td>
1215      * </tr>
1216      * <tr>
1217      *   <th scope="row"> {@link StandardCopyOption#COPY_ATTRIBUTES COPY_ATTRIBUTES} </th>
1218      *   <td> Attempts to copy the file attributes associated with this file to
1219      *     the target file. The exact file attributes that are copied is platform
1220      *     and file system dependent and therefore unspecified. Minimally, the
1221      *     {@link BasicFileAttributes#lastModifiedTime last-modified-time} is
1222      *     copied to the target file if supported by both the source and target
1223      *     file stores. Copying of file timestamps may result in precision
1224      *     loss. </td>
1225      * </tr>
1226      * <tr>
1227      *   <th scope="row"> {@link LinkOption#NOFOLLOW_LINKS NOFOLLOW_LINKS} </th>
1228      *   <td> Symbolic links are not followed. If the file is a symbolic link,
1229      *     then the symbolic link itself, not the target of the link, is copied.
1230      *     It is implementation specific if file attributes can be copied to the
1231      *     new link. In other words, the {@code COPY_ATTRIBUTES} option may be
1232      *     ignored when copying a symbolic link. </td>
1233      * </tr>
1234      * </tbody>
1235      * </table>
1236      *
1237      * <p> An implementation of this interface may support additional
1238      * implementation specific options.
1239      *
1240      * <p> Copying a file is not an atomic operation. If an {@link IOException}
1241      * is thrown, then it is possible that the target file is incomplete or some
1242      * of its file attributes have not been copied from the source file. When
1243      * the {@code REPLACE_EXISTING} option is specified and the target file
1244      * exists, then the target file is replaced. The check for the existence of
1245      * the file and the creation of the new file may not be atomic with respect
1246      * to other file system activities.
1247      *
1248      * <p> <b>Usage Example:</b>
1249      * Suppose we want to copy a file into a directory, giving it the same file
1250      * name as the source file:
1251      * <pre>
1252      *     Path source = ...
1253      *     Path newdir = ...
1254      *     Files.copy(source, newdir.resolve(source.getFileName());
1255      * </pre>
1256      *
1257      * @param   source
1258      *          the path to the file to copy
1259      * @param   target
1260      *          the path to the target file (may be associated with a different
1261      *          provider to the source path)
1262      * @param   options
1263      *          options specifying how the copy should be done
1264      *
1265      * @return  the path to the target file
1266      *
1267      * @throws  UnsupportedOperationException
1268      *          if the array contains a copy option that is not supported
1269      * @throws  FileAlreadyExistsException
1270      *          if the target file exists but cannot be replaced because the
1271      *          {@code REPLACE_EXISTING} option is not specified <i>(optional
1272      *          specific exception)</i>
1273      * @throws  DirectoryNotEmptyException
1274      *          the {@code REPLACE_EXISTING} option is specified but the file
1275      *          cannot be replaced because it is a non-empty directory
1276      *          <i>(optional specific exception)</i>
1277      * @throws  IOException
1278      *          if an I/O error occurs
1279      * @throws  SecurityException
1280      *          In the case of the default provider, and a security manager is
1281      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
1282      *          method is invoked to check read access to the source file, the
1283      *          {@link SecurityManager#checkWrite(String) checkWrite} is invoked
1284      *          to check write access to the target file. If a symbolic link is
1285      *          copied the security manager is invoked to check {@link
1286      *          LinkPermission}{@code ("symbolic")}.
1287      */
1288     public static Path copy(Path source, Path target, CopyOption... options)
1289         throws IOException
1290     {
1291         FileSystemProvider provider = provider(source);
1292         if (provider(target) == provider) {
1293             // same provider
1294             provider.copy(source, target, options);
1295         } else {
1296             // different providers
1297             CopyMoveHelper.copyToForeignTarget(source, target, options);
1298         }
1299         return target;
1300     }
1301 
1302     /**
1303      * Move or rename a file to a target file.
1304      *
1305      * <p> By default, this method attempts to move the file to the target
1306      * file, failing if the target file exists except if the source and
1307      * target are the {@link #isSameFile same} file, in which case this method
1308      * has no effect. If the file is a symbolic link then the symbolic link
1309      * itself, not the target of the link, is moved. This method may be
1310      * invoked to move an empty directory. In some implementations a directory
1311      * has entries for special files or links that are created when the
1312      * directory is created. In such implementations a directory is considered
1313      * empty when only the special entries exist. When invoked to move a
1314      * directory that is not empty then the directory is moved if it does not
1315      * require moving the entries in the directory.  For example, renaming a
1316      * directory on the same {@link FileStore} will usually not require moving
1317      * the entries in the directory. When moving a directory requires that its
1318      * entries be moved then this method fails (by throwing an {@code
1319      * IOException}). To move a <i>file tree</i> may involve copying rather
1320      * than moving directories and this can be done using the {@link
1321      * #copy copy} method in conjunction with the {@link
1322      * #walkFileTree Files.walkFileTree} utility method.
1323      *
1324      * <p> The {@code options} parameter may include any of the following:
1325      *
1326      * <table class="striped">
1327      * <caption style="display:none">Options</caption>
1328      * <thead>
1329      * <tr> <th scope="col">Option</th> <th scope="col">Description</th> </tr>
1330      * </thead>
1331      * <tbody>
1332      * <tr>
1333      *   <th scope="row"> {@link StandardCopyOption#REPLACE_EXISTING REPLACE_EXISTING} </th>
1334      *   <td> If the target file exists, then the target file is replaced if it
1335      *     is not a non-empty directory. If the target file exists and is a
1336      *     symbolic link, then the symbolic link itself, not the target of
1337      *     the link, is replaced. </td>
1338      * </tr>
1339      * <tr>
1340      *   <th scope="row"> {@link StandardCopyOption#ATOMIC_MOVE ATOMIC_MOVE} </th>
1341      *   <td> The move is performed as an atomic file system operation and all
1342      *     other options are ignored. If the target file exists then it is
1343      *     implementation specific if the existing file is replaced or this method
1344      *     fails by throwing an {@link IOException}. If the move cannot be
1345      *     performed as an atomic file system operation then {@link
1346      *     AtomicMoveNotSupportedException} is thrown. This can arise, for
1347      *     example, when the target location is on a different {@code FileStore}
1348      *     and would require that the file be copied, or target location is
1349      *     associated with a different provider to this object. </td>
1350      * </tbody>
1351      * </table>
1352      *
1353      * <p> An implementation of this interface may support additional
1354      * implementation specific options.
1355      *
1356      * <p> Moving a file will copy the {@link
1357      * BasicFileAttributes#lastModifiedTime last-modified-time} to the target
1358      * file if supported by both source and target file stores. Copying of file
1359      * timestamps may result in precision loss. An implementation may also
1360      * attempt to copy other file attributes but is not required to fail if the
1361      * file attributes cannot be copied. When the move is performed as
1362      * a non-atomic operation, and an {@code IOException} is thrown, then the
1363      * state of the files is not defined. The original file and the target file
1364      * may both exist, the target file may be incomplete or some of its file
1365      * attributes may not been copied from the original file.
1366      *
1367      * <p> <b>Usage Examples:</b>
1368      * Suppose we want to rename a file to "newname", keeping the file in the
1369      * same directory:
1370      * <pre>
1371      *     Path source = ...
1372      *     Files.move(source, source.resolveSibling("newname"));
1373      * </pre>
1374      * Alternatively, suppose we want to move a file to new directory, keeping
1375      * the same file name, and replacing any existing file of that name in the
1376      * directory:
1377      * <pre>
1378      *     Path source = ...
1379      *     Path newdir = ...
1380      *     Files.move(source, newdir.resolve(source.getFileName()), REPLACE_EXISTING);
1381      * </pre>
1382      *
1383      * @param   source
1384      *          the path to the file to move
1385      * @param   target
1386      *          the path to the target file (may be associated with a different
1387      *          provider to the source path)
1388      * @param   options
1389      *          options specifying how the move should be done
1390      *
1391      * @return  the path to the target file
1392      *
1393      * @throws  UnsupportedOperationException
1394      *          if the array contains a copy option that is not supported
1395      * @throws  FileAlreadyExistsException
1396      *          if the target file exists but cannot be replaced because the
1397      *          {@code REPLACE_EXISTING} option is not specified <i>(optional
1398      *          specific exception)</i>
1399      * @throws  DirectoryNotEmptyException
1400      *          the {@code REPLACE_EXISTING} option is specified but the file
1401      *          cannot be replaced because it is a non-empty directory, or the
1402      *          source is a non-empty directory containing entries that would
1403      *          be required to be moved <i>(optional specific exceptions)</i>
1404      * @throws  AtomicMoveNotSupportedException
1405      *          if the options array contains the {@code ATOMIC_MOVE} option but
1406      *          the file cannot be moved as an atomic file system operation.
1407      * @throws  IOException
1408      *          if an I/O error occurs
1409      * @throws  SecurityException
1410      *          In the case of the default provider, and a security manager is
1411      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
1412      *          method is invoked to check write access to both the source and
1413      *          target file.
1414      */
1415     public static Path move(Path source, Path target, CopyOption... options)
1416         throws IOException
1417     {
1418         FileSystemProvider provider = provider(source);
1419         if (provider(target) == provider) {
1420             // same provider
1421             provider.move(source, target, options);
1422         } else {
1423             // different providers
1424             CopyMoveHelper.moveToForeignTarget(source, target, options);
1425         }
1426         return target;
1427     }
1428 
1429     // -- Miscellaneous --
1430 
1431     /**
1432      * Reads the target of a symbolic link <i>(optional operation)</i>.
1433      *
1434      * <p> If the file system supports <a href="package-summary.html#links">symbolic
1435      * links</a> then this method is used to read the target of the link, failing
1436      * if the file is not a symbolic link. The target of the link need not exist.
1437      * The returned {@code Path} object will be associated with the same file
1438      * system as {@code link}.
1439      *
1440      * @param   link
1441      *          the path to the symbolic link
1442      *
1443      * @return  a {@code Path} object representing the target of the link
1444      *
1445      * @throws  UnsupportedOperationException
1446      *          if the implementation does not support symbolic links
1447      * @throws  NotLinkException
1448      *          if the target could otherwise not be read because the file
1449      *          is not a symbolic link <i>(optional specific exception)</i>
1450      * @throws  IOException
1451      *          if an I/O error occurs
1452      * @throws  SecurityException
1453      *          In the case of the default provider, and a security manager
1454      *          is installed, it checks that {@code FilePermission} has been
1455      *          granted with the "{@code readlink}" action to read the link.
1456      */
1457     public static Path readSymbolicLink(Path link) throws IOException {
1458         return provider(link).readSymbolicLink(link);
1459     }
1460 
1461     /**
1462      * Returns the {@link FileStore} representing the file store where a file
1463      * is located.
1464      *
1465      * <p> Once a reference to the {@code FileStore} is obtained it is
1466      * implementation specific if operations on the returned {@code FileStore},
1467      * or {@link FileStoreAttributeView} objects obtained from it, continue
1468      * to depend on the existence of the file. In particular the behavior is not
1469      * defined for the case that the file is deleted or moved to a different
1470      * file store.
1471      *
1472      * @param   path
1473      *          the path to the file
1474      *
1475      * @return  the file store where the file is stored
1476      *
1477      * @throws  IOException
1478      *          if an I/O error occurs
1479      * @throws  SecurityException
1480      *          In the case of the default provider, and a security manager is
1481      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
1482      *          method is invoked to check read access to the file, and in
1483      *          addition it checks
1484      *          {@link RuntimePermission}{@code ("getFileStoreAttributes")}
1485      */
1486     public static FileStore getFileStore(Path path) throws IOException {
1487         return provider(path).getFileStore(path);
1488     }
1489 
1490     /**
1491      * Tests if two paths locate the same file.
1492      *
1493      * <p> If both {@code Path} objects are {@link Path#equals(Object) equal}
1494      * then this method returns {@code true} without checking if the file exists.
1495      * If the two {@code Path} objects are associated with different providers
1496      * then this method returns {@code false}. Otherwise, this method checks if
1497      * both {@code Path} objects locate the same file, and depending on the
1498      * implementation, may require to open or access both files.
1499      *
1500      * <p> If the file system and files remain static, then this method implements
1501      * an equivalence relation for non-null {@code Paths}.
1502      * <ul>
1503      * <li>It is <i>reflexive</i>: for {@code Path} {@code f},
1504      *     {@code isSameFile(f,f)} should return {@code true}.
1505      * <li>It is <i>symmetric</i>: for two {@code Paths} {@code f} and {@code g},
1506      *     {@code isSameFile(f,g)} will equal {@code isSameFile(g,f)}.
1507      * <li>It is <i>transitive</i>: for three {@code Paths}
1508      *     {@code f}, {@code g}, and {@code h}, if {@code isSameFile(f,g)} returns
1509      *     {@code true} and {@code isSameFile(g,h)} returns {@code true}, then
1510      *     {@code isSameFile(f,h)} will return {@code true}.
1511      * </ul>
1512      *
1513      * @param   path
1514      *          one path to the file
1515      * @param   path2
1516      *          the other path
1517      *
1518      * @return  {@code true} if, and only if, the two paths locate the same file
1519      *
1520      * @throws  IOException
1521      *          if an I/O error occurs
1522      * @throws  SecurityException
1523      *          In the case of the default provider, and a security manager is
1524      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
1525      *          method is invoked to check read access to both files.
1526      *
1527      * @see java.nio.file.attribute.BasicFileAttributes#fileKey
1528      */
1529     public static boolean isSameFile(Path path, Path path2) throws IOException {
1530         return provider(path).isSameFile(path, path2);
1531     }
1532 
1533     /**
1534      * Tells whether or not a file is considered <em>hidden</em>. The exact
1535      * definition of hidden is platform or provider dependent. On UNIX for
1536      * example a file is considered to be hidden if its name begins with a
1537      * period character ('.'). On Windows a file is considered hidden if it
1538      * isn't a directory and the DOS {@link DosFileAttributes#isHidden hidden}
1539      * attribute is set.
1540      *
1541      * <p> Depending on the implementation this method may require to access
1542      * the file system to determine if the file is considered hidden.
1543      *
1544      * @param   path
1545      *          the path to the file to test
1546      *
1547      * @return  {@code true} if the file is considered hidden
1548      *
1549      * @throws  IOException
1550      *          if an I/O error occurs
1551      * @throws  SecurityException
1552      *          In the case of the default provider, and a security manager is
1553      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
1554      *          method is invoked to check read access to the file.
1555      */
1556     public static boolean isHidden(Path path) throws IOException {
1557         return provider(path).isHidden(path);
1558     }
1559 
1560     // lazy loading of default and installed file type detectors
1561     private static class FileTypeDetectors{
1562         static final FileTypeDetector defaultFileTypeDetector =
1563             createDefaultFileTypeDetector();
1564         static final List<FileTypeDetector> installedDetectors =
1565             loadInstalledDetectors();
1566 
1567         // creates the default file type detector
1568         private static FileTypeDetector createDefaultFileTypeDetector() {
1569             return AccessController
1570                 .doPrivileged(new PrivilegedAction<>() {
1571                     @Override public FileTypeDetector run() {
1572                         return sun.nio.fs.DefaultFileTypeDetector.create();
1573                 }});
1574         }
1575 
1576         // loads all installed file type detectors
1577         private static List<FileTypeDetector> loadInstalledDetectors() {
1578             return AccessController
1579                 .doPrivileged(new PrivilegedAction<>() {
1580                     @Override public List<FileTypeDetector> run() {
1581                         List<FileTypeDetector> list = new ArrayList<>();
1582                         ServiceLoader<FileTypeDetector> loader = ServiceLoader
1583                             .load(FileTypeDetector.class, ClassLoader.getSystemClassLoader());
1584                         for (FileTypeDetector detector: loader) {
1585                             list.add(detector);
1586                         }
1587                         return list;
1588                 }});
1589         }
1590     }
1591 
1592     /**
1593      * Probes the content type of a file.
1594      *
1595      * <p> This method uses the installed {@link FileTypeDetector} implementations
1596      * to probe the given file to determine its content type. Each file type
1597      * detector's {@link FileTypeDetector#probeContentType probeContentType} is
1598      * invoked, in turn, to probe the file type. If the file is recognized then
1599      * the content type is returned. If the file is not recognized by any of the
1600      * installed file type detectors then a system-default file type detector is
1601      * invoked to guess the content type.
1602      *
1603      * <p> A given invocation of the Java virtual machine maintains a system-wide
1604      * list of file type detectors. Installed file type detectors are loaded
1605      * using the service-provider loading facility defined by the {@link ServiceLoader}
1606      * class. Installed file type detectors are loaded using the system class
1607      * loader. If the system class loader cannot be found then the platform class
1608      * loader is used. File type detectors are typically installed
1609      * by placing them in a JAR file on the application class path,
1610      * the JAR file contains a provider-configuration file
1611      * named {@code java.nio.file.spi.FileTypeDetector} in the resource directory
1612      * {@code META-INF/services}, and the file lists one or more fully-qualified
1613      * names of concrete subclass of {@code FileTypeDetector } that have a zero
1614      * argument constructor. If the process of locating or instantiating the
1615      * installed file type detectors fails then an unspecified error is thrown.
1616      * The ordering that installed providers are located is implementation
1617      * specific.
1618      *
1619      * <p> The return value of this method is the string form of the value of a
1620      * Multipurpose Internet Mail Extension (MIME) content type as
1621      * defined by <a href="http://www.ietf.org/rfc/rfc2045.txt"><i>RFC&nbsp;2045:
1622      * Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet
1623      * Message Bodies</i></a>. The string is guaranteed to be parsable according
1624      * to the grammar in the RFC.
1625      *
1626      * @param   path
1627      *          the path to the file to probe
1628      *
1629      * @return  The content type of the file, or {@code null} if the content
1630      *          type cannot be determined
1631      *
1632      * @throws  IOException
1633      *          if an I/O error occurs
1634      * @throws  SecurityException
1635      *          If a security manager is installed and it denies an unspecified
1636      *          permission required by a file type detector implementation.
1637      */
1638     public static String probeContentType(Path path)
1639         throws IOException
1640     {
1641         // try installed file type detectors
1642         for (FileTypeDetector detector: FileTypeDetectors.installedDetectors) {
1643             String result = detector.probeContentType(path);
1644             if (result != null)
1645                 return result;
1646         }
1647 
1648         // fallback to default
1649         return FileTypeDetectors.defaultFileTypeDetector.probeContentType(path);
1650     }
1651 
1652     // -- File Attributes --
1653 
1654     /**
1655      * Returns a file attribute view of a given type.
1656      *
1657      * <p> A file attribute view provides a read-only or updatable view of a
1658      * set of file attributes. This method is intended to be used where the file
1659      * attribute view defines type-safe methods to read or update the file
1660      * attributes. The {@code type} parameter is the type of the attribute view
1661      * required and the method returns an instance of that type if supported.
1662      * The {@link BasicFileAttributeView} type supports access to the basic
1663      * attributes of a file. Invoking this method to select a file attribute
1664      * view of that type will always return an instance of that class.
1665      *
1666      * <p> The {@code options} array may be used to indicate how symbolic links
1667      * are handled by the resulting file attribute view for the case that the
1668      * file is a symbolic link. By default, symbolic links are followed. If the
1669      * option {@link LinkOption#NOFOLLOW_LINKS NOFOLLOW_LINKS} is present then
1670      * symbolic links are not followed. This option is ignored by implementations
1671      * that do not support symbolic links.
1672      *
1673      * <p> <b>Usage Example:</b>
1674      * Suppose we want read or set a file's ACL, if supported:
1675      * <pre>
1676      *     Path path = ...
1677      *     AclFileAttributeView view = Files.getFileAttributeView(path, AclFileAttributeView.class);
1678      *     if (view != null) {
1679      *         List&lt;AclEntry&gt; acl = view.getAcl();
1680      *         :
1681      *     }
1682      * </pre>
1683      *
1684      * @param   <V>
1685      *          The {@code FileAttributeView} type
1686      * @param   path
1687      *          the path to the file
1688      * @param   type
1689      *          the {@code Class} object corresponding to the file attribute view
1690      * @param   options
1691      *          options indicating how symbolic links are handled
1692      *
1693      * @return  a file attribute view of the specified type, or {@code null} if
1694      *          the attribute view type is not available
1695      */
1696     public static <V extends FileAttributeView> V getFileAttributeView(Path path,
1697                                                                        Class<V> type,
1698                                                                        LinkOption... options)
1699     {
1700         return provider(path).getFileAttributeView(path, type, options);
1701     }
1702 
1703     /**
1704      * Reads a file's attributes as a bulk operation.
1705      *
1706      * <p> The {@code type} parameter is the type of the attributes required
1707      * and this method returns an instance of that type if supported. All
1708      * implementations support a basic set of file attributes and so invoking
1709      * this method with a  {@code type} parameter of {@code
1710      * BasicFileAttributes.class} will not throw {@code
1711      * UnsupportedOperationException}.
1712      *
1713      * <p> The {@code options} array may be used to indicate how symbolic links
1714      * are handled for the case that the file is a symbolic link. By default,
1715      * symbolic links are followed and the file attribute of the final target
1716      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
1717      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
1718      *
1719      * <p> It is implementation specific if all file attributes are read as an
1720      * atomic operation with respect to other file system operations.
1721      *
1722      * <p> <b>Usage Example:</b>
1723      * Suppose we want to read a file's attributes in bulk:
1724      * <pre>
1725      *    Path path = ...
1726      *    BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
1727      * </pre>
1728      * Alternatively, suppose we want to read file's POSIX attributes without
1729      * following symbolic links:
1730      * <pre>
1731      *    PosixFileAttributes attrs =
1732      *        Files.readAttributes(path, PosixFileAttributes.class, NOFOLLOW_LINKS);
1733      * </pre>
1734      *
1735      * @param   <A>
1736      *          The {@code BasicFileAttributes} type
1737      * @param   path
1738      *          the path to the file
1739      * @param   type
1740      *          the {@code Class} of the file attributes required
1741      *          to read
1742      * @param   options
1743      *          options indicating how symbolic links are handled
1744      *
1745      * @return  the file attributes
1746      *
1747      * @throws  UnsupportedOperationException
1748      *          if an attributes of the given type are not supported
1749      * @throws  IOException
1750      *          if an I/O error occurs
1751      * @throws  SecurityException
1752      *          In the case of the default provider, a security manager is
1753      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
1754      *          method is invoked to check read access to the file. If this
1755      *          method is invoked to read security sensitive attributes then the
1756      *          security manager may be invoke to check for additional permissions.
1757      */
1758     public static <A extends BasicFileAttributes> A readAttributes(Path path,
1759                                                                    Class<A> type,
1760                                                                    LinkOption... options)
1761         throws IOException
1762     {
1763         return provider(path).readAttributes(path, type, options);
1764     }
1765 
1766     /**
1767      * Sets the value of a file attribute.
1768      *
1769      * <p> The {@code attribute} parameter identifies the attribute to be set
1770      * and takes the form:
1771      * <blockquote>
1772      * [<i>view-name</i><b>:</b>]<i>attribute-name</i>
1773      * </blockquote>
1774      * where square brackets [...] delineate an optional component and the
1775      * character {@code ':'} stands for itself.
1776      *
1777      * <p> <i>view-name</i> is the {@link FileAttributeView#name name} of a {@link
1778      * FileAttributeView} that identifies a set of file attributes. If not
1779      * specified then it defaults to {@code "basic"}, the name of the file
1780      * attribute view that identifies the basic set of file attributes common to
1781      * many file systems. <i>attribute-name</i> is the name of the attribute
1782      * within the set.
1783      *
1784      * <p> The {@code options} array may be used to indicate how symbolic links
1785      * are handled for the case that the file is a symbolic link. By default,
1786      * symbolic links are followed and the file attribute of the final target
1787      * of the link is set. If the option {@link LinkOption#NOFOLLOW_LINKS
1788      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
1789      *
1790      * <p> <b>Usage Example:</b>
1791      * Suppose we want to set the DOS "hidden" attribute:
1792      * <pre>
1793      *    Path path = ...
1794      *    Files.setAttribute(path, "dos:hidden", true);
1795      * </pre>
1796      *
1797      * @param   path
1798      *          the path to the file
1799      * @param   attribute
1800      *          the attribute to set
1801      * @param   value
1802      *          the attribute value
1803      * @param   options
1804      *          options indicating how symbolic links are handled
1805      *
1806      * @return  the given path
1807      *
1808      * @throws  UnsupportedOperationException
1809      *          if the attribute view is not available
1810      * @throws  IllegalArgumentException
1811      *          if the attribute name is not specified, or is not recognized, or
1812      *          the attribute value is of the correct type but has an
1813      *          inappropriate value
1814      * @throws  ClassCastException
1815      *          if the attribute value is not of the expected type or is a
1816      *          collection containing elements that are not of the expected
1817      *          type
1818      * @throws  IOException
1819      *          if an I/O error occurs
1820      * @throws  SecurityException
1821      *          In the case of the default provider, and a security manager is
1822      *          installed, its {@link SecurityManager#checkWrite(String) checkWrite}
1823      *          method denies write access to the file. If this method is invoked
1824      *          to set security sensitive attributes then the security manager
1825      *          may be invoked to check for additional permissions.
1826      */
1827     public static Path setAttribute(Path path, String attribute, Object value,
1828                                     LinkOption... options)
1829         throws IOException
1830     {
1831         provider(path).setAttribute(path, attribute, value, options);
1832         return path;
1833     }
1834 
1835     /**
1836      * Reads the value of a file attribute.
1837      *
1838      * <p> The {@code attribute} parameter identifies the attribute to be read
1839      * and takes the form:
1840      * <blockquote>
1841      * [<i>view-name</i><b>:</b>]<i>attribute-name</i>
1842      * </blockquote>
1843      * where square brackets [...] delineate an optional component and the
1844      * character {@code ':'} stands for itself.
1845      *
1846      * <p> <i>view-name</i> is the {@link FileAttributeView#name name} of a {@link
1847      * FileAttributeView} that identifies a set of file attributes. If not
1848      * specified then it defaults to {@code "basic"}, the name of the file
1849      * attribute view that identifies the basic set of file attributes common to
1850      * many file systems. <i>attribute-name</i> is the name of the attribute.
1851      *
1852      * <p> The {@code options} array may be used to indicate how symbolic links
1853      * are handled for the case that the file is a symbolic link. By default,
1854      * symbolic links are followed and the file attribute of the final target
1855      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
1856      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
1857      *
1858      * <p> <b>Usage Example:</b>
1859      * Suppose we require the user ID of the file owner on a system that
1860      * supports a "{@code unix}" view:
1861      * <pre>
1862      *    Path path = ...
1863      *    int uid = (Integer)Files.getAttribute(path, "unix:uid");
1864      * </pre>
1865      *
1866      * @param   path
1867      *          the path to the file
1868      * @param   attribute
1869      *          the attribute to read
1870      * @param   options
1871      *          options indicating how symbolic links are handled
1872      *
1873      * @return  the attribute value
1874      *
1875      * @throws  UnsupportedOperationException
1876      *          if the attribute view is not available
1877      * @throws  IllegalArgumentException
1878      *          if the attribute name is not specified or is not recognized
1879      * @throws  IOException
1880      *          if an I/O error occurs
1881      * @throws  SecurityException
1882      *          In the case of the default provider, and a security manager is
1883      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
1884      *          method denies read access to the file. If this method is invoked
1885      *          to read security sensitive attributes then the security manager
1886      *          may be invoked to check for additional permissions.
1887      */
1888     public static Object getAttribute(Path path, String attribute,
1889                                       LinkOption... options)
1890         throws IOException
1891     {
1892         // only one attribute should be read
1893         if (attribute.indexOf('*') >= 0 || attribute.indexOf(',') >= 0)
1894             throw new IllegalArgumentException(attribute);
1895         Map<String,Object> map = readAttributes(path, attribute, options);
1896         assert map.size() == 1;
1897         String name;
1898         int pos = attribute.indexOf(':');
1899         if (pos == -1) {
1900             name = attribute;
1901         } else {
1902             name = (pos == attribute.length()) ? "" : attribute.substring(pos+1);
1903         }
1904         return map.get(name);
1905     }
1906 
1907     /**
1908      * Reads a set of file attributes as a bulk operation.
1909      *
1910      * <p> The {@code attributes} parameter identifies the attributes to be read
1911      * and takes the form:
1912      * <blockquote>
1913      * [<i>view-name</i><b>:</b>]<i>attribute-list</i>
1914      * </blockquote>
1915      * where square brackets [...] delineate an optional component and the
1916      * character {@code ':'} stands for itself.
1917      *
1918      * <p> <i>view-name</i> is the {@link FileAttributeView#name name} of a {@link
1919      * FileAttributeView} that identifies a set of file attributes. If not
1920      * specified then it defaults to {@code "basic"}, the name of the file
1921      * attribute view that identifies the basic set of file attributes common to
1922      * many file systems.
1923      *
1924      * <p> The <i>attribute-list</i> component is a comma separated list of
1925      * one or more names of attributes to read. If the list contains the value
1926      * {@code "*"} then all attributes are read. Attributes that are not supported
1927      * are ignored and will not be present in the returned map. It is
1928      * implementation specific if all attributes are read as an atomic operation
1929      * with respect to other file system operations.
1930      *
1931      * <p> The following examples demonstrate possible values for the {@code
1932      * attributes} parameter:
1933      *
1934      * <table class="striped" style="text-align: left; margin-left:2em">
1935      * <caption style="display:none">Possible values</caption>
1936      * <thead>
1937      * <tr>
1938      *  <th scope="col">Example
1939      *  <th scope="col">Description
1940      * </thead>
1941      * <tbody>
1942      * <tr>
1943      *   <th scope="row"> {@code "*"} </th>
1944      *   <td> Read all {@link BasicFileAttributes basic-file-attributes}. </td>
1945      * </tr>
1946      * <tr>
1947      *   <th scope="row"> {@code "size,lastModifiedTime,lastAccessTime"} </th>
1948      *   <td> Reads the file size, last modified time, and last access time
1949      *     attributes. </td>
1950      * </tr>
1951      * <tr>
1952      *   <th scope="row"> {@code "posix:*"} </th>
1953      *   <td> Read all {@link PosixFileAttributes POSIX-file-attributes}. </td>
1954      * </tr>
1955      * <tr>
1956      *   <th scope="row"> {@code "posix:permissions,owner,size"} </th>
1957      *   <td> Reads the POSIX file permissions, owner, and file size. </td>
1958      * </tr>
1959      * </tbody>
1960      * </table>
1961      *
1962      * <p> The {@code options} array may be used to indicate how symbolic links
1963      * are handled for the case that the file is a symbolic link. By default,
1964      * symbolic links are followed and the file attribute of the final target
1965      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
1966      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
1967      *
1968      * @param   path
1969      *          the path to the file
1970      * @param   attributes
1971      *          the attributes to read
1972      * @param   options
1973      *          options indicating how symbolic links are handled
1974      *
1975      * @return  a map of the attributes returned; The map's keys are the
1976      *          attribute names, its values are the attribute values
1977      *
1978      * @throws  UnsupportedOperationException
1979      *          if the attribute view is not available
1980      * @throws  IllegalArgumentException
1981      *          if no attributes are specified or an unrecognized attribute is
1982      *          specified
1983      * @throws  IOException
1984      *          if an I/O error occurs
1985      * @throws  SecurityException
1986      *          In the case of the default provider, and a security manager is
1987      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
1988      *          method denies read access to the file. If this method is invoked
1989      *          to read security sensitive attributes then the security manager
1990      *          may be invoke to check for additional permissions.
1991      */
1992     public static Map<String,Object> readAttributes(Path path, String attributes,
1993                                                     LinkOption... options)
1994         throws IOException
1995     {
1996         return provider(path).readAttributes(path, attributes, options);
1997     }
1998 
1999     /**
2000      * Returns a file's POSIX file permissions.
2001      *
2002      * <p> The {@code path} parameter is associated with a {@code FileSystem}
2003      * that supports the {@link PosixFileAttributeView}. This attribute view
2004      * provides access to file attributes commonly associated with files on file
2005      * systems used by operating systems that implement the Portable Operating
2006      * System Interface (POSIX) family of standards.
2007      *
2008      * <p> The {@code options} array may be used to indicate how symbolic links
2009      * are handled for the case that the file is a symbolic link. By default,
2010      * symbolic links are followed and the file attribute of the final target
2011      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
2012      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
2013      *
2014      * @param   path
2015      *          the path to the file
2016      * @param   options
2017      *          options indicating how symbolic links are handled
2018      *
2019      * @return  the file permissions
2020      *
2021      * @throws  UnsupportedOperationException
2022      *          if the associated file system does not support the {@code
2023      *          PosixFileAttributeView}
2024      * @throws  IOException
2025      *          if an I/O error occurs
2026      * @throws  SecurityException
2027      *          In the case of the default provider, a security manager is
2028      *          installed, and it denies
2029      *          {@link RuntimePermission}{@code ("accessUserInformation")}
2030      *          or its {@link SecurityManager#checkRead(String) checkRead} method
2031      *          denies read access to the file.
2032      */
2033     public static Set<PosixFilePermission> getPosixFilePermissions(Path path,
2034                                                                    LinkOption... options)
2035         throws IOException
2036     {
2037         return readAttributes(path, PosixFileAttributes.class, options).permissions();
2038     }
2039 
2040     /**
2041      * Sets a file's POSIX permissions.
2042      *
2043      * <p> The {@code path} parameter is associated with a {@code FileSystem}
2044      * that supports the {@link PosixFileAttributeView}. This attribute view
2045      * provides access to file attributes commonly associated with files on file
2046      * systems used by operating systems that implement the Portable Operating
2047      * System Interface (POSIX) family of standards.
2048      *
2049      * @param   path
2050      *          The path to the file
2051      * @param   perms
2052      *          The new set of permissions
2053      *
2054      * @return  The given path
2055      *
2056      * @throws  UnsupportedOperationException
2057      *          if the associated file system does not support the {@code
2058      *          PosixFileAttributeView}
2059      * @throws  ClassCastException
2060      *          if the sets contains elements that are not of type {@code
2061      *          PosixFilePermission}
2062      * @throws  IOException
2063      *          if an I/O error occurs
2064      * @throws  SecurityException
2065      *          In the case of the default provider, and a security manager is
2066      *          installed, it denies
2067      *          {@link RuntimePermission}{@code ("accessUserInformation")}
2068      *          or its {@link SecurityManager#checkWrite(String) checkWrite}
2069      *          method denies write access to the file.
2070      */
2071     public static Path setPosixFilePermissions(Path path,
2072                                                Set<PosixFilePermission> perms)
2073         throws IOException
2074     {
2075         PosixFileAttributeView view =
2076             getFileAttributeView(path, PosixFileAttributeView.class);
2077         if (view == null)
2078             throw new UnsupportedOperationException();
2079         view.setPermissions(perms);
2080         return path;
2081     }
2082 
2083     /**
2084      * Returns the owner of a file.
2085      *
2086      * <p> The {@code path} parameter is associated with a file system that
2087      * supports {@link FileOwnerAttributeView}. This file attribute view provides
2088      * access to a file attribute that is the owner of the file.
2089      *
2090      * @param   path
2091      *          The path to the file
2092      * @param   options
2093      *          options indicating how symbolic links are handled
2094      *
2095      * @return  A user principal representing the owner of the file
2096      *
2097      * @throws  UnsupportedOperationException
2098      *          if the associated file system does not support the {@code
2099      *          FileOwnerAttributeView}
2100      * @throws  IOException
2101      *          if an I/O error occurs
2102      * @throws  SecurityException
2103      *          In the case of the default provider, and a security manager is
2104      *          installed, it denies
2105      *          {@link RuntimePermission}{@code ("accessUserInformation")}
2106      *          or its {@link SecurityManager#checkRead(String) checkRead} method
2107      *          denies read access to the file.
2108      */
2109     public static UserPrincipal getOwner(Path path, LinkOption... options) throws IOException {
2110         FileOwnerAttributeView view =
2111             getFileAttributeView(path, FileOwnerAttributeView.class, options);
2112         if (view == null)
2113             throw new UnsupportedOperationException();
2114         return view.getOwner();
2115     }
2116 
2117     /**
2118      * Updates the file owner.
2119      *
2120      * <p> The {@code path} parameter is associated with a file system that
2121      * supports {@link FileOwnerAttributeView}. This file attribute view provides
2122      * access to a file attribute that is the owner of the file.
2123      *
2124      * <p> <b>Usage Example:</b>
2125      * Suppose we want to make "joe" the owner of a file:
2126      * <pre>
2127      *     Path path = ...
2128      *     UserPrincipalLookupService lookupService =
2129      *         provider(path).getUserPrincipalLookupService();
2130      *     UserPrincipal joe = lookupService.lookupPrincipalByName("joe");
2131      *     Files.setOwner(path, joe);
2132      * </pre>
2133      *
2134      * @param   path
2135      *          The path to the file
2136      * @param   owner
2137      *          The new file owner
2138      *
2139      * @return  The given path
2140      *
2141      * @throws  UnsupportedOperationException
2142      *          if the associated file system does not support the {@code
2143      *          FileOwnerAttributeView}
2144      * @throws  IOException
2145      *          if an I/O error occurs
2146      * @throws  SecurityException
2147      *          In the case of the default provider, and a security manager is
2148      *          installed, it denies
2149      *          {@link RuntimePermission}{@code ("accessUserInformation")}
2150      *          or its {@link SecurityManager#checkWrite(String) checkWrite}
2151      *          method denies write access to the file.
2152      *
2153      * @see FileSystem#getUserPrincipalLookupService
2154      * @see java.nio.file.attribute.UserPrincipalLookupService
2155      */
2156     public static Path setOwner(Path path, UserPrincipal owner)
2157         throws IOException
2158     {
2159         FileOwnerAttributeView view =
2160             getFileAttributeView(path, FileOwnerAttributeView.class);
2161         if (view == null)
2162             throw new UnsupportedOperationException();
2163         view.setOwner(owner);
2164         return path;
2165     }
2166 
2167     /**
2168      * Tests whether a file is a symbolic link.
2169      *
2170      * <p> Where it is required to distinguish an I/O exception from the case
2171      * that the file is not a symbolic link then the file attributes can be
2172      * read with the {@link #readAttributes(Path,Class,LinkOption[])
2173      * readAttributes} method and the file type tested with the {@link
2174      * BasicFileAttributes#isSymbolicLink} method.
2175      *
2176      * @param   path  The path to the file
2177      *
2178      * @return  {@code true} if the file is a symbolic link; {@code false} if
2179      *          the file does not exist, is not a symbolic link, or it cannot
2180      *          be determined if the file is a symbolic link or not.
2181      *
2182      * @throws  SecurityException
2183      *          In the case of the default provider, and a security manager is
2184      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
2185      *          method denies read access to the file.
2186      */
2187     public static boolean isSymbolicLink(Path path) {
2188         try {
2189             return readAttributes(path,
2190                                   BasicFileAttributes.class,
2191                                   LinkOption.NOFOLLOW_LINKS).isSymbolicLink();
2192         } catch (IOException ioe) {
2193             return false;
2194         }
2195     }
2196 
2197     /**
2198      * Tests whether a file is a directory.
2199      *
2200      * <p> The {@code options} array may be used to indicate how symbolic links
2201      * are handled for the case that the file is a symbolic link. By default,
2202      * symbolic links are followed and the file attribute of the final target
2203      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
2204      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
2205      *
2206      * <p> Where it is required to distinguish an I/O exception from the case
2207      * that the file is not a directory then the file attributes can be
2208      * read with the {@link #readAttributes(Path,Class,LinkOption[])
2209      * readAttributes} method and the file type tested with the {@link
2210      * BasicFileAttributes#isDirectory} method.
2211      *
2212      * @param   path
2213      *          the path to the file to test
2214      * @param   options
2215      *          options indicating how symbolic links are handled
2216      *
2217      * @return  {@code true} if the file is a directory; {@code false} if
2218      *          the file does not exist, is not a directory, or it cannot
2219      *          be determined if the file is a directory or not.
2220      *
2221      * @throws  SecurityException
2222      *          In the case of the default provider, and a security manager is
2223      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
2224      *          method denies read access to the file.
2225      */
2226     public static boolean isDirectory(Path path, LinkOption... options) {
2227         if (options.length == 0) {
2228             FileSystemProvider provider = provider(path);
2229             if (provider instanceof AbstractFileSystemProvider)
2230                 return ((AbstractFileSystemProvider)provider).isDirectory(path);
2231         }
2232 
2233         try {
2234             return readAttributes(path, BasicFileAttributes.class, options).isDirectory();
2235         } catch (IOException ioe) {
2236             return false;
2237         }
2238     }
2239 
2240     /**
2241      * Tests whether a file is a regular file with opaque content.
2242      *
2243      * <p> The {@code options} array may be used to indicate how symbolic links
2244      * are handled for the case that the file is a symbolic link. By default,
2245      * symbolic links are followed and the file attribute of the final target
2246      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
2247      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
2248      *
2249      * <p> Where it is required to distinguish an I/O exception from the case
2250      * that the file is not a regular file then the file attributes can be
2251      * read with the {@link #readAttributes(Path,Class,LinkOption[])
2252      * readAttributes} method and the file type tested with the {@link
2253      * BasicFileAttributes#isRegularFile} method.
2254      *
2255      * @param   path
2256      *          the path to the file
2257      * @param   options
2258      *          options indicating how symbolic links are handled
2259      *
2260      * @return  {@code true} if the file is a regular file; {@code false} if
2261      *          the file does not exist, is not a regular file, or it
2262      *          cannot be determined if the file is a regular file or not.
2263      *
2264      * @throws  SecurityException
2265      *          In the case of the default provider, and a security manager is
2266      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
2267      *          method denies read access to the file.
2268      */
2269     public static boolean isRegularFile(Path path, LinkOption... options) {
2270         if (options.length == 0) {
2271             FileSystemProvider provider = provider(path);
2272             if (provider instanceof AbstractFileSystemProvider)
2273                 return ((AbstractFileSystemProvider)provider).isRegularFile(path);
2274         }
2275 
2276         try {
2277             return readAttributes(path, BasicFileAttributes.class, options).isRegularFile();
2278         } catch (IOException ioe) {
2279             return false;
2280         }
2281     }
2282 
2283     /**
2284      * Returns a file's last modified time.
2285      *
2286      * <p> The {@code options} array may be used to indicate how symbolic links
2287      * are handled for the case that the file is a symbolic link. By default,
2288      * symbolic links are followed and the file attribute of the final target
2289      * of the link is read. If the option {@link LinkOption#NOFOLLOW_LINKS
2290      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
2291      *
2292      * @param   path
2293      *          the path to the file
2294      * @param   options
2295      *          options indicating how symbolic links are handled
2296      *
2297      * @return  a {@code FileTime} representing the time the file was last
2298      *          modified, or an implementation specific default when a time
2299      *          stamp to indicate the time of last modification is not supported
2300      *          by the file system
2301      *
2302      * @throws  IOException
2303      *          if an I/O error occurs
2304      * @throws  SecurityException
2305      *          In the case of the default provider, and a security manager is
2306      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
2307      *          method denies read access to the file.
2308      *
2309      * @see BasicFileAttributes#lastModifiedTime
2310      */
2311     public static FileTime getLastModifiedTime(Path path, LinkOption... options)
2312         throws IOException
2313     {
2314         return readAttributes(path, BasicFileAttributes.class, options).lastModifiedTime();
2315     }
2316 
2317     /**
2318      * Updates a file's last modified time attribute. The file time is converted
2319      * to the epoch and precision supported by the file system. Converting from
2320      * finer to coarser granularities result in precision loss. The behavior of
2321      * this method when attempting to set the last modified time when it is not
2322      * supported by the file system or is outside the range supported by the
2323      * underlying file store is not defined. It may or not fail by throwing an
2324      * {@code IOException}.
2325      *
2326      * <p> <b>Usage Example:</b>
2327      * Suppose we want to set the last modified time to the current time:
2328      * <pre>
2329      *    Path path = ...
2330      *    FileTime now = FileTime.fromMillis(System.currentTimeMillis());
2331      *    Files.setLastModifiedTime(path, now);
2332      * </pre>
2333      *
2334      * @param   path
2335      *          the path to the file
2336      * @param   time
2337      *          the new last modified time
2338      *
2339      * @return  the given path
2340      *
2341      * @throws  IOException
2342      *          if an I/O error occurs
2343      * @throws  SecurityException
2344      *          In the case of the default provider, and a security manager is
2345      *          installed, its {@link SecurityManager#checkWrite(String)
2346      *          checkWrite} method denies write access to the file.
2347      *
2348      * @see BasicFileAttributeView#setTimes
2349      */
2350     public static Path setLastModifiedTime(Path path, FileTime time)
2351         throws IOException
2352     {
2353         getFileAttributeView(path, BasicFileAttributeView.class)
2354             .setTimes(Objects.requireNonNull(time), null, null);
2355         return path;
2356     }
2357 
2358     /**
2359      * Returns the size of a file (in bytes). The size may differ from the
2360      * actual size on the file system due to compression, support for sparse
2361      * files, or other reasons. The size of files that are not {@link
2362      * #isRegularFile regular} files is implementation specific and
2363      * therefore unspecified.
2364      *
2365      * @param   path
2366      *          the path to the file
2367      *
2368      * @return  the file size, in bytes
2369      *
2370      * @throws  IOException
2371      *          if an I/O error occurs
2372      * @throws  SecurityException
2373      *          In the case of the default provider, and a security manager is
2374      *          installed, its {@link SecurityManager#checkRead(String) checkRead}
2375      *          method denies read access to the file.
2376      *
2377      * @see BasicFileAttributes#size
2378      */
2379     public static long size(Path path) throws IOException {
2380         return readAttributes(path, BasicFileAttributes.class).size();
2381     }
2382 
2383     // -- Accessibility --
2384 
2385     /**
2386      * Returns {@code false} if NOFOLLOW_LINKS is present.
2387      */
2388     private static boolean followLinks(LinkOption... options) {
2389         boolean followLinks = true;
2390         for (LinkOption opt: options) {
2391             if (opt == LinkOption.NOFOLLOW_LINKS) {
2392                 followLinks = false;
2393                 continue;
2394             }
2395             if (opt == null)
2396                 throw new NullPointerException();
2397             throw new AssertionError("Should not get here");
2398         }
2399         return followLinks;
2400     }
2401 
2402     /**
2403      * Tests whether a file exists.
2404      *
2405      * <p> The {@code options} parameter may be used to indicate how symbolic links
2406      * are handled for the case that the file is a symbolic link. By default,
2407      * symbolic links are followed. If the option {@link LinkOption#NOFOLLOW_LINKS
2408      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
2409      *
2410      * <p> Note that the result of this method is immediately outdated. If this
2411      * method indicates the file exists then there is no guarantee that a
2412      * subsequent access will succeed. Care should be taken when using this
2413      * method in security sensitive applications.
2414      *
2415      * @param   path
2416      *          the path to the file to test
2417      * @param   options
2418      *          options indicating how symbolic links are handled
2419      * .
2420      * @return  {@code true} if the file exists; {@code false} if the file does
2421      *          not exist or its existence cannot be determined.
2422      *
2423      * @throws  SecurityException
2424      *          In the case of the default provider, the {@link
2425      *          SecurityManager#checkRead(String)} is invoked to check
2426      *          read access to the file.
2427      *
2428      * @see #notExists
2429      */
2430     public static boolean exists(Path path, LinkOption... options) {
2431         if (options.length == 0) {
2432             FileSystemProvider provider = provider(path);
2433             if (provider instanceof AbstractFileSystemProvider)
2434                 return ((AbstractFileSystemProvider)provider).exists(path);
2435         }
2436 
2437         try {
2438             if (followLinks(options)) {
2439                 provider(path).checkAccess(path);
2440             } else {
2441                 // attempt to read attributes without following links
2442                 readAttributes(path, BasicFileAttributes.class,
2443                                LinkOption.NOFOLLOW_LINKS);
2444             }
2445             // file exists
2446             return true;
2447         } catch (IOException x) {
2448             // does not exist or unable to determine if file exists
2449             return false;
2450         }
2451 
2452     }
2453 
2454     /**
2455      * Tests whether the file located by this path does not exist. This method
2456      * is intended for cases where it is required to take action when it can be
2457      * confirmed that a file does not exist.
2458      *
2459      * <p> The {@code options} parameter may be used to indicate how symbolic links
2460      * are handled for the case that the file is a symbolic link. By default,
2461      * symbolic links are followed. If the option {@link LinkOption#NOFOLLOW_LINKS
2462      * NOFOLLOW_LINKS} is present then symbolic links are not followed.
2463      *
2464      * <p> Note that this method is not the complement of the {@link #exists
2465      * exists} method. Where it is not possible to determine if a file exists
2466      * or not then both methods return {@code false}. As with the {@code exists}
2467      * method, the result of this method is immediately outdated. If this
2468      * method indicates the file does exist then there is no guarantee that a
2469      * subsequent attempt to create the file will succeed. Care should be taken
2470      * when using this method in security sensitive applications.
2471      *
2472      * @param   path
2473      *          the path to the file to test
2474      * @param   options
2475      *          options indicating how symbolic links are handled
2476      *
2477      * @return  {@code true} if the file does not exist; {@code false} if the
2478      *          file exists or its existence cannot be determined
2479      *
2480      * @throws  SecurityException
2481      *          In the case of the default provider, the {@link
2482      *          SecurityManager#checkRead(String)} is invoked to check
2483      *          read access to the file.
2484      */
2485     public static boolean notExists(Path path, LinkOption... options) {
2486         try {
2487             if (followLinks(options)) {
2488                 provider(path).checkAccess(path);
2489             } else {
2490                 // attempt to read attributes without following links
2491                 readAttributes(path, BasicFileAttributes.class,
2492                                LinkOption.NOFOLLOW_LINKS);
2493             }
2494             // file exists
2495             return false;
2496         } catch (NoSuchFileException x) {
2497             // file confirmed not to exist
2498             return true;
2499         } catch (IOException x) {
2500             return false;
2501         }
2502     }
2503 
2504     /**
2505      * Used by isReadable, isWritable, isExecutable to test access to a file.
2506      */
2507     private static boolean isAccessible(Path path, AccessMode... modes) {
2508         try {
2509             provider(path).checkAccess(path, modes);
2510             return true;
2511         } catch (IOException x) {
2512             return false;
2513         }
2514     }
2515 
2516     /**
2517      * Tests whether a file is readable. This method checks that a file exists
2518      * and that this Java virtual machine has appropriate privileges that would
2519      * allow it open the file for reading. Depending on the implementation, this
2520      * method may require to read file permissions, access control lists, or
2521      * other file attributes in order to check the effective access to the file.
2522      * Consequently, this method may not be atomic with respect to other file
2523      * system operations.
2524      *
2525      * <p> Note that the result of this method is immediately outdated, there is
2526      * no guarantee that a subsequent attempt to open the file for reading will
2527      * succeed (or even that it will access the same file). Care should be taken
2528      * when using this method in security sensitive applications.
2529      *
2530      * @param   path
2531      *          the path to the file to check
2532      *
2533      * @return  {@code true} if the file exists and is readable; {@code false}
2534      *          if the file does not exist, read access would be denied because
2535      *          the Java virtual machine has insufficient privileges, or access
2536      *          cannot be determined
2537      *
2538      * @throws  SecurityException
2539      *          In the case of the default provider, and a security manager is
2540      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
2541      *          is invoked to check read access to the file.
2542      */
2543     public static boolean isReadable(Path path) {
2544         return isAccessible(path, AccessMode.READ);
2545     }
2546 
2547     /**
2548      * Tests whether a file is writable. This method checks that a file exists
2549      * and that this Java virtual machine has appropriate privileges that would
2550      * allow it open the file for writing. Depending on the implementation, this
2551      * method may require to read file permissions, access control lists, or
2552      * other file attributes in order to check the effective access to the file.
2553      * Consequently, this method may not be atomic with respect to other file
2554      * system operations.
2555      *
2556      * <p> Note that result of this method is immediately outdated, there is no
2557      * guarantee that a subsequent attempt to open the file for writing will
2558      * succeed (or even that it will access the same file). Care should be taken
2559      * when using this method in security sensitive applications.
2560      *
2561      * @param   path
2562      *          the path to the file to check
2563      *
2564      * @return  {@code true} if the file exists and is writable; {@code false}
2565      *          if the file does not exist, write access would be denied because
2566      *          the Java virtual machine has insufficient privileges, or access
2567      *          cannot be determined
2568      *
2569      * @throws  SecurityException
2570      *          In the case of the default provider, and a security manager is
2571      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
2572      *          is invoked to check write access to the file.
2573      */
2574     public static boolean isWritable(Path path) {
2575         return isAccessible(path, AccessMode.WRITE);
2576     }
2577 
2578     /**
2579      * Tests whether a file is executable. This method checks that a file exists
2580      * and that this Java virtual machine has appropriate privileges to {@link
2581      * Runtime#exec execute} the file. The semantics may differ when checking
2582      * access to a directory. For example, on UNIX systems, checking for
2583      * execute access checks that the Java virtual machine has permission to
2584      * search the directory in order to access file or subdirectories.
2585      *
2586      * <p> Depending on the implementation, this method may require to read file
2587      * permissions, access control lists, or other file attributes in order to
2588      * check the effective access to the file. Consequently, this method may not
2589      * be atomic with respect to other file system operations.
2590      *
2591      * <p> Note that the result of this method is immediately outdated, there is
2592      * no guarantee that a subsequent attempt to execute the file will succeed
2593      * (or even that it will access the same file). Care should be taken when
2594      * using this method in security sensitive applications.
2595      *
2596      * @param   path
2597      *          the path to the file to check
2598      *
2599      * @return  {@code true} if the file exists and is executable; {@code false}
2600      *          if the file does not exist, execute access would be denied because
2601      *          the Java virtual machine has insufficient privileges, or access
2602      *          cannot be determined
2603      *
2604      * @throws  SecurityException
2605      *          In the case of the default provider, and a security manager is
2606      *          installed, the {@link SecurityManager#checkExec(String)
2607      *          checkExec} is invoked to check execute access to the file.
2608      */
2609     public static boolean isExecutable(Path path) {
2610         return isAccessible(path, AccessMode.EXECUTE);
2611     }
2612 
2613     // -- Recursive operations --
2614 
2615     /**
2616      * Walks a file tree.
2617      *
2618      * <p> This method walks a file tree rooted at a given starting file. The
2619      * file tree traversal is <em>depth-first</em> with the given {@link
2620      * FileVisitor} invoked for each file encountered. File tree traversal
2621      * completes when all accessible files in the tree have been visited, or a
2622      * visit method returns a result of {@link FileVisitResult#TERMINATE
2623      * TERMINATE}. Where a visit method terminates due an {@code IOException},
2624      * an uncaught error, or runtime exception, then the traversal is terminated
2625      * and the error or exception is propagated to the caller of this method.
2626      *
2627      * <p> For each file encountered this method attempts to read its {@link
2628      * java.nio.file.attribute.BasicFileAttributes}. If the file is not a
2629      * directory then the {@link FileVisitor#visitFile visitFile} method is
2630      * invoked with the file attributes. If the file attributes cannot be read,
2631      * due to an I/O exception, then the {@link FileVisitor#visitFileFailed
2632      * visitFileFailed} method is invoked with the I/O exception.
2633      *
2634      * <p> Where the file is a directory, and the directory could not be opened,
2635      * then the {@code visitFileFailed} method is invoked with the I/O exception,
2636      * after which, the file tree walk continues, by default, at the next
2637      * <em>sibling</em> of the directory.
2638      *
2639      * <p> Where the directory is opened successfully, then the entries in the
2640      * directory, and their <em>descendants</em> are visited. When all entries
2641      * have been visited, or an I/O error occurs during iteration of the
2642      * directory, then the directory is closed and the visitor's {@link
2643      * FileVisitor#postVisitDirectory postVisitDirectory} method is invoked.
2644      * The file tree walk then continues, by default, at the next <em>sibling</em>
2645      * of the directory.
2646      *
2647      * <p> By default, symbolic links are not automatically followed by this
2648      * method. If the {@code options} parameter contains the {@link
2649      * FileVisitOption#FOLLOW_LINKS FOLLOW_LINKS} option then symbolic links are
2650      * followed. When following links, and the attributes of the target cannot
2651      * be read, then this method attempts to get the {@code BasicFileAttributes}
2652      * of the link. If they can be read then the {@code visitFile} method is
2653      * invoked with the attributes of the link (otherwise the {@code visitFileFailed}
2654      * method is invoked as specified above).
2655      *
2656      * <p> If the {@code options} parameter contains the {@link
2657      * FileVisitOption#FOLLOW_LINKS FOLLOW_LINKS} option then this method keeps
2658      * track of directories visited so that cycles can be detected. A cycle
2659      * arises when there is an entry in a directory that is an ancestor of the
2660      * directory. Cycle detection is done by recording the {@link
2661      * java.nio.file.attribute.BasicFileAttributes#fileKey file-key} of directories,
2662      * or if file keys are not available, by invoking the {@link #isSameFile
2663      * isSameFile} method to test if a directory is the same file as an
2664      * ancestor. When a cycle is detected it is treated as an I/O error, and the
2665      * {@link FileVisitor#visitFileFailed visitFileFailed} method is invoked with
2666      * an instance of {@link FileSystemLoopException}.
2667      *
2668      * <p> The {@code maxDepth} parameter is the maximum number of levels of
2669      * directories to visit. A value of {@code 0} means that only the starting
2670      * file is visited, unless denied by the security manager. A value of
2671      * {@link Integer#MAX_VALUE MAX_VALUE} may be used to indicate that all
2672      * levels should be visited. The {@code visitFile} method is invoked for all
2673      * files, including directories, encountered at {@code maxDepth}, unless the
2674      * basic file attributes cannot be read, in which case the {@code
2675      * visitFileFailed} method is invoked.
2676      *
2677      * <p> If a visitor returns a result of {@code null} then {@code
2678      * NullPointerException} is thrown.
2679      *
2680      * <p> When a security manager is installed and it denies access to a file
2681      * (or directory), then it is ignored and the visitor is not invoked for
2682      * that file (or directory).
2683      *
2684      * @param   start
2685      *          the starting file
2686      * @param   options
2687      *          options to configure the traversal
2688      * @param   maxDepth
2689      *          the maximum number of directory levels to visit
2690      * @param   visitor
2691      *          the file visitor to invoke for each file
2692      *
2693      * @return  the starting file
2694      *
2695      * @throws  IllegalArgumentException
2696      *          if the {@code maxDepth} parameter is negative
2697      * @throws  SecurityException
2698      *          If the security manager denies access to the starting file.
2699      *          In the case of the default provider, the {@link
2700      *          SecurityManager#checkRead(String) checkRead} method is invoked
2701      *          to check read access to the directory.
2702      * @throws  IOException
2703      *          if an I/O error is thrown by a visitor method
2704      */
2705     public static Path walkFileTree(Path start,
2706                                     Set<FileVisitOption> options,
2707                                     int maxDepth,
2708                                     FileVisitor<? super Path> visitor)
2709         throws IOException
2710     {
2711         /**
2712          * Create a FileTreeWalker to walk the file tree, invoking the visitor
2713          * for each event.
2714          */
2715         try (FileTreeWalker walker = new FileTreeWalker(options, maxDepth)) {
2716             FileTreeWalker.Event ev = walker.walk(start);
2717             do {
2718                 FileVisitResult result;
2719                 switch (ev.type()) {
2720                     case ENTRY :
2721                         IOException ioe = ev.ioeException();
2722                         if (ioe == null) {
2723                             assert ev.attributes() != null;
2724                             result = visitor.visitFile(ev.file(), ev.attributes());
2725                         } else {
2726                             result = visitor.visitFileFailed(ev.file(), ioe);
2727                         }
2728                         break;
2729 
2730                     case START_DIRECTORY :
2731                         result = visitor.preVisitDirectory(ev.file(), ev.attributes());
2732 
2733                         // if SKIP_SIBLINGS and SKIP_SUBTREE is returned then
2734                         // there shouldn't be any more events for the current
2735                         // directory.
2736                         if (result == FileVisitResult.SKIP_SUBTREE ||
2737                             result == FileVisitResult.SKIP_SIBLINGS)
2738                             walker.pop();
2739                         break;
2740 
2741                     case END_DIRECTORY :
2742                         result = visitor.postVisitDirectory(ev.file(), ev.ioeException());
2743 
2744                         // SKIP_SIBLINGS is a no-op for postVisitDirectory
2745                         if (result == FileVisitResult.SKIP_SIBLINGS)
2746                             result = FileVisitResult.CONTINUE;
2747                         break;
2748 
2749                     default :
2750                         throw new AssertionError("Should not get here");
2751                 }
2752 
2753                 if (Objects.requireNonNull(result) != FileVisitResult.CONTINUE) {
2754                     if (result == FileVisitResult.TERMINATE) {
2755                         break;
2756                     } else if (result == FileVisitResult.SKIP_SIBLINGS) {
2757                         walker.skipRemainingSiblings();
2758                     }
2759                 }
2760                 ev = walker.next();
2761             } while (ev != null);
2762         }
2763 
2764         return start;
2765     }
2766 
2767     /**
2768      * Walks a file tree.
2769      *
2770      * <p> This method works as if invoking it were equivalent to evaluating the
2771      * expression:
2772      * <blockquote><pre>
2773      * walkFileTree(start, EnumSet.noneOf(FileVisitOption.class), Integer.MAX_VALUE, visitor)
2774      * </pre></blockquote>
2775      * In other words, it does not follow symbolic links, and visits all levels
2776      * of the file tree.
2777      *
2778      * @param   start
2779      *          the starting file
2780      * @param   visitor
2781      *          the file visitor to invoke for each file
2782      *
2783      * @return  the starting file
2784      *
2785      * @throws  SecurityException
2786      *          If the security manager denies access to the starting file.
2787      *          In the case of the default provider, the {@link
2788      *          SecurityManager#checkRead(String) checkRead} method is invoked
2789      *          to check read access to the directory.
2790      * @throws  IOException
2791      *          if an I/O error is thrown by a visitor method
2792      */
2793     public static Path walkFileTree(Path start, FileVisitor<? super Path> visitor)
2794         throws IOException
2795     {
2796         return walkFileTree(start,
2797                             EnumSet.noneOf(FileVisitOption.class),
2798                             Integer.MAX_VALUE,
2799                             visitor);
2800     }
2801 
2802 
2803     // -- Utility methods for simple usages --
2804 
2805     // buffer size used for reading and writing
2806     private static final int BUFFER_SIZE = 8192;
2807 
2808     /**
2809      * Opens a file for reading, returning a {@code BufferedReader} that may be
2810      * used to read text from the file in an efficient manner. Bytes from the
2811      * file are decoded into characters using the specified charset. Reading
2812      * commences at the beginning of the file.
2813      *
2814      * <p> The {@code Reader} methods that read from the file throw {@code
2815      * IOException} if a malformed or unmappable byte sequence is read.
2816      *
2817      * @param   path
2818      *          the path to the file
2819      * @param   cs
2820      *          the charset to use for decoding
2821      *
2822      * @return  a new buffered reader, with default buffer size, to read text
2823      *          from the file
2824      *
2825      * @throws  IOException
2826      *          if an I/O error occurs opening the file
2827      * @throws  SecurityException
2828      *          In the case of the default provider, and a security manager is
2829      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
2830      *          method is invoked to check read access to the file.
2831      *
2832      * @see #readAllLines
2833      */
2834     public static BufferedReader newBufferedReader(Path path, Charset cs)
2835         throws IOException
2836     {
2837         CharsetDecoder decoder = cs.newDecoder();
2838         Reader reader = new InputStreamReader(newInputStream(path), decoder);
2839         return new BufferedReader(reader);
2840     }
2841 
2842     /**
2843      * Opens a file for reading, returning a {@code BufferedReader} to read text
2844      * from the file in an efficient manner. Bytes from the file are decoded into
2845      * characters using the {@link StandardCharsets#UTF_8 UTF-8} {@link Charset
2846      * charset}.
2847      *
2848      * <p> This method works as if invoking it were equivalent to evaluating the
2849      * expression:
2850      * <pre>{@code
2851      * Files.newBufferedReader(path, StandardCharsets.UTF_8)
2852      * }</pre>
2853      *
2854      * @param   path
2855      *          the path to the file
2856      *
2857      * @return  a new buffered reader, with default buffer size, to read text
2858      *          from the file
2859      *
2860      * @throws  IOException
2861      *          if an I/O error occurs opening the file
2862      * @throws  SecurityException
2863      *          In the case of the default provider, and a security manager is
2864      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
2865      *          method is invoked to check read access to the file.
2866      *
2867      * @since 1.8
2868      */
2869     public static BufferedReader newBufferedReader(Path path) throws IOException {
2870         return newBufferedReader(path, StandardCharsets.UTF_8);
2871     }
2872 
2873     /**
2874      * Opens or creates a file for writing, returning a {@code BufferedWriter}
2875      * that may be used to write text to the file in an efficient manner.
2876      * The {@code options} parameter specifies how the file is created or
2877      * opened. If no options are present then this method works as if the {@link
2878      * StandardOpenOption#CREATE CREATE}, {@link
2879      * StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING}, and {@link
2880      * StandardOpenOption#WRITE WRITE} options are present. In other words, it
2881      * opens the file for writing, creating the file if it doesn't exist, or
2882      * initially truncating an existing {@link #isRegularFile regular-file} to
2883      * a size of {@code 0} if it exists.
2884      *
2885      * <p> The {@code Writer} methods to write text throw {@code IOException}
2886      * if the text cannot be encoded using the specified charset.
2887      *
2888      * @param   path
2889      *          the path to the file
2890      * @param   cs
2891      *          the charset to use for encoding
2892      * @param   options
2893      *          options specifying how the file is opened
2894      *
2895      * @return  a new buffered writer, with default buffer size, to write text
2896      *          to the file
2897      *
2898      * @throws  IllegalArgumentException
2899      *          if {@code options} contains an invalid combination of options
2900      * @throws  IOException
2901      *          if an I/O error occurs opening or creating the file
2902      * @throws  UnsupportedOperationException
2903      *          if an unsupported option is specified
2904      * @throws  SecurityException
2905      *          In the case of the default provider, and a security manager is
2906      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
2907      *          method is invoked to check write access to the file. The {@link
2908      *          SecurityManager#checkDelete(String) checkDelete} method is
2909      *          invoked to check delete access if the file is opened with the
2910      *          {@code DELETE_ON_CLOSE} option.
2911      *
2912      * @see #write(Path,Iterable,Charset,OpenOption[])
2913      */
2914     public static BufferedWriter newBufferedWriter(Path path, Charset cs,
2915                                                    OpenOption... options)
2916         throws IOException
2917     {
2918         CharsetEncoder encoder = cs.newEncoder();
2919         Writer writer = new OutputStreamWriter(newOutputStream(path, options), encoder);
2920         return new BufferedWriter(writer);
2921     }
2922 
2923     /**
2924      * Opens or creates a file for writing, returning a {@code BufferedWriter}
2925      * to write text to the file in an efficient manner. The text is encoded
2926      * into bytes for writing using the {@link StandardCharsets#UTF_8 UTF-8}
2927      * {@link Charset charset}.
2928      *
2929      * <p> This method works as if invoking it were equivalent to evaluating the
2930      * expression:
2931      * <pre>{@code
2932      * Files.newBufferedWriter(path, StandardCharsets.UTF_8, options)
2933      * }</pre>
2934      *
2935      * @param   path
2936      *          the path to the file
2937      * @param   options
2938      *          options specifying how the file is opened
2939      *
2940      * @return  a new buffered writer, with default buffer size, to write text
2941      *          to the file
2942      *
2943      * @throws  IllegalArgumentException
2944      *          if {@code options} contains an invalid combination of options
2945      * @throws  IOException
2946      *          if an I/O error occurs opening or creating the file
2947      * @throws  UnsupportedOperationException
2948      *          if an unsupported option is specified
2949      * @throws  SecurityException
2950      *          In the case of the default provider, and a security manager is
2951      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
2952      *          method is invoked to check write access to the file. The {@link
2953      *          SecurityManager#checkDelete(String) checkDelete} method is
2954      *          invoked to check delete access if the file is opened with the
2955      *          {@code DELETE_ON_CLOSE} option.
2956      *
2957      * @since 1.8
2958      */
2959     public static BufferedWriter newBufferedWriter(Path path, OpenOption... options)
2960         throws IOException
2961     {
2962         return newBufferedWriter(path, StandardCharsets.UTF_8, options);
2963     }
2964 
2965     /**
2966      * Copies all bytes from an input stream to a file. On return, the input
2967      * stream will be at end of stream.
2968      *
2969      * <p> By default, the copy fails if the target file already exists or is a
2970      * symbolic link. If the {@link StandardCopyOption#REPLACE_EXISTING
2971      * REPLACE_EXISTING} option is specified, and the target file already exists,
2972      * then it is replaced if it is not a non-empty directory. If the target
2973      * file exists and is a symbolic link, then the symbolic link is replaced.
2974      * In this release, the {@code REPLACE_EXISTING} option is the only option
2975      * required to be supported by this method. Additional options may be
2976      * supported in future releases.
2977      *
2978      * <p>  If an I/O error occurs reading from the input stream or writing to
2979      * the file, then it may do so after the target file has been created and
2980      * after some bytes have been read or written. Consequently the input
2981      * stream may not be at end of stream and may be in an inconsistent state.
2982      * It is strongly recommended that the input stream be promptly closed if an
2983      * I/O error occurs.
2984      *
2985      * <p> This method may block indefinitely reading from the input stream (or
2986      * writing to the file). The behavior for the case that the input stream is
2987      * <i>asynchronously closed</i> or the thread interrupted during the copy is
2988      * highly input stream and file system provider specific and therefore not
2989      * specified.
2990      *
2991      * <p> <b>Usage example</b>: Suppose we want to capture a web page and save
2992      * it to a file:
2993      * <pre>
2994      *     Path path = ...
2995      *     URI u = URI.create("http://java.sun.com/");
2996      *     try (InputStream in = u.toURL().openStream()) {
2997      *         Files.copy(in, path);
2998      *     }
2999      * </pre>
3000      *
3001      * @param   in
3002      *          the input stream to read from
3003      * @param   target
3004      *          the path to the file
3005      * @param   options
3006      *          options specifying how the copy should be done
3007      *
3008      * @return  the number of bytes read or written
3009      *
3010      * @throws  IOException
3011      *          if an I/O error occurs when reading or writing
3012      * @throws  FileAlreadyExistsException
3013      *          if the target file exists but cannot be replaced because the
3014      *          {@code REPLACE_EXISTING} option is not specified <i>(optional
3015      *          specific exception)</i>
3016      * @throws  DirectoryNotEmptyException
3017      *          the {@code REPLACE_EXISTING} option is specified but the file
3018      *          cannot be replaced because it is a non-empty directory
3019      *          <i>(optional specific exception)</i>     *
3020      * @throws  UnsupportedOperationException
3021      *          if {@code options} contains a copy option that is not supported
3022      * @throws  SecurityException
3023      *          In the case of the default provider, and a security manager is
3024      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
3025      *          method is invoked to check write access to the file. Where the
3026      *          {@code REPLACE_EXISTING} option is specified, the security
3027      *          manager's {@link SecurityManager#checkDelete(String) checkDelete}
3028      *          method is invoked to check that an existing file can be deleted.
3029      */
3030     public static long copy(InputStream in, Path target, CopyOption... options)
3031         throws IOException
3032     {
3033         // ensure not null before opening file
3034         Objects.requireNonNull(in);
3035 
3036         // check for REPLACE_EXISTING
3037         boolean replaceExisting = false;
3038         for (CopyOption opt: options) {
3039             if (opt == StandardCopyOption.REPLACE_EXISTING) {
3040                 replaceExisting = true;
3041             } else {
3042                 if (opt == null) {
3043                     throw new NullPointerException("options contains 'null'");
3044                 }  else {
3045                     throw new UnsupportedOperationException(opt + " not supported");
3046                 }
3047             }
3048         }
3049 
3050         // attempt to delete an existing file
3051         SecurityException se = null;
3052         if (replaceExisting) {
3053             try {
3054                 deleteIfExists(target);
3055             } catch (SecurityException x) {
3056                 se = x;
3057             }
3058         }
3059 
3060         // attempt to create target file. If it fails with
3061         // FileAlreadyExistsException then it may be because the security
3062         // manager prevented us from deleting the file, in which case we just
3063         // throw the SecurityException.
3064         OutputStream ostream;
3065         try {
3066             ostream = newOutputStream(target, StandardOpenOption.CREATE_NEW,
3067                                               StandardOpenOption.WRITE);
3068         } catch (FileAlreadyExistsException x) {
3069             if (se != null)
3070                 throw se;
3071             // someone else won the race and created the file
3072             throw x;
3073         }
3074 
3075         // do the copy
3076         try (OutputStream out = ostream) {
3077             return in.transferTo(out);
3078         }
3079     }
3080 
3081     /**
3082      * Copies all bytes from a file to an output stream.
3083      *
3084      * <p> If an I/O error occurs reading from the file or writing to the output
3085      * stream, then it may do so after some bytes have been read or written.
3086      * Consequently the output stream may be in an inconsistent state. It is
3087      * strongly recommended that the output stream be promptly closed if an I/O
3088      * error occurs.
3089      *
3090      * <p> This method may block indefinitely writing to the output stream (or
3091      * reading from the file). The behavior for the case that the output stream
3092      * is <i>asynchronously closed</i> or the thread interrupted during the copy
3093      * is highly output stream and file system provider specific and therefore
3094      * not specified.
3095      *
3096      * <p> Note that if the given output stream is {@link java.io.Flushable}
3097      * then its {@link java.io.Flushable#flush flush} method may need to invoked
3098      * after this method completes so as to flush any buffered output.
3099      *
3100      * @param   source
3101      *          the  path to the file
3102      * @param   out
3103      *          the output stream to write to
3104      *
3105      * @return  the number of bytes read or written
3106      *
3107      * @throws  IOException
3108      *          if an I/O error occurs when reading or writing
3109      * @throws  SecurityException
3110      *          In the case of the default provider, and a security manager is
3111      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
3112      *          method is invoked to check read access to the file.
3113      */
3114     public static long copy(Path source, OutputStream out) throws IOException {
3115         // ensure not null before opening file
3116         Objects.requireNonNull(out);
3117 
3118         try (InputStream in = newInputStream(source)) {
3119             return in.transferTo(out);
3120         }
3121     }
3122 
3123     /**
3124      * The maximum size of array to allocate.
3125      * Some VMs reserve some header words in an array.
3126      * Attempts to allocate larger arrays may result in
3127      * OutOfMemoryError: Requested array size exceeds VM limit
3128      */
3129     private static final int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8;
3130 
3131     private static final jdk.internal.misc.JavaLangAccess JLA =
3132             jdk.internal.misc.SharedSecrets.getJavaLangAccess();
3133 
3134     /**
3135      * Reads all the bytes from an input stream. Uses {@code initialSize} as a hint
3136      * about how many bytes the stream will have.
3137      *
3138      * @param   source
3139      *          the input stream to read from
3140      * @param   initialSize
3141      *          the initial size of the byte array to allocate
3142      *
3143      * @return  a byte array containing the bytes read from the file
3144      *
3145      * @throws  IOException
3146      *          if an I/O error occurs reading from the stream
3147      * @throws  OutOfMemoryError
3148      *          if an array of the required size cannot be allocated
3149      */
3150     private static byte[] read(InputStream source, int initialSize) throws IOException {
3151         int capacity = initialSize;
3152         byte[] buf = new byte[capacity];
3153         int nread = 0;
3154         int n;
3155         for (;;) {
3156             // read to EOF which may read more or less than initialSize (eg: file
3157             // is truncated while we are reading)
3158             while ((n = source.read(buf, nread, capacity - nread)) > 0)
3159                 nread += n;
3160 
3161             // if last call to source.read() returned -1, we are done
3162             // otherwise, try to read one more byte; if that failed we're done too
3163             if (n < 0 || (n = source.read()) < 0)
3164                 break;
3165 
3166             // one more byte was read; need to allocate a larger buffer
3167             if (capacity <= MAX_BUFFER_SIZE - capacity) {
3168                 capacity = Math.max(capacity << 1, BUFFER_SIZE);
3169             } else {
3170                 if (capacity == MAX_BUFFER_SIZE)
3171                     throw new OutOfMemoryError("Required array size too large");
3172                 capacity = MAX_BUFFER_SIZE;
3173             }
3174             buf = Arrays.copyOf(buf, capacity);
3175             buf[nread++] = (byte)n;
3176         }
3177         return (capacity == nread) ? buf : Arrays.copyOf(buf, nread);
3178     }
3179 
3180     /**
3181      * Reads all the bytes from a file. The method ensures that the file is
3182      * closed when all bytes have been read or an I/O error, or other runtime
3183      * exception, is thrown.
3184      *
3185      * <p> Note that this method is intended for simple cases where it is
3186      * convenient to read all bytes into a byte array. It is not intended for
3187      * reading in large files.
3188      *
3189      * @param   path
3190      *          the path to the file
3191      *
3192      * @return  a byte array containing the bytes read from the file
3193      *
3194      * @throws  IOException
3195      *          if an I/O error occurs reading from the stream
3196      * @throws  OutOfMemoryError
3197      *          if an array of the required size cannot be allocated, for
3198      *          example the file is larger that {@code 2GB}
3199      * @throws  SecurityException
3200      *          In the case of the default provider, and a security manager is
3201      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
3202      *          method is invoked to check read access to the file.
3203      */
3204     public static byte[] readAllBytes(Path path) throws IOException {
3205         try (SeekableByteChannel sbc = Files.newByteChannel(path);
3206              InputStream in = Channels.newInputStream(sbc)) {
3207             if (sbc instanceof FileChannelImpl)
3208                 ((FileChannelImpl) sbc).setUninterruptible();
3209             long size = sbc.size();
3210             if (size > (long) MAX_BUFFER_SIZE)
3211                 throw new OutOfMemoryError("Required array size too large");
3212             return read(in, (int)size);
3213         }
3214     }
3215 
3216     /**
3217      * Reads all content from a file into a string, decoding from bytes to characters
3218      * using the {@link StandardCharsets#UTF_8 UTF-8} {@link Charset charset}.
3219      * The method ensures that the file is closed when all content have been read
3220      * or an I/O error, or other runtime exception, is thrown.
3221      *
3222      * <p> This method is equivalent to:
3223      * {@code readString(path, StandardCharsets.UTF_8) }
3224      *
3225      * @param   path the path to the file
3226      *
3227      * @return  a String containing the content read from the file
3228      *
3229      * @throws  IOException
3230      *          if an I/O error occurs reading from the file or a malformed or
3231      *          unmappable byte sequence is read
3232      * @throws  OutOfMemoryError
3233      *          if the file is extremely large, for example larger than {@code 2GB}
3234      * @throws  SecurityException
3235      *          In the case of the default provider, and a security manager is
3236      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
3237      *          method is invoked to check read access to the file.
3238      *
3239      * @since 11
3240      */
3241     public static String readString(Path path) throws IOException {
3242         return readString(path, StandardCharsets.UTF_8);
3243     }
3244 
3245     /**
3246      * Reads all characters from a file into a string, decoding from bytes to characters
3247      * using the specified {@linkplain Charset charset}.
3248      * The method ensures that the file is closed when all content have been read
3249      * or an I/O error, or other runtime exception, is thrown.
3250      *
3251      * <p> This method reads all content including the line separators in the middle
3252      * and/or at the end. The resulting string will contain line separators as they
3253      * appear in the file.
3254      *
3255      * @apiNote
3256      * This method is intended for simple cases where it is appropriate and convenient
3257      * to read the content of a file into a String. It is not intended for reading
3258      * very large files.
3259      *
3260      *
3261      *
3262      * @param   path the path to the file
3263      * @param   cs the charset to use for decoding
3264      *
3265      * @return  a String containing the content read from the file
3266      *
3267      * @throws  IOException
3268      *          if an I/O error occurs reading from the file or a malformed or
3269      *          unmappable byte sequence is read
3270      * @throws  OutOfMemoryError
3271      *          if the file is extremely large, for example larger than {@code 2GB}
3272      * @throws  SecurityException
3273      *          In the case of the default provider, and a security manager is
3274      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
3275      *          method is invoked to check read access to the file.
3276      *
3277      * @since 11
3278      */
3279     public static String readString(Path path, Charset cs) throws IOException {
3280         Objects.requireNonNull(path);
3281         Objects.requireNonNull(cs);
3282 
3283         byte[] ba = readAllBytes(path);
3284         return JLA.newStringNoRepl(ba, cs);
3285     }
3286 
3287     /**
3288      * Read all lines from a file. This method ensures that the file is
3289      * closed when all bytes have been read or an I/O error, or other runtime
3290      * exception, is thrown. Bytes from the file are decoded into characters
3291      * using the specified charset.
3292      *
3293      * <p> This method recognizes the following as line terminators:
3294      * <ul>
3295      *   <li> <code>\u000D</code> followed by <code>\u000A</code>,
3296      *     CARRIAGE RETURN followed by LINE FEED </li>
3297      *   <li> <code>\u000A</code>, LINE FEED </li>
3298      *   <li> <code>\u000D</code>, CARRIAGE RETURN </li>
3299      * </ul>
3300      * <p> Additional Unicode line terminators may be recognized in future
3301      * releases.
3302      *
3303      * <p> Note that this method is intended for simple cases where it is
3304      * convenient to read all lines in a single operation. It is not intended
3305      * for reading in large files.
3306      *
3307      * @param   path
3308      *          the path to the file
3309      * @param   cs
3310      *          the charset to use for decoding
3311      *
3312      * @return  the lines from the file as a {@code List}; whether the {@code
3313      *          List} is modifiable or not is implementation dependent and
3314      *          therefore not specified
3315      *
3316      * @throws  IOException
3317      *          if an I/O error occurs reading from the file or a malformed or
3318      *          unmappable byte sequence is read
3319      * @throws  SecurityException
3320      *          In the case of the default provider, and a security manager is
3321      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
3322      *          method is invoked to check read access to the file.
3323      *
3324      * @see #newBufferedReader
3325      */
3326     public static List<String> readAllLines(Path path, Charset cs) throws IOException {
3327         try (BufferedReader reader = newBufferedReader(path, cs)) {
3328             List<String> result = new ArrayList<>();
3329             for (;;) {
3330                 String line = reader.readLine();
3331                 if (line == null)
3332                     break;
3333                 result.add(line);
3334             }
3335             return result;
3336         }
3337     }
3338 
3339     /**
3340      * Read all lines from a file. Bytes from the file are decoded into characters
3341      * using the {@link StandardCharsets#UTF_8 UTF-8} {@link Charset charset}.
3342      *
3343      * <p> This method works as if invoking it were equivalent to evaluating the
3344      * expression:
3345      * <pre>{@code
3346      * Files.readAllLines(path, StandardCharsets.UTF_8)
3347      * }</pre>
3348      *
3349      * @param   path
3350      *          the path to the file
3351      *
3352      * @return  the lines from the file as a {@code List}; whether the {@code
3353      *          List} is modifiable or not is implementation dependent and
3354      *          therefore not specified
3355      *
3356      * @throws  IOException
3357      *          if an I/O error occurs reading from the file or a malformed or
3358      *          unmappable byte sequence is read
3359      * @throws  SecurityException
3360      *          In the case of the default provider, and a security manager is
3361      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
3362      *          method is invoked to check read access to the file.
3363      *
3364      * @since 1.8
3365      */
3366     public static List<String> readAllLines(Path path) throws IOException {
3367         return readAllLines(path, StandardCharsets.UTF_8);
3368     }
3369 
3370     /**
3371      * Writes bytes to a file. The {@code options} parameter specifies how
3372      * the file is created or opened. If no options are present then this method
3373      * works as if the {@link StandardOpenOption#CREATE CREATE}, {@link
3374      * StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING}, and {@link
3375      * StandardOpenOption#WRITE WRITE} options are present. In other words, it
3376      * opens the file for writing, creating the file if it doesn't exist, or
3377      * initially truncating an existing {@link #isRegularFile regular-file} to
3378      * a size of {@code 0}. All bytes in the byte array are written to the file.
3379      * The method ensures that the file is closed when all bytes have been
3380      * written (or an I/O error or other runtime exception is thrown). If an I/O
3381      * error occurs then it may do so after the file has been created or
3382      * truncated, or after some bytes have been written to the file.
3383      *
3384      * <p> <b>Usage example</b>: By default the method creates a new file or
3385      * overwrites an existing file. Suppose you instead want to append bytes
3386      * to an existing file:
3387      * <pre>
3388      *     Path path = ...
3389      *     byte[] bytes = ...
3390      *     Files.write(path, bytes, StandardOpenOption.APPEND);
3391      * </pre>
3392      *
3393      * @param   path
3394      *          the path to the file
3395      * @param   bytes
3396      *          the byte array with the bytes to write
3397      * @param   options
3398      *          options specifying how the file is opened
3399      *
3400      * @return  the path
3401      *
3402      * @throws  IllegalArgumentException
3403      *          if {@code options} contains an invalid combination of options
3404      * @throws  IOException
3405      *          if an I/O error occurs writing to or creating the file
3406      * @throws  UnsupportedOperationException
3407      *          if an unsupported option is specified
3408      * @throws  SecurityException
3409      *          In the case of the default provider, and a security manager is
3410      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
3411      *          method is invoked to check write access to the file. The {@link
3412      *          SecurityManager#checkDelete(String) checkDelete} method is
3413      *          invoked to check delete access if the file is opened with the
3414      *          {@code DELETE_ON_CLOSE} option.
3415      */
3416     public static Path write(Path path, byte[] bytes, OpenOption... options)
3417         throws IOException
3418     {
3419         // ensure bytes is not null before opening file
3420         Objects.requireNonNull(bytes);
3421 
3422         try (OutputStream out = Files.newOutputStream(path, options)) {
3423             int len = bytes.length;
3424             int rem = len;
3425             while (rem > 0) {
3426                 int n = Math.min(rem, BUFFER_SIZE);
3427                 out.write(bytes, (len-rem), n);
3428                 rem -= n;
3429             }
3430         }
3431         return path;
3432     }
3433 
3434     /**
3435      * Write lines of text to a file. Each line is a char sequence and is
3436      * written to the file in sequence with each line terminated by the
3437      * platform's line separator, as defined by the system property {@code
3438      * line.separator}. Characters are encoded into bytes using the specified
3439      * charset.
3440      *
3441      * <p> The {@code options} parameter specifies how the file is created
3442      * or opened. If no options are present then this method works as if the
3443      * {@link StandardOpenOption#CREATE CREATE}, {@link
3444      * StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING}, and {@link
3445      * StandardOpenOption#WRITE WRITE} options are present. In other words, it
3446      * opens the file for writing, creating the file if it doesn't exist, or
3447      * initially truncating an existing {@link #isRegularFile regular-file} to
3448      * a size of {@code 0}. The method ensures that the file is closed when all
3449      * lines have been written (or an I/O error or other runtime exception is
3450      * thrown). If an I/O error occurs then it may do so after the file has
3451      * been created or truncated, or after some bytes have been written to the
3452      * file.
3453      *
3454      * @param   path
3455      *          the path to the file
3456      * @param   lines
3457      *          an object to iterate over the char sequences
3458      * @param   cs
3459      *          the charset to use for encoding
3460      * @param   options
3461      *          options specifying how the file is opened
3462      *
3463      * @return  the path
3464      *
3465      * @throws  IllegalArgumentException
3466      *          if {@code options} contains an invalid combination of options
3467      * @throws  IOException
3468      *          if an I/O error occurs writing to or creating the file, or the
3469      *          text cannot be encoded using the specified charset
3470      * @throws  UnsupportedOperationException
3471      *          if an unsupported option is specified
3472      * @throws  SecurityException
3473      *          In the case of the default provider, and a security manager is
3474      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
3475      *          method is invoked to check write access to the file. The {@link
3476      *          SecurityManager#checkDelete(String) checkDelete} method is
3477      *          invoked to check delete access if the file is opened with the
3478      *          {@code DELETE_ON_CLOSE} option.
3479      */
3480     public static Path write(Path path, Iterable<? extends CharSequence> lines,
3481                              Charset cs, OpenOption... options)
3482         throws IOException
3483     {
3484         // ensure lines is not null before opening file
3485         Objects.requireNonNull(lines);
3486         CharsetEncoder encoder = cs.newEncoder();
3487         OutputStream out = newOutputStream(path, options);
3488         try (BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out, encoder))) {
3489             for (CharSequence line: lines) {
3490                 writer.append(line);
3491                 writer.newLine();
3492             }
3493         }
3494         return path;
3495     }
3496 
3497     /**
3498      * Write lines of text to a file. Characters are encoded into bytes using
3499      * the {@link StandardCharsets#UTF_8 UTF-8} {@link Charset charset}.
3500      *
3501      * <p> This method works as if invoking it were equivalent to evaluating the
3502      * expression:
3503      * <pre>{@code
3504      * Files.write(path, lines, StandardCharsets.UTF_8, options);
3505      * }</pre>
3506      *
3507      * @param   path
3508      *          the path to the file
3509      * @param   lines
3510      *          an object to iterate over the char sequences
3511      * @param   options
3512      *          options specifying how the file is opened
3513      *
3514      * @return  the path
3515      *
3516      * @throws  IllegalArgumentException
3517      *          if {@code options} contains an invalid combination of options
3518      * @throws  IOException
3519      *          if an I/O error occurs writing to or creating the file, or the
3520      *          text cannot be encoded as {@code UTF-8}
3521      * @throws  UnsupportedOperationException
3522      *          if an unsupported option is specified
3523      * @throws  SecurityException
3524      *          In the case of the default provider, and a security manager is
3525      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
3526      *          method is invoked to check write access to the file. The {@link
3527      *          SecurityManager#checkDelete(String) checkDelete} method is
3528      *          invoked to check delete access if the file is opened with the
3529      *          {@code DELETE_ON_CLOSE} option.
3530      *
3531      * @since 1.8
3532      */
3533     public static Path write(Path path,
3534                              Iterable<? extends CharSequence> lines,
3535                              OpenOption... options)
3536         throws IOException
3537     {
3538         return write(path, lines, StandardCharsets.UTF_8, options);
3539     }
3540 
3541     /**
3542      * Write a {@linkplain java.lang.CharSequence CharSequence} to a file.
3543      * Characters are encoded into bytes using the
3544      * {@link StandardCharsets#UTF_8 UTF-8} {@link Charset charset}.
3545      *
3546      * <p> This method is equivalent to:
3547      * {@code writeString(path, test, StandardCharsets.UTF_8, options) }
3548      *
3549      * @param   path
3550      *          the path to the file
3551      * @param   csq
3552      *          the CharSequence to be written
3553      * @param   options
3554      *          options specifying how the file is opened
3555      *
3556      * @return  the path
3557      *
3558      * @throws  IllegalArgumentException
3559      *          if {@code options} contains an invalid combination of options
3560      * @throws  IOException
3561      *          if an I/O error occurs writing to or creating the file, or the
3562      *          text cannot be encoded using the specified charset
3563      * @throws  UnsupportedOperationException
3564      *          if an unsupported option is specified
3565      * @throws  SecurityException
3566      *          In the case of the default provider, and a security manager is
3567      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
3568      *          method is invoked to check write access to the file. The {@link
3569      *          SecurityManager#checkDelete(String) checkDelete} method is
3570      *          invoked to check delete access if the file is opened with the
3571      *          {@code DELETE_ON_CLOSE} option.
3572      *
3573      * @since 11
3574      */
3575     public static Path writeString(Path path, CharSequence csq, OpenOption... options)
3576             throws IOException
3577     {
3578         return writeString(path, csq, StandardCharsets.UTF_8, options);
3579     }
3580 
3581     /**
3582      * Write a {@linkplain java.lang.CharSequence CharSequence} to a file.
3583      * Characters are encoded into bytes using the specified
3584      * {@linkplain java.nio.charset.Charset charset}.
3585      *
3586      * <p> All characters are written as they are, including the line separators in
3587      * the char sequence. No extra characters are added.
3588      *
3589      * <p> The {@code options} parameter specifies how the file is created
3590      * or opened. If no options are present then this method works as if the
3591      * {@link StandardOpenOption#CREATE CREATE}, {@link
3592      * StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING}, and {@link
3593      * StandardOpenOption#WRITE WRITE} options are present. In other words, it
3594      * opens the file for writing, creating the file if it doesn't exist, or
3595      * initially truncating an existing {@link #isRegularFile regular-file} to
3596      * a size of {@code 0}.
3597      *
3598      *
3599      * @param   path
3600      *          the path to the file
3601      * @param   csq
3602      *          the CharSequence to be written
3603      * @param   cs
3604      *          the charset to use for encoding
3605      * @param   options
3606      *          options specifying how the file is opened
3607      *
3608      * @return  the path
3609      *
3610      * @throws  IllegalArgumentException
3611      *          if {@code options} contains an invalid combination of options
3612      * @throws  IOException
3613      *          if an I/O error occurs writing to or creating the file, or the
3614      *          text cannot be encoded using the specified charset
3615      * @throws  UnsupportedOperationException
3616      *          if an unsupported option is specified
3617      * @throws  SecurityException
3618      *          In the case of the default provider, and a security manager is
3619      *          installed, the {@link SecurityManager#checkWrite(String) checkWrite}
3620      *          method is invoked to check write access to the file. The {@link
3621      *          SecurityManager#checkDelete(String) checkDelete} method is
3622      *          invoked to check delete access if the file is opened with the
3623      *          {@code DELETE_ON_CLOSE} option.
3624      *
3625      * @since 11
3626      */
3627     public static Path writeString(Path path, CharSequence csq, Charset cs, OpenOption... options)
3628             throws IOException
3629     {
3630         // ensure the text is not null before opening file
3631         Objects.requireNonNull(path);
3632         Objects.requireNonNull(csq);
3633         Objects.requireNonNull(cs);
3634 
3635         byte[] bytes = JLA.getBytesNoRepl(String.valueOf(csq), cs);
3636         write(path, bytes, options);
3637 
3638         return path;
3639     }
3640 
3641     // -- Stream APIs --
3642 
3643     /**
3644      * Return a lazily populated {@code Stream}, the elements of
3645      * which are the entries in the directory.  The listing is not recursive.
3646      *
3647      * <p> The elements of the stream are {@link Path} objects that are
3648      * obtained as if by {@link Path#resolve(Path) resolving} the name of the
3649      * directory entry against {@code dir}. Some file systems maintain special
3650      * links to the directory itself and the directory's parent directory.
3651      * Entries representing these links are not included.
3652      *
3653      * <p> The stream is <i>weakly consistent</i>. It is thread safe but does
3654      * not freeze the directory while iterating, so it may (or may not)
3655      * reflect updates to the directory that occur after returning from this
3656      * method.
3657      *
3658      * <p> The returned stream contains a reference to an open directory.
3659      * The directory is closed by closing the stream.
3660      *
3661      * <p> Operating on a closed stream behaves as if the end of stream
3662      * has been reached. Due to read-ahead, one or more elements may be
3663      * returned after the stream has been closed.
3664      *
3665      * <p> If an {@link IOException} is thrown when accessing the directory
3666      * after this method has returned, it is wrapped in an {@link
3667      * UncheckedIOException} which will be thrown from the method that caused
3668      * the access to take place.
3669      *
3670      * @apiNote
3671      * This method must be used within a try-with-resources statement or similar
3672      * control structure to ensure that the stream's open directory is closed
3673      * promptly after the stream's operations have completed.
3674      *
3675      * @param   dir  The path to the directory
3676      *
3677      * @return  The {@code Stream} describing the content of the
3678      *          directory
3679      *
3680      * @throws  NotDirectoryException
3681      *          if the file could not otherwise be opened because it is not
3682      *          a directory <i>(optional specific exception)</i>
3683      * @throws  IOException
3684      *          if an I/O error occurs when opening the directory
3685      * @throws  SecurityException
3686      *          In the case of the default provider, and a security manager is
3687      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
3688      *          method is invoked to check read access to the directory.
3689      *
3690      * @see     #newDirectoryStream(Path)
3691      * @since   1.8
3692      */
3693     public static Stream<Path> list(Path dir) throws IOException {
3694         DirectoryStream<Path> ds = Files.newDirectoryStream(dir);
3695         try {
3696             final Iterator<Path> delegate = ds.iterator();
3697 
3698             // Re-wrap DirectoryIteratorException to UncheckedIOException
3699             Iterator<Path> iterator = new Iterator<>() {
3700                 @Override
3701                 public boolean hasNext() {
3702                     try {
3703                         return delegate.hasNext();
3704                     } catch (DirectoryIteratorException e) {
3705                         throw new UncheckedIOException(e.getCause());
3706                     }
3707                 }
3708                 @Override
3709                 public Path next() {
3710                     try {
3711                         return delegate.next();
3712                     } catch (DirectoryIteratorException e) {
3713                         throw new UncheckedIOException(e.getCause());
3714                     }
3715                 }
3716             };
3717 
3718             Spliterator<Path> spliterator =
3719                 Spliterators.spliteratorUnknownSize(iterator, Spliterator.DISTINCT);
3720             return StreamSupport.stream(spliterator, false)
3721                                 .onClose(asUncheckedRunnable(ds));
3722         } catch (Error|RuntimeException e) {
3723             try {
3724                 ds.close();
3725             } catch (IOException ex) {
3726                 try {
3727                     e.addSuppressed(ex);
3728                 } catch (Throwable ignore) {}
3729             }
3730             throw e;
3731         }
3732     }
3733 
3734     /**
3735      * Return a {@code Stream} that is lazily populated with {@code
3736      * Path} by walking the file tree rooted at a given starting file.  The
3737      * file tree is traversed <em>depth-first</em>, the elements in the stream
3738      * are {@link Path} objects that are obtained as if by {@link
3739      * Path#resolve(Path) resolving} the relative path against {@code start}.
3740      *
3741      * <p> The {@code stream} walks the file tree as elements are consumed.
3742      * The {@code Stream} returned is guaranteed to have at least one
3743      * element, the starting file itself. For each file visited, the stream
3744      * attempts to read its {@link BasicFileAttributes}. If the file is a
3745      * directory and can be opened successfully, entries in the directory, and
3746      * their <em>descendants</em> will follow the directory in the stream as
3747      * they are encountered. When all entries have been visited, then the
3748      * directory is closed. The file tree walk then continues at the next
3749      * <em>sibling</em> of the directory.
3750      *
3751      * <p> The stream is <i>weakly consistent</i>. It does not freeze the
3752      * file tree while iterating, so it may (or may not) reflect updates to
3753      * the file tree that occur after returned from this method.
3754      *
3755      * <p> By default, symbolic links are not automatically followed by this
3756      * method. If the {@code options} parameter contains the {@link
3757      * FileVisitOption#FOLLOW_LINKS FOLLOW_LINKS} option then symbolic links are
3758      * followed. When following links, and the attributes of the target cannot
3759      * be read, then this method attempts to get the {@code BasicFileAttributes}
3760      * of the link.
3761      *
3762      * <p> If the {@code options} parameter contains the {@link
3763      * FileVisitOption#FOLLOW_LINKS FOLLOW_LINKS} option then the stream keeps
3764      * track of directories visited so that cycles can be detected. A cycle
3765      * arises when there is an entry in a directory that is an ancestor of the
3766      * directory. Cycle detection is done by recording the {@link
3767      * java.nio.file.attribute.BasicFileAttributes#fileKey file-key} of directories,
3768      * or if file keys are not available, by invoking the {@link #isSameFile
3769      * isSameFile} method to test if a directory is the same file as an
3770      * ancestor. When a cycle is detected it is treated as an I/O error with
3771      * an instance of {@link FileSystemLoopException}.
3772      *
3773      * <p> The {@code maxDepth} parameter is the maximum number of levels of
3774      * directories to visit. A value of {@code 0} means that only the starting
3775      * file is visited, unless denied by the security manager. A value of
3776      * {@link Integer#MAX_VALUE MAX_VALUE} may be used to indicate that all
3777      * levels should be visited.
3778      *
3779      * <p> When a security manager is installed and it denies access to a file
3780      * (or directory), then it is ignored and not included in the stream.
3781      *
3782      * <p> The returned stream contains references to one or more open directories.
3783      * The directories are closed by closing the stream.
3784      *
3785      * <p> If an {@link IOException} is thrown when accessing the directory
3786      * after this method has returned, it is wrapped in an {@link
3787      * UncheckedIOException} which will be thrown from the method that caused
3788      * the access to take place.
3789      *
3790      * @apiNote
3791      * This method must be used within a try-with-resources statement or similar
3792      * control structure to ensure that the stream's open directories are closed
3793      * promptly after the stream's operations have completed.
3794      *
3795      * @param   start
3796      *          the starting file
3797      * @param   maxDepth
3798      *          the maximum number of directory levels to visit
3799      * @param   options
3800      *          options to configure the traversal
3801      *
3802      * @return  the {@link Stream} of {@link Path}
3803      *
3804      * @throws  IllegalArgumentException
3805      *          if the {@code maxDepth} parameter is negative
3806      * @throws  SecurityException
3807      *          If the security manager denies access to the starting file.
3808      *          In the case of the default provider, the {@link
3809      *          SecurityManager#checkRead(String) checkRead} method is invoked
3810      *          to check read access to the directory.
3811      * @throws  IOException
3812      *          if an I/O error is thrown when accessing the starting file.
3813      * @since   1.8
3814      */
3815     public static Stream<Path> walk(Path start,
3816                                     int maxDepth,
3817                                     FileVisitOption... options)
3818         throws IOException
3819     {
3820         FileTreeIterator iterator = new FileTreeIterator(start, maxDepth, options);
3821         try {
3822             Spliterator<FileTreeWalker.Event> spliterator =
3823                 Spliterators.spliteratorUnknownSize(iterator, Spliterator.DISTINCT);
3824             return StreamSupport.stream(spliterator, false)
3825                                 .onClose(iterator::close)
3826                                 .map(entry -> entry.file());
3827         } catch (Error|RuntimeException e) {
3828             iterator.close();
3829             throw e;
3830         }
3831     }
3832 
3833     /**
3834      * Return a {@code Stream} that is lazily populated with {@code
3835      * Path} by walking the file tree rooted at a given starting file.  The
3836      * file tree is traversed <em>depth-first</em>, the elements in the stream
3837      * are {@link Path} objects that are obtained as if by {@link
3838      * Path#resolve(Path) resolving} the relative path against {@code start}.
3839      *
3840      * <p> This method works as if invoking it were equivalent to evaluating the
3841      * expression:
3842      * <blockquote><pre>
3843      * walk(start, Integer.MAX_VALUE, options)
3844      * </pre></blockquote>
3845      * In other words, it visits all levels of the file tree.
3846      *
3847      * <p> The returned stream contains references to one or more open directories.
3848      * The directories are closed by closing the stream.
3849      *
3850      * @apiNote
3851      * This method must be used within a try-with-resources statement or similar
3852      * control structure to ensure that the stream's open directories are closed
3853      * promptly after the stream's operations have completed.
3854      *
3855      * @param   start
3856      *          the starting file
3857      * @param   options
3858      *          options to configure the traversal
3859      *
3860      * @return  the {@link Stream} of {@link Path}
3861      *
3862      * @throws  SecurityException
3863      *          If the security manager denies access to the starting file.
3864      *          In the case of the default provider, the {@link
3865      *          SecurityManager#checkRead(String) checkRead} method is invoked
3866      *          to check read access to the directory.
3867      * @throws  IOException
3868      *          if an I/O error is thrown when accessing the starting file.
3869      *
3870      * @see     #walk(Path, int, FileVisitOption...)
3871      * @since   1.8
3872      */
3873     public static Stream<Path> walk(Path start, FileVisitOption... options) throws IOException {
3874         return walk(start, Integer.MAX_VALUE, options);
3875     }
3876 
3877     /**
3878      * Return a {@code Stream} that is lazily populated with {@code
3879      * Path} by searching for files in a file tree rooted at a given starting
3880      * file.
3881      *
3882      * <p> This method walks the file tree in exactly the manner specified by
3883      * the {@link #walk walk} method. For each file encountered, the given
3884      * {@link BiPredicate} is invoked with its {@link Path} and {@link
3885      * BasicFileAttributes}. The {@code Path} object is obtained as if by
3886      * {@link Path#resolve(Path) resolving} the relative path against {@code
3887      * start} and is only included in the returned {@link Stream} if
3888      * the {@code BiPredicate} returns true. Compare to calling {@link
3889      * java.util.stream.Stream#filter filter} on the {@code Stream}
3890      * returned by {@code walk} method, this method may be more efficient by
3891      * avoiding redundant retrieval of the {@code BasicFileAttributes}.
3892      *
3893      * <p> The returned stream contains references to one or more open directories.
3894      * The directories are closed by closing the stream.
3895      *
3896      * <p> If an {@link IOException} is thrown when accessing the directory
3897      * after returned from this method, it is wrapped in an {@link
3898      * UncheckedIOException} which will be thrown from the method that caused
3899      * the access to take place.
3900      *
3901      * @apiNote
3902      * This method must be used within a try-with-resources statement or similar
3903      * control structure to ensure that the stream's open directories are closed
3904      * promptly after the stream's operations have completed.
3905      *
3906      * @param   start
3907      *          the starting file
3908      * @param   maxDepth
3909      *          the maximum number of directory levels to search
3910      * @param   matcher
3911      *          the function used to decide whether a file should be included
3912      *          in the returned stream
3913      * @param   options
3914      *          options to configure the traversal
3915      *
3916      * @return  the {@link Stream} of {@link Path}
3917      *
3918      * @throws  IllegalArgumentException
3919      *          if the {@code maxDepth} parameter is negative
3920      * @throws  SecurityException
3921      *          If the security manager denies access to the starting file.
3922      *          In the case of the default provider, the {@link
3923      *          SecurityManager#checkRead(String) checkRead} method is invoked
3924      *          to check read access to the directory.
3925      * @throws  IOException
3926      *          if an I/O error is thrown when accessing the starting file.
3927      *
3928      * @see     #walk(Path, int, FileVisitOption...)
3929      * @since   1.8
3930      */
3931     public static Stream<Path> find(Path start,
3932                                     int maxDepth,
3933                                     BiPredicate<Path, BasicFileAttributes> matcher,
3934                                     FileVisitOption... options)
3935         throws IOException
3936     {
3937         FileTreeIterator iterator = new FileTreeIterator(start, maxDepth, options);
3938         try {
3939             Spliterator<FileTreeWalker.Event> spliterator =
3940                 Spliterators.spliteratorUnknownSize(iterator, Spliterator.DISTINCT);
3941             return StreamSupport.stream(spliterator, false)
3942                                 .onClose(iterator::close)
3943                                 .filter(entry -> matcher.test(entry.file(), entry.attributes()))
3944                                 .map(entry -> entry.file());
3945         } catch (Error|RuntimeException e) {
3946             iterator.close();
3947             throw e;
3948         }
3949     }
3950 
3951 
3952     /**
3953      * Read all lines from a file as a {@code Stream}. Unlike {@link
3954      * #readAllLines(Path, Charset) readAllLines}, this method does not read
3955      * all lines into a {@code List}, but instead populates lazily as the stream
3956      * is consumed.
3957      *
3958      * <p> Bytes from the file are decoded into characters using the specified
3959      * charset and the same line terminators as specified by {@code
3960      * readAllLines} are supported.
3961      *
3962      * <p> The returned stream contains a reference to an open file. The file
3963      * is closed by closing the stream.
3964      *
3965      * <p> The file contents should not be modified during the execution of the
3966      * terminal stream operation. Otherwise, the result of the terminal stream
3967      * operation is undefined.
3968      *
3969      * <p> After this method returns, then any subsequent I/O exception that
3970      * occurs while reading from the file or when a malformed or unmappable byte
3971      * sequence is read, is wrapped in an {@link UncheckedIOException} that will
3972      * be thrown from the
3973      * {@link java.util.stream.Stream} method that caused the read to take
3974      * place. In case an {@code IOException} is thrown when closing the file,
3975      * it is also wrapped as an {@code UncheckedIOException}.
3976      *
3977      * @apiNote
3978      * This method must be used within a try-with-resources statement or similar
3979      * control structure to ensure that the stream's open file is closed promptly
3980      * after the stream's operations have completed.
3981      *
3982      * @implNote
3983      * This implementation supports good parallel stream performance for the
3984      * standard charsets {@link StandardCharsets#UTF_8 UTF-8},
3985      * {@link StandardCharsets#US_ASCII US-ASCII} and
3986      * {@link StandardCharsets#ISO_8859_1 ISO-8859-1}.  Such
3987      * <em>line-optimal</em> charsets have the property that the encoded bytes
3988      * of a line feed ('\n') or a carriage return ('\r') are efficiently
3989      * identifiable from other encoded characters when randomly accessing the
3990      * bytes of the file.
3991      *
3992      * <p> For non-<em>line-optimal</em> charsets the stream source's
3993      * spliterator has poor splitting properties, similar to that of a
3994      * spliterator associated with an iterator or that associated with a stream
3995      * returned from {@link BufferedReader#lines()}.  Poor splitting properties
3996      * can result in poor parallel stream performance.
3997      *
3998      * <p> For <em>line-optimal</em> charsets the stream source's spliterator
3999      * has good splitting properties, assuming the file contains a regular
4000      * sequence of lines.  Good splitting properties can result in good parallel
4001      * stream performance.  The spliterator for a <em>line-optimal</em> charset
4002      * takes advantage of the charset properties (a line feed or a carriage
4003      * return being efficient identifiable) such that when splitting it can
4004      * approximately divide the number of covered lines in half.
4005      *
4006      * @param   path
4007      *          the path to the file
4008      * @param   cs
4009      *          the charset to use for decoding
4010      *
4011      * @return  the lines from the file as a {@code Stream}
4012      *
4013      * @throws  IOException
4014      *          if an I/O error occurs opening the file
4015      * @throws  SecurityException
4016      *          In the case of the default provider, and a security manager is
4017      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
4018      *          method is invoked to check read access to the file.
4019      *
4020      * @see     #readAllLines(Path, Charset)
4021      * @see     #newBufferedReader(Path, Charset)
4022      * @see     java.io.BufferedReader#lines()
4023      * @since   1.8
4024      */
4025     public static Stream<String> lines(Path path, Charset cs) throws IOException {
4026         // Use the good splitting spliterator if:
4027         // 1) the path is associated with the default file system;
4028         // 2) the character set is supported; and
4029         // 3) the file size is such that all bytes can be indexed by int values
4030         //    (this limitation is imposed by ByteBuffer)
4031         if (path.getFileSystem() == FileSystems.getDefault() &&
4032             FileChannelLinesSpliterator.SUPPORTED_CHARSET_NAMES.contains(cs.name())) {
4033             FileChannel fc = FileChannel.open(path, StandardOpenOption.READ);
4034 
4035             Stream<String> fcls = createFileChannelLinesStream(fc, cs);
4036             if (fcls != null) {
4037                 return fcls;
4038             }
4039             fc.close();
4040         }
4041 
4042         return createBufferedReaderLinesStream(Files.newBufferedReader(path, cs));
4043     }
4044 
4045     private static Stream<String> createFileChannelLinesStream(FileChannel fc, Charset cs) throws IOException {
4046         try {
4047             // Obtaining the size from the FileChannel is much faster
4048             // than obtaining using path.toFile().length()
4049             long length = fc.size();
4050             // FileChannel.size() may in certain circumstances return zero
4051             // for a non-zero length file so disallow this case.
4052             if (length > 0 && length <= Integer.MAX_VALUE) {
4053                 Spliterator<String> s = new FileChannelLinesSpliterator(fc, cs, 0, (int) length);
4054                 return StreamSupport.stream(s, false)
4055                         .onClose(Files.asUncheckedRunnable(fc));
4056             }
4057         } catch (Error|RuntimeException|IOException e) {
4058             try {
4059                 fc.close();
4060             } catch (IOException ex) {
4061                 try {
4062                     e.addSuppressed(ex);
4063                 } catch (Throwable ignore) {
4064                 }
4065             }
4066             throw e;
4067         }
4068         return null;
4069     }
4070 
4071     private static Stream<String> createBufferedReaderLinesStream(BufferedReader br) {
4072         try {
4073             return br.lines().onClose(asUncheckedRunnable(br));
4074         } catch (Error|RuntimeException e) {
4075             try {
4076                 br.close();
4077             } catch (IOException ex) {
4078                 try {
4079                     e.addSuppressed(ex);
4080                 } catch (Throwable ignore) {
4081                 }
4082             }
4083             throw e;
4084         }
4085     }
4086 
4087     /**
4088      * Read all lines from a file as a {@code Stream}. Bytes from the file are
4089      * decoded into characters using the {@link StandardCharsets#UTF_8 UTF-8}
4090      * {@link Charset charset}.
4091      *
4092      * <p> The returned stream contains a reference to an open file. The file
4093      * is closed by closing the stream.
4094      *
4095      * <p> The file contents should not be modified during the execution of the
4096      * terminal stream operation. Otherwise, the result of the terminal stream
4097      * operation is undefined.
4098      *
4099      * <p> This method works as if invoking it were equivalent to evaluating the
4100      * expression:
4101      * <pre>{@code
4102      * Files.lines(path, StandardCharsets.UTF_8)
4103      * }</pre>
4104      *
4105      * @apiNote
4106      * This method must be used within a try-with-resources statement or similar
4107      * control structure to ensure that the stream's open file is closed promptly
4108      * after the stream's operations have completed.
4109      *
4110      * @param   path
4111      *          the path to the file
4112      *
4113      * @return  the lines from the file as a {@code Stream}
4114      *
4115      * @throws  IOException
4116      *          if an I/O error occurs opening the file
4117      * @throws  SecurityException
4118      *          In the case of the default provider, and a security manager is
4119      *          installed, the {@link SecurityManager#checkRead(String) checkRead}
4120      *          method is invoked to check read access to the file.
4121      *
4122      * @since 1.8
4123      */
4124     public static Stream<String> lines(Path path) throws IOException {
4125         return lines(path, StandardCharsets.UTF_8);
4126     }
4127 }
--- EOF ---