Java Convert via ByteBuffer toFile(URL url)

Description

Convert from a URL to a File.

License

Open Source License

Parameter

Parameter	Description
url	the file URL to convert, <code>null</code> returns <code>null</code>

Return

the equivalent File object, or null if the URL's protocol is not file

Declaration

public static File toFile(URL url) 

Method Source Code

//package com.java2s;
//License from project: Open Source License 

import java.io.File;

import java.net.URL;

import java.nio.ByteBuffer;

import java.nio.charset.Charset;

public class Main {
    /** The UTF-8 character set, used to decode octets in URLs. */
    private static final Charset UTF8 = Charset.forName("UTF-8");

    /**//from  w w w  .  j  av a  2 s .c  o m
     * Convert from a <code>URL</code> to a <code>File</code>.
     * <p>
     * From version 1.1 this method will decode the URL. Syntax such as
     * <code>file:///my%20docs/file.txt</code> will be correctly decoded to
     * <code>/my docs/file.txt</code>. Starting with version 1.5, this method uses
     * UTF-8 to decode percent-encoded octets to characters. Additionally, malformed
     * percent-encoded octets are handled leniently by passing them through
     * literally.
     * @param url the file URL to convert, <code>null</code> returns
     *        <code>null</code>
     * @return the equivalent <code>File</code> object, or <code>null</code> if the
     *         URL's protocol is not <code>file</code>
     */
    public static File toFile(URL url) {
        if (url == null || !"file".equalsIgnoreCase(url.getProtocol())) {
            return null;
        } else {
            String filename = url.getFile().replace('/', File.separatorChar);
            filename = decodeUrl(filename);
            return new File(filename);
        }
    }

    /**
     * Decodes the specified URL as per RFC 3986, i.e. transforms percent-encoded
     * octets to characters by decoding with the UTF-8 character set. This function
     * is primarily intended for usage with {@link java.net.URL} which unfortunately
     * does not enforce proper URLs. As such, this method will leniently accept
     * invalid characters or malformed percent-encoded octets and simply pass them
     * literally through to the result string. Except for rare edge cases, this will
     * make unencoded URLs pass through unaltered.
     * @param url The URL to decode, may be <code>null</code>.
     * @return The decoded URL or <code>null</code> if the input was
     *         <code>null</code>.
     */
    static String decodeUrl(String url) {
        String decoded = url;
        if (url != null && url.indexOf('%') >= 0) {
            int n = url.length();
            StringBuffer buffer = new StringBuffer();
            ByteBuffer bytes = ByteBuffer.allocate(n);
            for (int i = 0; i < n;) {
                if (url.charAt(i) == '%') {
                    try {
                        do {
                            byte octet = (byte) Integer.parseInt(url.substring(i + 1, i + 3), 16);
                            bytes.put(octet);
                            i += 3;
                        } while (i < n && url.charAt(i) == '%');
                        continue;
                    } catch (RuntimeException e) {
                        // malformed percent-encoded octet, fall through and
                        // append characters literally
                    } finally {
                        if (bytes.position() > 0) {
                            bytes.flip();
                            buffer.append(UTF8.decode(bytes).toString());
                            bytes.clear();
                        }
                    }
                }
                buffer.append(url.charAt(i++));
            }
            decoded = buffer.toString();
        }
        return decoded;
    }
}

Related

1. toChars(byte[] bytes)
2. toChars(byte[] bytes)
3. toChars(byte[] bytes)
4. toDirectBuffer(String s)
5. toDoubleArray(byte[] data)
6. toFile(URL url)
7. toFiles(URL[] urls)
8. toFloat(byte[] bytes)
9. toFloat(final byte[] b)