public URL(String spec) throws MalformedURLException 
{
        this((URL) null, spec, (URLStreamHandler) null);
}

Creates a new URL instance by parsing the string {@code spec}.

Parameters:

spec - the URL string representation which has to be parsed.

Throws:

MalformedURLException - if the given string {@code spec} could not be parsed as a URL.

 public URL(URL context,
    String spec) throws MalformedURLException 
{
        this(context, spec, (URLStreamHandler) null);
}

Creates a new URL to the specified resource {@code spec}. This URL is relative to the given {@code context}. If the protocol of the parsed URL does not match with the protocol of the context URL, then the newly created URL is absolute and bases only on the given URL represented by {@code spec}. Otherwise the protocol is defined by the context URL.

Parameters:

context - the URL which is used as the context.

spec - the URL string representation which has to be parsed.

Throws:

MalformedURLException - if the given string {@code spec} could not be parsed as a URL or an invalid protocol has been found.

 public URL(URL context,
    String spec,
    URLStreamHandler handler) throws MalformedURLException 
{
        if (handler != null) {
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                sm.checkPermission(specifyStreamHandlerPermission);
            }
            strmHandler = handler;
        }
        if (spec == null) {
            throw new MalformedURLException();
        }
        spec = spec.trim();
        // The spec includes a protocol if it includes a colon character
        // before the first occurrence of a slash character. Note that,
        // "protocol" is the field which holds this URLs protocol.
        int index;
        try {
            index = spec.indexOf(':');
        } catch (NullPointerException e) {
            throw new MalformedURLException(e.toString());
        }
        int startIPv6Addr = spec.indexOf('[');
        if (index  >= 0) {
            if ((startIPv6Addr == -1) || (index <  startIPv6Addr)) {
                protocol = spec.substring(0, index);
                // According to RFC 2396 scheme part should match
                // the following expression:
                // alpha *( alpha | digit | "+" | "-" | "." )
                char c = protocol.charAt(0);
                boolean valid = ('a' < = c && c < = 'z') || ('A' < = c && c < = 'Z');
                for (int i = 1; valid && (i <  protocol.length()); i++) {
                    c = protocol.charAt(i);
                    valid = ('a' < = c && c < = 'z') ||
                            ('A' < = c && c < = 'Z') ||
                            ('0' < = c && c < = '9') ||
                            (c == '+') ||
                            (c == '-') ||
                            (c == '.');
                }
                if (!valid) {
                    protocol = null;
                    index = -1;
                } else {
                    // Ignore case in protocol names.
                	// Scheme is defined by ASCII characters.
                    protocol = Util.toASCIILowerCase(protocol);
                }
            }
        }
        if (protocol != null) {
            // If the context was specified, and it had the same protocol
            // as the spec, then fill in the receiver's slots from the values
            // in the context but still allow them to be over-ridden later
            // by the values in the spec.
            if (context != null && protocol.equals(context.getProtocol())) {
                String cPath = context.getPath();
                if (cPath != null && cPath.startsWith("/")) { //$NON-NLS-1$
                    set(protocol, context.getHost(), context.getPort(), context
                            .getAuthority(), context.getUserInfo(), cPath,
                            context.getQuery(), null);
                }
                if (strmHandler == null) {
                    strmHandler = context.strmHandler;
                }
            }
        } else {
            // If the spec did not include a protocol, then the context
            // *must* be specified. Fill in the receiver's slots from the
            // values in the context, but still allow them to be over-ridden
            // by the values in the ("relative") spec.
            if (context == null) {
                throw new MalformedURLException(
                        Messages.getString(
                                "luni.9B", spec)); //$NON-NLS-1$
            }
            set(context.getProtocol(), context.getHost(), context.getPort(),
                    context.getAuthority(), context.getUserInfo(), context
                            .getPath(), context.getQuery(), null);
            if (strmHandler == null) {
                strmHandler = context.strmHandler;
            }
        }
        // If the stream handler has not been determined, set it
        // to the default for the specified protocol.
        if (strmHandler == null) {
            setupStreamHandler();
            if (strmHandler == null) {
                throw new MalformedURLException(
                        Messages.getString(
                                "luni.9C", protocol)); //$NON-NLS-1$
            }
        }
        // Let the handler parse the URL. If the handler throws
        // any exception, throw MalformedURLException instead.
        //
        // Note: We want "index" to be the index of the start of the scheme
        // specific part of the URL. At this point, it will be either
        // -1 or the index of the colon after the protocol, so we
        // increment it to point at either character 0 or the character
        // after the colon.
        try {
            strmHandler.parseURL(this, spec, ++index, spec.length());
        } catch (Exception e) {
            throw new MalformedURLException(e.toString());
        }
        if (port <  -1) {
            throw new MalformedURLException(Messages
                    .getString("luni.56", port)); //$NON-NLS-1$
        }
}

