public String canonizeString(String file) 
{
        int i = 0;
        int lim = file.length();
        // Remove embedded /../
        while ((i = file.indexOf("/../"))  >= 0) {
            if ((lim = file.lastIndexOf('/', i - 1))  >= 0) {
                file = file.substring(0, lim) + file.substring(i + 3);
            } else {
                file = file.substring(i + 3);
            }
        }
        // Remove embedded /./
        while ((i = file.indexOf("/./"))  >= 0) {
            file = file.substring(0, i) + file.substring(i + 2);
        }
        // Remove trailing ..
        while (file.endsWith("/..")) {
            i = file.indexOf("/..");
            if ((lim = file.lastIndexOf('/', i - 1))  >= 0) {
                file = file.substring(0, lim+1);
            } else {
                file = file.substring(0, i);
            }
        }
        // Remove trailing .
        if (file.endsWith("/."))
            file = file.substring(0, file.length() -1);
        return file;
}

Returns a canonical version of the specified string.

 public static String decode(String s) 
{
        int n = s.length();
        if ((n == 0) || (s.indexOf('%') <  0))
            return s;
        StringBuilder sb = new StringBuilder(n);
        ByteBuffer bb = ByteBuffer.allocate(n);
        CharBuffer cb = CharBuffer.allocate(n);
        CharsetDecoder dec = ThreadLocalCoders.decoderFor("UTF-8")
            .onMalformedInput(CodingErrorAction.REPORT)
            .onUnmappableCharacter(CodingErrorAction.REPORT);
        char c = s.charAt(0);
        for (int i = 0; i <  n;) {
            assert c == s.charAt(i);
            if (c != '%') {
                sb.append(c);
                if (++i  >= n)
                    break;
                c = s.charAt(i);
                continue;
            }
            bb.clear();
            int ui = i;
            for (;;) {
                assert (n - i  >= 2);
                try {
                    bb.put(unescape(s, i));
                } catch (NumberFormatException e) {
                    throw new IllegalArgumentException();
                }
                i += 3;
                if (i  >= n)
                    break;
                c = s.charAt(i);
                if (c != '%')
                    break;
            }
            bb.flip();
            cb.clear();
            dec.reset();
            CoderResult cr = dec.decode(bb, cb, true);
            if (cr.isError())
                throw new IllegalArgumentException("Error decoding percent encoded characters");
            cr = dec.flush(cb);
            if (cr.isError())
                throw new IllegalArgumentException("Error decoding percent encoded characters");
            sb.append(cb.flip().toString());
        }
        return sb.toString();
}

Returns a new String constructed from the specified String by replacing the URL escape sequences and UTF8 encoding with the characters they represent.

 public static String encodePath(String path) 
{
        return encodePath(path, true);
}

Constructs an encoded version of the specified path string suitable for use in the construction of a URL. A path separator is replaced by a forward slash. The string is UTF8 encoded. The % escape sequence is used for characters that are above 0x7F or those defined in RFC2396 as reserved or excluded in the path component of a URL.

 public static String encodePath(String path,
    boolean flag) 
{
        char[] retCC = new char[path.length() * 2 + 16];
        int    retLen = 0;
        char[] pathCC = path.toCharArray();
        int n = path.length();
        for (int i=0; i< n; i++) {
            char c = pathCC[i];
            if ((!flag && c == '/') || (flag && c == File.separatorChar))
                retCC[retLen++] = '/';
            else {
                if (c < = 0x007F) {
                    if (c  >= 'a' && c < = 'z' ||
                        c  >= 'A' && c < = 'Z' ||
                        c  >= '0' && c < = '9') {
                        retCC[retLen++] = c;
                    } else
                    if (encodedInPath.get(c))
                        retLen = escape(retCC, c, retLen);
                    else
                        retCC[retLen++] = c;
                } else if (c  > 0x07FF) {
                    retLen = escape(retCC, (char)(0xE0 | ((c  > > 12) & 0x0F)), retLen);
                    retLen = escape(retCC, (char)(0x80 | ((c  > >  6) & 0x3F)), retLen);
                    retLen = escape(retCC, (char)(0x80 | ((c  > >  0) & 0x3F)), retLen);
                } else {
                    retLen = escape(retCC, (char)(0xC0 | ((c  > >  6) & 0x1F)), retLen);
                    retLen = escape(retCC, (char)(0x80 | ((c  > >  0) & 0x3F)), retLen);
                }
            }
            //worst case scenario for character [0x7ff-] every single
            //character will be encoded into 9 characters.
            if (retLen + 9  > retCC.length) {
                int newLen = retCC.length * 2 + 16;
                if (newLen <  0) {
                    newLen = Integer.MAX_VALUE;
                }
                char[] buf = new char[newLen];
                System.arraycopy(retCC, 0, buf, 0, retLen);
                retCC = buf;
            }
        }
        return new String(retCC, 0, retLen);
}

 public static URL fileToEncodedURL(File file) throws MalformedURLException 
{
        String path = file.getAbsolutePath();
        path = ParseUtil.encodePath(path);
        if (!path.startsWith("/")) {
            path = "/" + path;
        }
        if (!path.endsWith("/") && file.isDirectory()) {
            path = path + "/";
        }
        return new URL("file", "", path);
}

 public static URI toURI(URL url) 
{
        String protocol = url.getProtocol();
        String auth = url.getAuthority();
        String path = url.getPath();
        String query = url.getQuery();
        String ref = url.getRef();
        if (path != null && !(path.startsWith("/")))
            path = "/" + path;
        //
        // In java.net.URI class, a port number of -1 implies the default
        // port number. So get it stripped off before creating URI instance.
        //
        if (auth != null && auth.endsWith(":-1"))
            auth = auth.substring(0, auth.length() - 3);
        java.net.URI uri;
        try {
            uri = createURI(protocol, auth, path, query, ref);
        } catch (java.net.URISyntaxException e) {
            uri = null;
        }
        return uri;
}