3262 *
3263 * @return a String containing the content read from the file
3264 *
3265 * @throws IOException
3266 * if an I/O error occurs reading from the file or a malformed or
3267 * unmappable byte sequence is read
3268 * @throws OutOfMemoryError
3269 * if the file is extremely large, for example larger than {@code 2GB}
3270 * @throws SecurityException
3271 * In the case of the default provider, and a security manager is
3272 * installed, the {@link SecurityManager#checkRead(String) checkRead}
3273 * method is invoked to check read access to the file.
3274 *
3275 * @since 11
3276 */
3277 public static String readString(Path path, Charset cs) throws IOException {
3278 Objects.requireNonNull(path);
3279 Objects.requireNonNull(cs);
3280
3281 byte[] ba = readAllBytes(path);
3282 try {
3283 return JLA.newStringNoRepl(ba, cs);
3284 } catch (IllegalArgumentException e) {
3285 throw new IOException(e);
3286 }
3287 }
3288
3289 /**
3290 * Read all lines from a file. This method ensures that the file is
3291 * closed when all bytes have been read or an I/O error, or other runtime
3292 * exception, is thrown. Bytes from the file are decoded into characters
3293 * using the specified charset.
3294 *
3295 * <p> This method recognizes the following as line terminators:
3296 * <ul>
3297 * <li> <code>\u000D</code> followed by <code>\u000A</code>,
3298 * CARRIAGE RETURN followed by LINE FEED </li>
3299 * <li> <code>\u000A</code>, LINE FEED </li>
3300 * <li> <code>\u000D</code>, CARRIAGE RETURN </li>
3301 * </ul>
3302 * <p> Additional Unicode line terminators may be recognized in future
3303 * releases.
3304 *
3305 * <p> Note that this method is intended for simple cases where it is
3306 * convenient to read all lines in a single operation. It is not intended
3617 * @throws UnsupportedOperationException
3618 * if an unsupported option is specified
3619 * @throws SecurityException
3620 * In the case of the default provider, and a security manager is
3621 * installed, the {@link SecurityManager#checkWrite(String) checkWrite}
3622 * method is invoked to check write access to the file. The {@link
3623 * SecurityManager#checkDelete(String) checkDelete} method is
3624 * invoked to check delete access if the file is opened with the
3625 * {@code DELETE_ON_CLOSE} option.
3626 *
3627 * @since 11
3628 */
3629 public static Path writeString(Path path, CharSequence csq, Charset cs, OpenOption... options)
3630 throws IOException
3631 {
3632 // ensure the text is not null before opening file
3633 Objects.requireNonNull(path);
3634 Objects.requireNonNull(csq);
3635 Objects.requireNonNull(cs);
3636
3637 try {
3638 byte[] bytes = JLA.getBytesNoRepl(String.valueOf(csq), cs);
3639 write(path, bytes, options);
3640 } catch (IllegalArgumentException e) {
3641 throw new IOException(e);
3642 }
3643
3644 return path;
3645 }
3646
3647 // -- Stream APIs --
3648
3649 /**
3650 * Return a lazily populated {@code Stream}, the elements of
3651 * which are the entries in the directory. The listing is not recursive.
3652 *
3653 * <p> The elements of the stream are {@link Path} objects that are
3654 * obtained as if by {@link Path#resolve(Path) resolving} the name of the
3655 * directory entry against {@code dir}. Some file systems maintain special
3656 * links to the directory itself and the directory's parent directory.
3657 * Entries representing these links are not included.
3658 *
3659 * <p> The stream is <i>weakly consistent</i>. It is thread safe but does
3660 * not freeze the directory while iterating, so it may (or may not)
3661 * reflect updates to the directory that occur after returning from this
3662 * method.
|
3262 *
3263 * @return a String containing the content read from the file
3264 *
3265 * @throws IOException
3266 * if an I/O error occurs reading from the file or a malformed or
3267 * unmappable byte sequence is read
3268 * @throws OutOfMemoryError
3269 * if the file is extremely large, for example larger than {@code 2GB}
3270 * @throws SecurityException
3271 * In the case of the default provider, and a security manager is
3272 * installed, the {@link SecurityManager#checkRead(String) checkRead}
3273 * method is invoked to check read access to the file.
3274 *
3275 * @since 11
3276 */
3277 public static String readString(Path path, Charset cs) throws IOException {
3278 Objects.requireNonNull(path);
3279 Objects.requireNonNull(cs);
3280
3281 byte[] ba = readAllBytes(path);
3282 return JLA.newStringNoRepl(ba, cs);
3283 }
3284
3285 /**
3286 * Read all lines from a file. This method ensures that the file is
3287 * closed when all bytes have been read or an I/O error, or other runtime
3288 * exception, is thrown. Bytes from the file are decoded into characters
3289 * using the specified charset.
3290 *
3291 * <p> This method recognizes the following as line terminators:
3292 * <ul>
3293 * <li> <code>\u000D</code> followed by <code>\u000A</code>,
3294 * CARRIAGE RETURN followed by LINE FEED </li>
3295 * <li> <code>\u000A</code>, LINE FEED </li>
3296 * <li> <code>\u000D</code>, CARRIAGE RETURN </li>
3297 * </ul>
3298 * <p> Additional Unicode line terminators may be recognized in future
3299 * releases.
3300 *
3301 * <p> Note that this method is intended for simple cases where it is
3302 * convenient to read all lines in a single operation. It is not intended
3613 * @throws UnsupportedOperationException
3614 * if an unsupported option is specified
3615 * @throws SecurityException
3616 * In the case of the default provider, and a security manager is
3617 * installed, the {@link SecurityManager#checkWrite(String) checkWrite}
3618 * method is invoked to check write access to the file. The {@link
3619 * SecurityManager#checkDelete(String) checkDelete} method is
3620 * invoked to check delete access if the file is opened with the
3621 * {@code DELETE_ON_CLOSE} option.
3622 *
3623 * @since 11
3624 */
3625 public static Path writeString(Path path, CharSequence csq, Charset cs, OpenOption... options)
3626 throws IOException
3627 {
3628 // ensure the text is not null before opening file
3629 Objects.requireNonNull(path);
3630 Objects.requireNonNull(csq);
3631 Objects.requireNonNull(cs);
3632
3633 byte[] bytes = JLA.getBytesNoRepl(String.valueOf(csq), cs);
3634 write(path, bytes, options);
3635
3636 return path;
3637 }
3638
3639 // -- Stream APIs --
3640
3641 /**
3642 * Return a lazily populated {@code Stream}, the elements of
3643 * which are the entries in the directory. The listing is not recursive.
3644 *
3645 * <p> The elements of the stream are {@link Path} objects that are
3646 * obtained as if by {@link Path#resolve(Path) resolving} the name of the
3647 * directory entry against {@code dir}. Some file systems maintain special
3648 * links to the directory itself and the directory's parent directory.
3649 * Entries representing these links are not included.
3650 *
3651 * <p> The stream is <i>weakly consistent</i>. It is thread safe but does
3652 * not freeze the directory while iterating, so it may (or may not)
3653 * reflect updates to the directory that occur after returning from this
3654 * method.
|