| Constructor: |
|---|
 public URI(String uri) throws URISyntaxException {
new Helper().parseURI(uri, false);
}
Creates a new URI instance according to the given string {@code uri}. Parameters:
uri -
the textual URI representation to be parsed into a URI object.
URISyntaxException -
if the given string {@code uri} doesn't fit to the
specification RFC2396 or could not be parsed correctly.
|
public URI(String scheme,
String ssp,
String frag) throws URISyntaxException {
StringBuilder uri = new StringBuilder();
if (scheme != null) {
uri.append(scheme);
uri.append(':');
}
if (ssp != null) {
// QUOTE ILLEGAL CHARACTERS
uri.append(quoteComponent(ssp, allLegal));
}
if (frag != null) {
uri.append('#');
// QUOTE ILLEGAL CHARACTERS
uri.append(quoteComponent(frag, allLegal));
}
new Helper().parseURI(uri.toString(), false);
} Parameters:
scheme -
the scheme part of the URI.
ssp -
the scheme-specific-part of the URI.
frag -
the fragment part of the URI.
URISyntaxException -
if the temporary created string doesn't fit to the
specification RFC2396 or could not be parsed correctly.
|
public URI(String scheme,
String host,
String path,
String fragment) throws URISyntaxException {
this(scheme, null, host, -1, path, null, fragment);
} Parameters:
scheme -
the scheme part of the URI.
host -
the host name of the URI.
path -
the path to the resource on the host.
fragment -
the fragment part of the URI.
URISyntaxException -
if the temporary created string doesn't fit to the
specification RFC2396 or could not be parsed correctly.
|
public URI(String scheme,
String authority,
String path,
String query,
String fragment) throws URISyntaxException {
if (scheme != null && path != null && path.length() > 0
&& path.charAt(0) != '/') {
throw new URISyntaxException(path, Messages.getString("luni.82")); //$NON-NLS-1$
}
StringBuilder uri = new StringBuilder();
if (scheme != null) {
uri.append(scheme);
uri.append(':');
}
if (authority != null) {
uri.append("//"); //$NON-NLS-1$
// QUOTE ILLEGAL CHARS
uri.append(quoteComponent(authority, "@[]" + someLegal)); //$NON-NLS-1$
}
if (path != null) {
// QUOTE ILLEGAL CHARS
uri.append(quoteComponent(path, "/@" + someLegal)); //$NON-NLS-1$
}
if (query != null) {
// QUOTE ILLEGAL CHARS
uri.append('?');
uri.append(quoteComponent(query, allLegal));
}
if (fragment != null) {
// QUOTE ILLEGAL CHARS
uri.append('#');
uri.append(quoteComponent(fragment, allLegal));
}
new Helper().parseURI(uri.toString(), false);
} Parameters:
scheme -
the scheme part of the URI.
authority -
the authority part of the URI.
path -
the path to the resource on the host.
query -
the query part of the URI to specify parameters for the
resource.
fragment -
the fragment part of the URI.
URISyntaxException -
if the temporary created string doesn't fit to the
specification RFC2396 or could not be parsed correctly.
|
public URI(String scheme,
String userinfo,
String host,
int port,
String path,
String query,
String fragment) throws URISyntaxException {
if (scheme == null && userinfo == null && host == null && path == null
&& query == null && fragment == null) {
this.path = ""; //$NON-NLS-1$
return;
}
if (scheme != null && path != null && path.length() > 0
&& path.charAt(0) != '/') {
throw new URISyntaxException(path, Messages.getString("luni.82")); //$NON-NLS-1$
}
StringBuilder uri = new StringBuilder();
if (scheme != null) {
uri.append(scheme);
uri.append(':');
}
if (userinfo != null || host != null || port != -1) {
uri.append("//"); //$NON-NLS-1$
}
if (userinfo != null) {
// QUOTE ILLEGAL CHARACTERS in userinfo
uri.append(quoteComponent(userinfo, someLegal));
uri.append('@');
}
if (host != null) {
// check for ipv6 addresses that hasn't been enclosed
// in square brackets
if (host.indexOf(':') != -1 && host.indexOf(']') == -1
&& host.indexOf('[') == -1) {
host = "[" + host + "]"; //$NON-NLS-1$ //$NON-NLS-2$
}
uri.append(host);
}
if (port != -1) {
uri.append(':');
uri.append(port);
}
if (path != null) {
// QUOTE ILLEGAL CHARS
uri.append(quoteComponent(path, "/@" + someLegal)); //$NON-NLS-1$
}
if (query != null) {
uri.append('?');
// QUOTE ILLEGAL CHARS
uri.append(quoteComponent(query, allLegal));
}
if (fragment != null) {
// QUOTE ILLEGAL CHARS
uri.append('#');
uri.append(quoteComponent(fragment, allLegal));
}
new Helper().parseURI(uri.toString(), true);
} Parameters:
scheme -
the scheme part of the URI.
userinfo -
the user information of the URI for authentication and
authorization.
host -
the host name of the URI.
port -
the port number of the URI.
path -
the path to the resource on the host.
query -
the query part of the URI to specify parameters for the
resource.
fragment -
the fragment part of the URI.
URISyntaxException -
if the temporary created string doesn't fit to the
specification RFC2396 or could not be parsed correctly.
|
| Method from java.net.URI Detail: |
|---|
public int compareTo(URI uri) {
int ret = 0;
// compare schemes
if (scheme == null && uri.scheme != null) {
return -1;
} else if (scheme != null && uri.scheme == null) {
return 1;
} else if (scheme != null && uri.scheme != null) {
ret = scheme.compareToIgnoreCase(uri.scheme);
if (ret != 0) {
return ret;
}
}
// compare opacities
if (!opaque && uri.opaque) {
return -1;
} else if (opaque && !uri.opaque) {
return 1;
} else if (opaque && uri.opaque) {
ret = schemespecificpart.compareTo(uri.schemespecificpart);
if (ret != 0) {
return ret;
}
} else {
// otherwise both must be hierarchical
// compare authorities
if (authority != null && uri.authority == null) {
return 1;
} else if (authority == null && uri.authority != null) {
return -1;
} else if (authority != null && uri.authority != null) {
if (host != null && uri.host != null) {
// both are server based, so compare userinfo, host, port
if (userinfo != null && uri.userinfo == null) {
return 1;
} else if (userinfo == null && uri.userinfo != null) {
return -1;
} else if (userinfo != null && uri.userinfo != null) {
ret = userinfo.compareTo(uri.userinfo);
if (ret != 0) {
return ret;
}
}
// userinfo's are the same, compare hostname
ret = host.compareToIgnoreCase(uri.host);
if (ret != 0) {
return ret;
}
// compare port
if (port != uri.port) {
return port - uri.port;
}
} else { // one or both are registry based, compare the whole
// authority
ret = authority.compareTo(uri.authority);
if (ret != 0) {
return ret;
}
}
}
// authorities are the same
// compare paths
ret = path.compareTo(uri.path);
if (ret != 0) {
return ret;
}
// compare queries
if (query != null && uri.query == null) {
return 1;
} else if (query == null && uri.query != null) {
return -1;
} else if (query != null && uri.query != null) {
ret = query.compareTo(uri.query);
if (ret != 0) {
return ret;
}
}
}
// everything else is identical, so compare fragments
if (fragment != null && uri.fragment == null) {
return 1;
} else if (fragment == null && uri.fragment != null) {
return -1;
} else if (fragment != null && uri.fragment != null) {
ret = fragment.compareTo(uri.fragment);
if (ret != 0) {
return ret;
}
}
// identical
return 0;
} Compares this URI with the given argument {@code uri}. This method will
return a negative value if this URI instance is less than the given
argument and a positive value if this URI instance is greater than the
given argument. The return value {@code 0} indicates that the two
instances represent the same URI. To define the order the single parts of
the URI are compared with each other. String components will be orderer
in the natural case-sensitive way. A hierarchical URI is less than an
opaque URI and if one part is {@code null} the URI with the undefined
part is less than the other one. |
public static URI create(String uri) {
URI result = null;
try {
result = new URI(uri);
} catch (URISyntaxException e) {
throw new IllegalArgumentException(e.getMessage());
}
return result;
} Parses the given argument {@code uri} and creates an appropriate URI
instance. |
public boolean equals(Object o) {
if (!(o instanceof URI)) {
return false;
}
URI uri = (URI) o;
if (uri.fragment == null && fragment != null || uri.fragment != null
&& fragment == null) {
return false;
} else if (uri.fragment != null && fragment != null) {
if (!equalsHexCaseInsensitive(uri.fragment, fragment)) {
return false;
}
}
if (uri.scheme == null && scheme != null || uri.scheme != null
&& scheme == null) {
return false;
} else if (uri.scheme != null && scheme != null) {
if (!uri.scheme.equalsIgnoreCase(scheme)) {
return false;
}
}
if (uri.opaque && opaque) {
return equalsHexCaseInsensitive(uri.schemespecificpart,
schemespecificpart);
} else if (!uri.opaque && !opaque) {
if (!equalsHexCaseInsensitive(path, uri.path)) {
return false;
}
if (uri.query != null && query == null || uri.query == null
&& query != null) {
return false;
} else if (uri.query != null && query != null) {
if (!equalsHexCaseInsensitive(uri.query, query)) {
return false;
}
}
if (uri.authority != null && authority == null
|| uri.authority == null && authority != null) {
return false;
} else if (uri.authority != null && authority != null) {
if (uri.host != null && host == null || uri.host == null
&& host != null) {
return false;
} else if (uri.host == null && host == null) {
// both are registry based, so compare the whole authority
return equalsHexCaseInsensitive(uri.authority, authority);
} else { // uri.host != null && host != null, so server-based
if (!host.equalsIgnoreCase(uri.host)) {
return false;
}
if (port != uri.port) {
return false;
}
if (uri.userinfo != null && userinfo == null
|| uri.userinfo == null && userinfo != null) {
return false;
} else if (uri.userinfo != null && userinfo != null) {
return equalsHexCaseInsensitive(userinfo, uri.userinfo);
} else {
return true;
}
}
} else {
// no authority
return true;
}
} else {
// one is opaque, the other hierarchical
return false;
}
} Compares this URI instance with the given argument {@code o} and
determines if both are equal. Two URI instances are equal if all single
parts are identical in their meaning. |
public String getAuthority() {
return decode(authority);
} Gets the decoded authority part of this URI. |
public String getFragment() {
return decode(fragment);
} Gets the decoded fragment part of this URI. |
public String getHost() {
return host;
} Gets the host part of this URI. |
public String getPath() {
return decode(path);
} Gets the decoded path part of this URI. |
public int getPort() {
return port;
} Gets the port number of this URI. |
public String getQuery() {
return decode(query);
} Gets the decoded query part of this URI. |
public String getRawAuthority() {
return authority;
} Gets the authority part of this URI in raw form. |
public String getRawFragment() {
return fragment;
} Gets the fragment part of this URI in raw form. |
public String getRawPath() {
return path;
} Gets the path part of this URI in raw form. |
public String getRawQuery() {
return query;
} Gets the query part of this URI in raw form. |
public String getRawSchemeSpecificPart() {
return schemespecificpart;
} Gets the scheme-specific part of this URI in raw form. |
public String getRawUserInfo() {
return userinfo;
} Gets the user-info part of this URI in raw form. |
public String getScheme() {
return scheme;
} Gets the scheme part of this URI. |
public String getSchemeSpecificPart() {
return decode(schemespecificpart);
} Gets the decoded scheme-specific part of this URI. |
public String getUserInfo() {
return decode(userinfo);
} Gets the decoded user-info part of this URI. |
public int hashCode() {
if (hash == -1) {
hash = getHashString().hashCode();
}
return hash;
} Gets the hashcode value of this URI instance. |
public boolean isAbsolute() {
return absolute;
} Indicates whether this URI is absolute, which means that a scheme part is
defined in this URI. |
public boolean isOpaque() {
return opaque;
} Indicates whether this URI is opaque or not. An opaque URI is absolute
and has a scheme-specific part which does not start with a slash
character. All parts except scheme, scheme-specific and fragment are
undefined. |
public URI normalize() {
if (opaque) {
return this;
}
String normalizedPath = normalize(path);
// if the path is already normalized, return this
if (path.equals(normalizedPath)) {
return this;
}
// get an exact copy of the URI re-calculate the scheme specific part
// since the path of the normalized URI is different from this URI.
URI result = duplicate();
result.path = normalizedPath;
result.setSchemeSpecificPart();
return result;
} Normalizes the path part of this URI. |
public URI parseServerAuthority() throws URISyntaxException {
if (!serverAuthority) {
new Helper().parseAuthority(true);
}
return this;
} Tries to parse the authority component of this URI to divide it into the
host, port, and user-info. If this URI is already determined as a
ServerAuthority this instance will be returned without changes. |
public URI relativize(URI relative) {
if (relative.opaque || opaque) {
return relative;
}
if (scheme == null ? relative.scheme != null : !scheme
.equals(relative.scheme)) {
return relative;
}
if (authority == null ? relative.authority != null : !authority
.equals(relative.authority)) {
return relative;
}
// normalize both paths
String thisPath = normalize(path);
String relativePath = normalize(relative.path);
/*
* if the paths aren't equal, then we need to determine if this URI's
* path is a parent path (begins with) the relative URI's path
*/
if (!thisPath.equals(relativePath)) {
// if this URI's path doesn't end in a '/', add one
if (!thisPath.endsWith("/")) { //$NON-NLS-1$
thisPath = thisPath + '/';
}
/*
* if the relative URI's path doesn't start with this URI's path,
* then just return the relative URI; the URIs have nothing in
* common
*/
if (!relativePath.startsWith(thisPath)) {
return relative;
}
}
URI result = new URI();
result.fragment = relative.fragment;
result.query = relative.query;
// the result URI is the remainder of the relative URI's path
result.path = relativePath.substring(thisPath.length());
result.setSchemeSpecificPart();
return result;
} Makes the given URI {@code relative} to a relative URI against the URI
represented by this instance. |
public URI resolve(URI relative) {
if (relative.absolute || opaque) {
return relative;
}
URI result;
if (relative.path.equals("") && relative.scheme == null //$NON-NLS-1$
&& relative.authority == null && relative.query == null
&& relative.fragment != null) {
// if the relative URI only consists of fragment,
// the resolved URI is very similar to this URI,
// except that it has the fragement from the relative URI.
result = duplicate();
result.fragment = relative.fragment;
// no need to re-calculate the scheme specific part,
// since fragment is not part of scheme specific part.
return result;
}
if (relative.authority != null) {
// if the relative URI has authority,
// the resolved URI is almost the same as the relative URI,
// except that it has the scheme of this URI.
result = relative.duplicate();
result.scheme = scheme;
result.absolute = absolute;
} else {
// since relative URI has no authority,
// the resolved URI is very similar to this URI,
// except that it has the query and fragment of the relative URI,
// and the path is different.
result = duplicate();
result.fragment = relative.fragment;
result.query = relative.query;
if (relative.path.startsWith("/")) { //$NON-NLS-1$
result.path = relative.path;
} else {
// resolve a relative reference
int endindex = path.lastIndexOf('/') + 1;
result.path = normalize(path.substring(0, endindex)
+ relative.path);
}
// re-calculate the scheme specific part since
// query and path of the resolved URI is different from this URI.
result.setSchemeSpecificPart();
}
return result;
} Resolves the given URI {@code relative} against the URI represented by
this instance. |
public URI resolve(String relative) {
return resolve(create(relative));
} Creates a new URI instance by parsing the given string {@code relative}
and resolves the created URI against the URI represented by this
instance. |
public String toASCIIString() {
return encodeOthers(toString());
} Returns the textual string representation of this URI instance using the
US-ASCII encoding. |
public String toString() {
if (string == null) {
StringBuilder result = new StringBuilder();
if (scheme != null) {
result.append(scheme);
result.append(':');
}
if (opaque) {
result.append(schemespecificpart);
} else {
if (authority != null) {
result.append("//"); //$NON-NLS-1$
result.append(authority);
}
if (path != null) {
result.append(path);
}
if (query != null) {
result.append('?');
result.append(query);
}
}
if (fragment != null) {
result.append('#');
result.append(fragment);
}
string = result.toString();
}
return string;
} Returns the textual string representation of this URI instance. |
public URL toURL() throws MalformedURLException {
if (!absolute) {
throw new IllegalArgumentException(Messages.getString("luni.91") + ": " //$NON-NLS-1$//$NON-NLS-2$
+ toString());
}
return new URL(toString());
} Converts this URI instance to a URL. |
java.net.URI
Save This Page