Creates a new URL to the specified resource {@code spec}. This URL is relative to the given {@code context}. The {@code handler} will be used to parse the URL string representation. If this argument is {@code null} the default {@code URLStreamHandler} will be used. If the protocol of the parsed URL does not match with the protocol of the context URL, then the newly created URL is absolute and bases only on the given URL represented by {@code spec}. Otherwise the protocol is defined by the context URL.

Parameters:

context - the URL which is used as the context.

spec - the URL string representation which has to be parsed.

handler - the specific stream handler to be used by this URL.

Throws:

MalformedURLException - if the given string {@code spec} could not be parsed as a URL or an invalid protocol has been found.

 public URL(String protocol,
    String host,
    String file) throws MalformedURLException 
{
        this(protocol, host, -1, file, (URLStreamHandler) null);
}

Creates a new URL instance using the given arguments. The URL uses the default port for the specified protocol.

Parameters:

protocol - the protocol of the new URL.

host - the host name or IP address of the new URL.

file - the name of the resource.

Throws:

MalformedURLException - if the combination of all arguments do not represent a valid URL or the protocol is invalid.

 public URL(String protocol,
    String host,
    int port,
    String file) throws MalformedURLException 
{
        this(protocol, host, port, file, (URLStreamHandler) null);
}

Creates a new URL instance using the given arguments. The URL uses the specified port instead of the default port for the given protocol.

Parameters:

protocol - the protocol of the new URL.

host - the host name or IP address of the new URL.

port - the specific port number of the URL. {@code -1} represents the default port of the protocol.

file - the name of the resource.

Throws:

MalformedURLException - if the combination of all arguments do not represent a valid URL or the protocol is invalid.

 public URL(String protocol,
    String host,
    int port,
    String file,
    URLStreamHandler handler) throws MalformedURLException 
{
        if (port <  -1) {
            throw new MalformedURLException(Messages.getString("luni.56", port)); //$NON-NLS-1$
        }
        if (host != null && host.indexOf(":") != -1 && host.charAt(0) != '[') { //$NON-NLS-1$
            host = "[" + host + "]"; //$NON-NLS-1$ //$NON-NLS-2$
        }
        if (protocol == null) {
            throw new NullPointerException(Messages.getString("luni.9C", "null")); //$NON-NLS-1$ //$NON-NLS-2$
        }
        this.protocol = protocol;
        this.host = host;
        this.port = port;
        // Set the fields from the arguments. Handle the case where the
        // passed in "file" includes both a file and a reference part.
        int index = -1;
        index = file.indexOf("#", file.lastIndexOf("/")); //$NON-NLS-1$ //$NON-NLS-2$
        if (index  >= 0) {
            this.file = file.substring(0, index);
            ref = file.substring(index + 1);
        } else {
            this.file = file;
        }
        fixURL(false);
        // Set the stream handler for the URL either to the handler
        // argument if it was specified, or to the default for the
        // receiver's protocol if the handler was null.
        if (handler == null) {
            setupStreamHandler();
            if (strmHandler == null) {
                throw new MalformedURLException(
                        Messages.getString("luni.9C", protocol)); //$NON-NLS-1$
            }
        } else {
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                sm.checkPermission(specifyStreamHandlerPermission);
            }
            strmHandler = handler;
        }
}

Creates a new URL instance using the given arguments. The URL uses the specified port instead of the default port for the given protocol.

Parameters:

protocol - the protocol of the new URL.

host - the host name or IP address of the new URL.

port - the specific port number of the URL. {@code -1} represents the default port of the protocol.

file - the name of the resource.

handler - the stream handler to be used by this URL.

Throws:

MalformedURLException - if the combination of all arguments do not represent a valid URL or the protocol is invalid.

SecurityException - if {@code handler} is non-{@code null}, and a security manager is installed that disallows user-defined protocol handlers.

 public boolean equals(Object o) 
{
        if (o == null) {
            return false;
        }
        if (this == o) {
            return true;
        }
        if (this.getClass() != o.getClass()) {
            return false;
        }
        return strmHandler.equals(this, (URL) o);
}

