Summary
-------

Add a new method `getExtension()` to `java.nio.file.Path`.

Problem
-------

No notion of file name extension is codified in the `java.nio` specification. Obtaining the file name extension from a `Path`, usually the portion of the last element after the last period character ('.', U+002E FULL STOP) optionally including the period character itself, currently devolves to a "manual" search of the `String` version of the file name.

Solution
--------

To `java.nio.file.Path` add the method
```
default String getExtension()
```
to return the extension of the filename, the last element of the `Path`;

Note that this method deals with `String`, whereas `Path` objects maintain data in an internal platform-specific format. `Path` creation (via `Path.of`) and conversion to `String` (via `toString`) may involve codeset conversion or Unicode normalization. These conversions are potentially lossy, and they might produce surprising or unexpected results. (An example of Unicode normalization involves accented characters, which have multiple valid representations consisting of different sequences of code points.) For this reason, many `Path` operations, such as `getName(int)` or `resolve(Path)`, operate on the platform-specific representation and avoid converting to and from `String`. 

The lossiness problems can occur in the current `Path` API, independent of the API addition proposed here. They occur when the application operates on the path data as a `String`. For example, the following expression returns true on most platforms:
```
Path.of("avant.apres").toString().endsWith("apres")
```
However, if an accent is added by inserting U+0300 COMBINING GRAVE ACCENT in the right place,
```
Path.of("avant.apre\u0300s").toString().endsWith("apre\u0300s")
```
this exposes the application to platform-specific behavior. In particular, this expression returns `true` on Linux and `false` on macOS.

Despite the potential lossiness, the API proposed here converts `Path` data to a Java `String` and enables further operations in the String domain. The reason is that there is no `Path` abstraction for operating on a *fragment* of a `Path` element in the platform-specific domain. Creating an abstraction that operates on fragments in the platform-specific domain is unwarranted. It would be quite complex (essentially re-creating a string-like API) in order to support most operations. In addition, there is no cross-platform notion of a filename extension. On some platforms, the file extension is purely a naming convention and is thus fundamentally a string operation.

Existing code that deals with filename extensions already likely does these operations in the `String` domain and so is already exposed to such lossiness. For example, to find the filename extension, such code would convert the last `Path` element to a `String`, call `lastIndexOf(".")`, and use `substring()` and string concatenation to manipulate portions of the name. The API added here does not attempt to solve the lossiness problem, nor is it feasible for it to attempt to solve it. This API is intended only to make `String`-based `Path` manipulation more convenient. 


Specification
-------------

    --- a/src/java.base/share/classes/java/nio/file/Path.java
    +++ b/src/java.base/share/classes/java/nio/file/Path.java
    @@ -49,7 +50,7 @@
      * file system. {@code Path} defines the {@link #getFileName() getFileName},
      * {@link #getParent getParent}, {@link #getRoot getRoot}, and {@link #subpath
      * subpath} methods to access the path components or a subsequence of its name
    - * elements.
    + * elements, and {@link #getExtension() getExtension} to obtain its extension.
      *
      * <p> In addition to accessing the components of a path, a {@code Path} also
      * defines the {@link #resolve(Path) resolve} and {@link #resolveSibling(Path)
    @@ -248,6 +249,63 @@ public static Path of(URI uri) {
          */
         Path getFileName();
     
    +    /**
    +     * Returns the file extension of this path's file name as a {@code String}.
    +     * The extension is derived from this {@code Path} by obtaining the
    +     * {@linkplain #getFileName file name element}, deriving its {@linkplain
    +     * #toString string representation}, and then extracting a substring
    +     * determined by the position of a period character ('.', U+002E FULL STOP)
    +     * within the file name string. If the file name element is {@code null},
    +     * or if the file name string does not contain a period character, or if
    +     * the only period in the file name string is its first character, then
    +     * the extension is {@code null}. Otherwise, the extension is the substring
    +     * after the last period in the file name string. If this last period is
    +     * also the last character in the file name string, then the  extension is
    +     * {@linkplain String#isEmpty empty}.
    +     *
    +     * @implSpec
    +     * The default implementation is equivalent for this path to:
    +     * <pre>{@code
    +     * int lastPeriod = fileName.lastIndexOf('.');
    +     * if (lastPeriod <= 0)
    +     *     return null;
    +     * return (lastPeriod == fileName.length() - 1)
    +     *     ? ""
    +     *     : fileName.substring(lastPeriod + 1);
    +     * }</pre>
    +     *
    +     * @return  the file name extension of this path, which might be the
    +     *          empty string, or {@code null} if no extension is found
    +     *
    +     * @since 20
    +     */
    +    default String getExtension() {}