This code works:
public final class Foo
{
private static final List<String> INPUTS = Arrays.asList(
"/foo", "//foo", "foo/", "foo/bar", "foo/bar/../baz", "foo//bar"
);
public static void main(final String... args)
{
Path path;
for (final String input: INPUTS) {
path = Paths.get("/", input).normalize();
System.out.printf("%s -> %s\n", input, path);
}
}
}
Output:
/foo -> /foo
//foo -> /foo
foo/ -> /foo
foo/bar -> /foo/bar
foo/bar/../baz -> /foo/baz
foo//bar -> /foo/bar
NOTE however that this is NOT portable. It won't work on Windows machines...
If you want a portable solution you can use memoryfilesystem, open a Unix filesystem and use that:
try (
final FileSystem fs = MemoryFileSystem.newLinux().build();
) {
// path operations here
}
GeeksforGeeks
geeksforgeeks.org › java › path-normalize-method-in-java-with-examples
Path normalize() method in Java with Examples - GeeksforGeeks
July 30, 2019 - The normalize() method of java.nio.file.Path used to return a path from current path in which all redundant name elements are eliminated. The precise definition of this method is implementation dependent and it derives a path that does not contain ...
About Path normalize() in Java - Stack Overflow
For the following code, the aPath turns out to be D:\ OCPJP7\ NIO2\ src\SubPath.java. Why is the programs element gone? Path aPath = Paths.get(" D:\\ OCPJP7\\ programs\\..\\ NIO2\\ src\\.\\ SubPat... More on stackoverflow.com
What is an example of using Path.normalize/Path.resolve in your code?
Let's see what they say they do: Path.normalize The path.normalize() method normalizes the given path, resolving '..' and '.' segments. "Normalize" here means make consistent. "Resolve" means work out what the symbols represent, . is the current directory and .. is up one directory. When multiple, sequential path segment separation characters are found (e.g. / on POSIX and either \ or / on Windows), they are replaced by a single instance of the platform-specific path segment separator (/ on POSIX and \ on Windows). Trailing separators are preserved. Different operating systems use different characters in paths. For example, C:\Users\jrandm\ on Windows and /home/jrandm/ on Linux. Part of normalizing -- making consistent -- is making sure the same path separator (the slash) is used. Node knows when it is running on Windows or a POSIX system (this includes Linux, BSD, and Mac). If the path is a zero-length string, '.' is returned, representing the current working directory. I think that's self-explanatory. Path.resolve The path.resolve() method resolves a sequence of paths or path segments into an absolute path. As in normalize, "resolve" here means to take any symbols and convert it into a full, or absolute, path. That means it is completely qualified: all of the /./ and /../ parts are applied so it is only the directory names and file. /foo/bar/.././././baz becomes /foo/baz. The given sequence of paths is processed from right to left, with each subsequent path prepended until an absolute path is constructed. [example cut] This means it starts on the left side and moves right, condensing the .s until they're all gone. If after processing all given path segments an absolute path has not yet been generated, the current working directory is used. If for some reason it fails to remove all the .s, this function falls back to the current working directory. That is defined as part of the environment when you run the node program. The resulting path is normalized and trailing slashes are removed unless the path is resolved to the root directory. The result of the resolution process is passed through normalize, described above, and any trailing slashes are removed unless it is the root directory (meaning something like / on POSIX or C:\ on Windows). More on reddit.com
1
1
March 5, 2020Normalizing slashes from a string path in java - Stack Overflow
String path = "/var/lib/////xen//images///rhel"; the number of slashes can be of any number. How to normalize the path in java like : /var/lib/xen/images/rhel More on stackoverflow.com
java - Generating a canonical path - Stack Overflow
That's why Java need to check it on the filesystem. So there's no simple logic to test the path without knowing the OS. ... So, while normalizing can do the trick, here is a procedure that exposes a little more of the Java API than would simply calling Paths.normalize() More on stackoverflow.com
Medium
medium.com › @python-javascript-php-html-css › fixing-windows-file-path-issues-in-java-using-path-3dbfff6ed0f8
Fixing Windows File Path Issues in Java Using Path
November 20, 2024 - Using the Path.normalize() method, you can streamline paths to their simplest form, reducing potential errors when working with both local files and external APIs. This approach is especially important when paths come from different environments ...
GitHub
gist.github.com › jgregorio0 › 4faf14a409561c5ef59de1e1964db8d0
normalizeFile.md · GitHub
private static final String REGEX_NON_ASCII = "[^\\p{ASCII}]"; /** * Elimina tildes y sustituye espacios por "-" * @param filename * @return */ public static String normalizeFilename(String filename) { if (StringUtils.isBlank(filename)) { return filename; } return Normalizer.normalize(filename, Normalizer.Form.NFD) .replaceAll(REGEX_NON_ASCII, "") .replaceAll(" ", "-"); } ... Path path = Paths.get("C:\\..\\.\\terrible/path//to/file"); // normalize the path Path normalizedPath = path.normalize();
Java2s
java2s.com › example › java-book › paths-normalizing.html
Java - File Input Output Paths Normalizing
The following code shows some examples of normalizing paths on Windows. import java.nio.file.Path; import java.nio.file.Paths; public class Main { public static void main(String[] args) { Path p1 = Paths.get("C:\\myData\\..\\\\myData\\Main.java"); Path p1n = p1.normalize();/*from www.
Java2s
java2s.com › Tutorials › Java › java.nio.file › Path › 0300__Path.normalize_.htm
Java IO Tutorial - Java Path.normalize()
In the following code shows how to use Path.normalize() method. /*from w w w. j a v a 2 s .c o m*/ import java.nio.file.Path; import java.nio.file.Paths; public class Main { public static void main(String[] args) { Path path = Paths.get("C:/home/./music/users.txt"); System.out.println("Normalized: " + path.normalize()); } }
Oracle
docs.oracle.com › javase › 8 › docs › api › java › nio › file › Path.html
Path (Java Platform SE 8 )
April 21, 2026 - This method does not access the file system; the path or its parent may not exist. Furthermore, this method does not eliminate special names such as "." and ".." that may be used in some implementations. On UNIX for example, the parent of "/a/b/c" is "/a/b", and the parent of "x/y/." is "x/y". This method may be used with the normalize method, to eliminate redundant names, for cases where shell-like navigation is required.
Jenkov
jenkov.com › tutorials › java-nio › path.html
Java NIO Path
Normalizing means that it removes all the . and .. codes in the middle of the path string, and resolves what path the path string refers to. Here is a Java Path.normalize() example:
Tabnine
tabnine.com › home › code library
Code Library - Tabnine
July 25, 2024 - Get the answers and suggestions you need from our AI code assistant. Get started in minutes with a free 90 day trial of Tabnine Pro.
Dev.java
dev.java › learn › java-io › file-system › path
Working with Paths - Dev.java
January 25, 2023 - Perhaps a server is configured ... "/." notation from the path. ... The normalize() method removes any redundant elements, which includes any "." or "directory/.." occurrences....
Top answer 1 of 2
1
Because the normalization replaced the .. programs' parent directory.
So you have NIO2 as a sub-folder of OCPJP7.
Similarly, . goes away as it's redundant (indicates current directory within context).
2 of 2
1
Because the programs element is followed by \\..\\ which means "to go up one directory level". This sequence removes the \\programs\\ part from your path.
Oracle
docs.oracle.com › en › java › javase › 20 › docs › api › java.base › java › nio › file › Path.html
Path (Java SE 20 & JDK 20)
July 10, 2023 - This method does not access the file system; the path or its parent may not exist. Furthermore, this method does not eliminate special names such as "." and ".." that may be used in some implementations. On UNIX for example, the parent of "/a/b/c" is "/a/b", and the parent of "x/y/." is "x/y". This method may be used with the normalize method, to eliminate redundant names, for cases where shell-like navigation is required.
Reddit
reddit.com › r/learnjavascript › what is an example of using path.normalize/path.resolve in your code?
r/learnjavascript on Reddit: What is an example of using Path.normalize/Path.resolve in your code?
March 5, 2020 -
Everytime I use them in my projects, I seem to get unintended consequences where the pathing doesn't work as intended.
I'd really like to know how more experienced people use these functions.
Oracle
docs.oracle.com › javase › 7 › docs › api › java › nio › file › Path.html
Path (Java Platform SE 7 )
This method does not access the file system; the path or its parent may not exist. Furthermore, this method does not eliminate special names such as "." and ".." that may be used in some implementations. On UNIX for example, the parent of "/a/b/c" is "/a/b", and the parent of "x/y/." is "x/y". This method may be used with the normalize method, to eliminate redundant names, for cases where shell-like navigation is required.
Top answer 1 of 4
14
Use the built-in String method replaceAll, with a regular expression "/+", replacing one or more slashes with one slash:
path = path.replaceAll("/+", "/");
2 of 4
5
You could use a File object to output the path specific to the current platform:
String path = "/var/lib/////xen//images///rhel";
path = new File(path).getPath();
Baeldung
baeldung.com › home › java › java io › java nio2 path api
Java NIO2 Path API | Baeldung
January 8, 2024 - You might have a situation where ... two have redundancies while the last one does not. Normalizing a path involves removing redundancies in it....
Baeldung
baeldung.com › home › networking › normalize a url in java
Normalize a URL in Java | Baeldung
January 31, 2024 - Performing manual normalization involves applying custom logic to standardize the URLs. This process includes removing extraneous elements, such as unnecessary query parameters and fragment identifiers, to distill the URL down to its essential core.
Top answer 1 of 7
21
I think you can use the URI class to do this; e.g. if the path contains no characters that need escaping in a URI path component, you can do this.
String normalized = new URI(path).normalize().getPath();
If the path contains (or might contain) characters that need escaping, the multi-argument constructors will escape the path argument, and you can provide null for the other arguments.
Notes:
The above normalizes a file path by treating it as a relative URI. If you want to normalize an entire URI ... including the (optional) scheme, authority, and other components, don't call
getPath()!URI normalization does not involve looking at the file system as File canonicalization does. But the flip side is that normalization behaves differently to canonicalization when there are symbolic links in the path.
2 of 7
17
Using Apache Commons IO (a well-known and well-tested library)
public static String normalize(String filename)
will do exactly what you're looking for.
Example:
String result = FilenameUtils.normalize(myFile.getAbsolutePath());
Oracle
docs.oracle.com › javase › tutorial › essential › io › pathOps.html
Path Operations (The Java™ Tutorials > Essential Java Classes > Basic I/O)
Perhaps a server is configured to save its log files in the "/dir/logs/." directory, and you want to delete the trailing "/." notation from the path. ... The normalize method removes any redundant elements, which includes any "." or "directory/.." occurrences.