Compares this URL instance with the given argument {@code o} and determines if both are equal. Two URL instances are equal if all single parts are identical in their meaning. Compares the argument to the receiver, and returns true if they represent the same URL. Two URLs are equal if they have the same file, host, port, protocol, and reference components.

  void fixURL(boolean fixHost) 
{
        int index;
        if (host != null && host.length()  > 0) {
            authority = host;
            if (port != -1) {
                authority = authority + ":" + port; //$NON-NLS-1$
            }
        }
        if (fixHost) {
            if (host != null && (index = host.lastIndexOf('@'))  > -1) {
                userInfo = host.substring(0, index);
                host = host.substring(index + 1);
            } else {
                userInfo = null;
            }
        }
        if (file != null && (index = file.indexOf('?'))  > -1) {
            query = file.substring(index + 1);
            path = file.substring(0, index);
        } else {
            query = null;
            path = file;
        }
}

 public String getAuthority() 
{
        return authority;
}

Gets the value of the authority part of this URL.

 public final Object getContent() throws IOException 
{
        return openConnection().getContent();
}

Gets the content of the resource which is referred by this URL. By default one of the following object types will be returned:
• Image for pictures
• AudioClip for audio sequences
• InputStream for all other data

 public final Object getContent(Class[] types) throws IOException 
{
        return openConnection().getContent(types);
}

Gets the content of the resource which is referred by this URL. The argument {@code types} is an array of allowed or expected object types. {@code null} will be returned if the obtained object type does not match with one from this list. Otherwise the first type that matches will be used.

 public int getDefaultPort() 
{
        return strmHandler.getDefaultPort();
}

Gets the default port number of the protocol used by this URL. If no default port is defined by the protocol or the {@code URLStreamHandler}, {@code -1} will be returned.

 public String getFile() 
{
        return file;
}

Gets the value of the file part of this URL.

 public String getHost() 
{
        return host;
}

Gets the value of the host part of this URL.

 public String getPath() 
{
        return path;
}

Gets the value of the path part of this URL.

 public int getPort() 
{
        return port;
}

Gets the port number of this URL or {@code -1} if the port is not set.

 public String getProtocol() 
{
        return protocol;
}

Gets the protocol of this URL.

 public String getQuery() 
{
        return query;
}

Gets the value of the query part of this URL.

 public String getRef() 
{
        return ref;
}

Gets the value of the reference part of this URL.

 public String getUserInfo() 
{
        return userInfo;
}

Gets the value of the user-info part of this URL.

 public int hashCode() 
{
        if (hashCode == 0) {
            hashCode = strmHandler.hashCode(this);
        }
        return hashCode;
}

Gets the hashcode value of this URL instance.

 public URLConnection openConnection() throws IOException 
{
        return strmHandler.openConnection(this);
}

Opens a connection to the remote resource specified by this URL. This connection allows bidirectional data transfer.

 public URLConnection openConnection(Proxy proxy) throws IOException 
{
        if (proxy == null) {
            // luni.9D=proxy should not be null
            throw new IllegalArgumentException(Messages.getString("luni.9D")); //$NON-NLS-1$
        }
        SecurityManager sm = System.getSecurityManager();
        if (sm != null && proxy.type() != Proxy.Type.DIRECT) {
            InetSocketAddress pAddress = (InetSocketAddress) proxy.address();
            String pHostName = pAddress.isUnresolved() ? pAddress.getHostName()
                    : pAddress.getAddress().getHostAddress();
            sm.checkConnect(pHostName, pAddress.getPort());
        }
        return strmHandler.openConnection(this, proxy);
}

Opens a connection to the remote resource specified by this URL. The connection will be established through the given proxy and allows bidirectional data transfer.

 public final InputStream openStream() throws IOException 
{
        return openConnection().getInputStream();
}

Opens an InputStream to read the resource referred by this URL.

 public boolean sameFile(URL otherURL) 
{
        return strmHandler.sameFile(this, otherURL);
}

Returns whether this URL refers to the same resource as the given argument {@code otherURL}. All URL components except the reference field are compared.

 protected  void set(String protocol,
    String host,
    int port,
    String file,
    String ref) 
{
        if (this.protocol == null) {
            this.protocol = protocol;
        }
        this.host = host;
        this.file = file;
        this.port = port;
        this.ref = ref;
        hashCode = 0;
        fixURL(true);
}

Sets the properties of this URL using the provided arguments. Only a {@code URLStreamHandler} can use this method to set fields of the existing URL instance. A URL is generally constant.

 protected  void set(String protocol,
    String host,
    int port,
    String authority,
    String userInfo,
    String path,
    String query,
    String ref) 
{
        String filePart = path;
        if (query != null && !query.equals("")) { //$NON-NLS-1$
            if (filePart != null) {
                filePart = filePart + "?" + query; //$NON-NLS-1$
            } else {
                filePart = "?" + query; //$NON-NLS-1$
            }
        }
        set(protocol, host, port, filePart, ref);
        this.authority = authority;
        this.userInfo = userInfo;
        this.path = path;
        this.query = query;
}

Sets the properties of this URL using the provided arguments. Only a {@code URLStreamHandler} can use this method to set fields of the existing URL instance. A URL is generally constant.

 public static synchronized  void setURLStreamHandlerFactory(URLStreamHandlerFactory streamFactory) 
{
        if (streamHandlerFactory != null) {
            throw new Error(Messages.getString("luni.9A")); //$NON-NLS-1$
        }
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkSetFactory();
        }
        streamHandlers.clear();
        streamHandlerFactory = streamFactory;
}

Sets the {@code URLStreamHandlerFactory} which creates protocol specific stream handlers. This method can be invoked only once during an application's lifetime. If the {@code URLStreamHandlerFactory} is already set an Error will be thrown.

A security check is performed to verify whether the current policy allows to set the stream handler factory.

  void setupStreamHandler() 
{
        // Check for a cached (previously looked up) handler for
        // the requested protocol.
        strmHandler = streamHandlers.get(protocol);
        if (strmHandler != null) {
            return;
        }
        // If there is a stream handler factory, then attempt to
        // use it to create the handler.
        if (streamHandlerFactory != null) {
            strmHandler = streamHandlerFactory.createURLStreamHandler(protocol);
            if (strmHandler != null) {
                streamHandlers.put(protocol, strmHandler);
                return;
            }
        }
        // Check if there is a list of packages which can provide handlers.
        // If so, then walk this list looking for an applicable one.
        String packageList = AccessController
                .doPrivileged(new PriviAction< String >(
                        "java.protocol.handler.pkgs")); //$NON-NLS-1$
        if (packageList != null) {
            StringTokenizer st = new StringTokenizer(packageList, "|"); //$NON-NLS-1$
            while (st.hasMoreTokens()) {
                String className = st.nextToken() + "." + protocol + ".Handler"; //$NON-NLS-1$ //$NON-NLS-2$
                try {
                    strmHandler = (URLStreamHandler) Class.forName(className,
                            true, ClassLoader.getSystemClassLoader())
                            .newInstance();
                    if (strmHandler != null) {
                        streamHandlers.put(protocol, strmHandler);
                    }
                    return;
                } catch (IllegalAccessException e) {
                } catch (InstantiationException e) {
                } catch (ClassNotFoundException e) {
                }
            }
        }
        // No one else has provided a handler, so try our internal one.
        String className = "org.apache.harmony.luni.internal.net.www.protocol." + protocol //$NON-NLS-1$
                + ".Handler"; //$NON-NLS-1$
        try {
            strmHandler = (URLStreamHandler) Class.forName(className)
                    .newInstance();
        } catch (IllegalAccessException e) {
        } catch (InstantiationException e) {
        } catch (ClassNotFoundException e) {
        }
        if (strmHandler != null) {
            streamHandlers.put(protocol, strmHandler);
        }
}

Sets the receiver's stream handler to one which is appropriate for its protocol. Throws a MalformedURLException if no reasonable handler is available.

Note that this will overwrite any existing stream handler with the new one. Senders must check if the strmHandler is null before calling the method if they do not want this behavior (a speed optimization).

 public String toExternalForm() 
{
        if (strmHandler == null) {
            return "unknown protocol(" + protocol + ")://" + host + file; //$NON-NLS-1$ //$NON-NLS-2$
        }
        return strmHandler.toExternalForm(this);
}

Returns a string containing a concise, human-readable representation of this URL.

 public String toString() 
{
        return toExternalForm();
}

Returns a string containing a concise, human-readable representation of this URL. The returned string is the same as the result of the method {@code toExternalForm()}.

 public URI toURI() throws URISyntaxException 
{
        return new URI(toExternalForm());
}

Converts this URL instance into an equivalent URI object.