实现的所有接口

Serializable ， Comparable<URI>
```
public final class URIextends Objectimplements Comparable<URI>, Serializable
```
表示统一资源标识符（URI）引用。
除了下面指出的一些微小偏差，这个类的一个实例表示由所定义的URI引用RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax ，通过修正RFC 2732: Format for Literal IPv6 Addresses in URLs 。 Literal IPv6地址格式也支持scope_ids。 scope_ids的语法和用法描述于here 。此类提供构造函数，用于从其组件创建URI实例，或者通过解析其字符串形式，访问实例的各个组件的方法以及规范化，解析和重新激活URI实例的方法。此类的实例是不可变的。

URI语法和组件
在最高级别，字符串形式的URI引用（下文中简称为“URI”）具有语法
[ scheme :] scheme-specific-part[ # fragment]
方括号[...]描绘可选组件，字符:和#代表自己。
绝对 URI指定方案; 一个非绝对的URI被认为是相对的 。 URI也根据它们是不透明还是分层来分类。

不透明 URI是绝对URI，其特定于方案的部分不以斜杠字符开头（ '/' ）。不透明的URI不需要进一步解析。不透明URI的一些示例是：
- mailto:[email protected]
- news:comp.lang.java
- urn:isbn:096139210x
分层 URI是绝对URI，其特定于方案的部分以斜杠字符开头，或者是相对URI，即不指定方案的URI。分层URI的一些示例是：

http://example.com/languages/java/
sample/a/index.html#28
../../demo/b/index.html
file:///~/calendar

分层URI根据语法进行进一步解析

[ scheme :][ // authority][ path][ ? query][ # fragment]
里的人物: ， / ， ?和#代表它们自身。分层URI的特定于方案的部分由方案和片段组件之间的字符组成。
如果指定，则分层URI的授权组件可以是基于服务器的 ，也可以是基于 注册表的 。基于服务器的权限根据熟悉的语法进行解析

[ user-info @] host[ : port]
其中人物@和:代表自己。目前使用的几乎所有URI方案都是基于服务器的。不以这种方式解析的权限组件被认为是基于注册表的。
如果以斜杠字符开头，则分层URI的路径组件本身被认为是绝对的（ '/' ）; 否则它是相对的。绝对或分配权限的分层URI的路径始终是绝对的。

总而言之，URI实例具有以下九个组件：
Describes the components of a URI:scheme,scheme-specific-part,authority,user-info,host,port,path,query,fragment Component Type scheme String scheme-specific-part String authority String user-info String host String port int path String query String fragment String

在给定的实例中，任何特定组件未定义或使用不同的值定义。未定义的字符串组件由null表示，而未定义的整数组件由-1表示。可以将字符串组件定义为将空字符串作为其值; 这不等于未定义的组件。
是否在实例中定义特定组件取决于所表示的URI的类型。绝对URI具有方案组件。不透明URI具有方案，方案特定部分，可能还有片段，但没有其他组件。分层URI总是具有路径（尽管它可以是空的）和特定于方案的部分（至少包含路径），并且可以具有任何其他组件。如果授权组件存在且基于服务器，则将定义主机组件并且可以定义用户信息和端口组件。

URI实例的操作
此类支持的关键操作是规范化 ，解析和相对化 。
规范化是从分层URI的路径组件中删除不必要的"."和".."段的过程。每个"."段都被删除。甲".."如果它是由非前面段仅除去".."段。规范化对不透明URI没有影响。

解决方案是将一个URI与另一个基本 URI解析的过程。生成的URI以RFC 2396指定的方式从两个URI的组件构造，从基URI中获取未在原始URI中指定的组件。对于分层URI，原始路径将根据基础路径进行解析，然后进行规范化。结果，例如，解决

sample/a/index.html#28                  (1)
对基础URI http://example.com/languages/java/是结果URI
http://example.com/languages/java/sample/a/index.html#28
解析相对URI
../../demo/b/index.html    (2)
反对这个结果，反过来，
http://example.com/languages/java/demo/b/index.html
支持绝对和相对URI的解析，以及分层URI的绝对和相对路径的解析。针对任何其他URI解析URI file:///~calendar只会产生原始URI，因为它是绝对的。根据相对基URI（1）解析上面的相对URI（2）会产生规范化但仍然相对的URI
demo/b/index.html

最后， 相对化是解决方案的反转：对于任何两个规范化的URI u和v ，

u .relativize( u .resolve( v )).equals( v )  and
u .resolve( u .relativize( v )).equals( v )  .

在构造包含必须相对于文档的基URI的URI的文档时，此操作通常很有用。例如，重新激活URI
http://example.com/languages/java/sample/a/index.html#28
针对基URI
http://example.com/languages/java/
产生相对URI sample/a/index.html#28 。
人物类别
RFC 2396精确指定URI引用的各个组件中允许哪些字符。以下类别（大部分取自该规范）在下面用于描述这些约束： Describes categories alpha,digit,alphanum,unreserved,punct,reserved,escaped,and other Category Description alpha The US-ASCII alphabetic characters, 'A' through 'Z' and 'a' through 'z' digit The US-ASCII decimal digit characters, '0' through '9' alphanum All alpha and digit characters unreserved All alphanum characters together with those in the string "_-!.~'()*" punct The characters in the string ",;:$&+=" reserved All punct characters together with those in the string "?/[]@" escaped Escaped octets, that is, triplets consisting of the percent character ('%') followed by two hexadecimal digits ('0'-'9', 'A'-'F', and 'a'-'f') other The Unicode characters that are not in the US-ASCII character set, are not control characters (according to the Character.isISOControl method), and are not space characters (according to the Character.isSpaceChar method)  (Deviation from RFC 2396, which is limited to US-ASCII)

所有合法URI字符集由未保留 ，保留，转义和其他字符组成。

转义的八位字节，引用，编码和解码
RFC 2396允许转义的八位字节出现在用户信息，路径，查询和片段组件中。转义在URI中有两个用途：
- 当需要URI严格遵守RFC 2396而不包含任何其他字符时，要编码非US-ASCII字符。
- 引用组件中非法的字符。用户信息，路径，查询和片段组件在哪些字符被视为合法和非法时略有不同。
这一目的在本课程中由三个相关操作提供：
- 的字符通过用转义八位组表示在UTF-8字符集的字符的序列替换它编码。例如，欧元货币符号（ '\u20AC' ）编码为"%E2%82%AC" 。 （ 与RFC 2396的偏差 ，它没有指定任何特定的字符集。）
- 简单地通过编码来引用非法字符。例如，空格字符通过将其替换为"%20"来引用。 UTF-8包含US-ASCII，因此对于US-ASCII字符，此转换具有RFC 2396所要求的效果。
- 转义的八位字节序列通过将其替换为UTF-8字符集中表示的字符序列进行解码。 UTF-8包含US-ASCII，因此解码具有取消引用任何引用的US-ASCII字符以及解码任何编码的非US-ASCII字符的效果。如果decoding error解码转义八位组，则错误的八位位组被更换时发生'\uFFFD' ，Unicode替换字符。
这些操作在此类的构造函数和方法中公开，如下所示：
- single-argument constructor要求引用其参数中的任何非法字符，并保留任何转义的八位字节和其他存在的字符。
- multi-argument constructors引用它们出现的组件所需的非法字符。百分比字符（ '%' ）始终由这些构造函数引用。保留任何其他字符。
- 的getRawUserInfo ， getRawPath ， getRawQuery ， getRawFragment ， getRawAuthority ，和getRawSchemeSpecificPart方法返回原始形式及其相应的分量的值，而不用解释任何转义八位组。这些方法返回的字符串可能包含转义的八位字节和其他字符，并且不包含任何非法字符。
- 的getUserInfo ， getPath ， getQuery ， getFragment ， getAuthority ，和getSchemeSpecificPart方法解码任何逃脱在它们的对应部件的八位字节。这些方法返回的字符串可能包含其他字符和非法字符，并且不包含任何转义的八位字节。
- toString方法返回一个URI字符串，其中包含所有必需的引号，但可能包含其他字符。
- toASCIIString方法返回一个完全引用并编码的URI字符串，该字符串不包含任何其他字符。
身份
对于任何URI U，它始终是情况
new URI( u .toString()).equals( u ) .
对于任何URIÜ不包含一个空的机构（如在之前的冗余语法如两个斜杠file:///tmp/以下一个主机名，但没有端口（如在）或冒号http://java.sun.com: ），并且不除了那些必须是字符进行编码引用，以下身份也有：
```
  new URI(u.getScheme(),             u.getSchemeSpecificPart(),             u.getFragment())     .equals(u) 
```
在所有情况下，
```
  new URI(u.getScheme(),             u.getAuthority(),             u.getPath(), u.getQuery(),             u.getFragment())     .equals(u) 
```
如果你是等级的，
```
  new URI(u.getScheme(),             u.getUserInfo(), u.getHost(), u.getPort(),             u.getPath(), u.getQuery(),             u.getFragment())     .equals(u) 
```
如果你是分层的，没有权限或基于服务器的权限。
URI，URL和URN
URI是统一资源标识符，而URL是统一资源定位符 。因此，抽象地说，每个URL都是一个URI，但不是每个URI都是一个URL。这是因为URI的另一个子类别，统一资源名称（URN），它们命名资源但不指定如何定位它们。的mailto ， news ，和isbn上面所示URI是的URN的例子。
URI和URL之间的概念区别反映在此类与URL类之间的差异中。

此类的实例表示RFC 2396定义的语法意义上的URI引用.URI可以是绝对的或相对的。根据通用语法解析URI字符串，而不考虑它指定的方案（如果有的话）。不执行主机查找（如果有），并且不构造依赖于方案的流处理程序。严格按照实例的字符内容定义等同，散列和比较。换句话说，URI实例只不过是一个结构化字符串，它支持比较，规范化，解析和相对化的语法，与方案无关的操作。

相比之下， URL类的实例表示URL的语法组件以及访问其描述的资源所需的一些信息。 URL必须是绝对的，也就是说，它必须始终指定方案。根据其方案解析URL字符串。始终为URL建立流处理程序，实际上，无法为没有可用处理程序的方案创建URL实例。平等和散列取决于主机的方案和互联网地址，如果有的话; 比较没有定义。换句话说，URL是一种结构化字符串，它支持解析的语法操作以及查找主机和打开与指定资源的连接的网络I / O操作。
从以下版本开始：

1.4

另请参见：

RFC 2279: UTF-8, a transformation format of ISO 10646 ，
RFC 2373: IPv6 Addressing Architecture ，
RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax ，
RFC 2732: Format for Literal IPv6 Addresses in URLs ，
URISyntaxException ， Serialized Form

构造方法摘要

构造方法
构造器	描述
`URI(String str)`	通过解析给定的字符串构造URI。
`URI(String scheme, String ssp, String fragment)`	根据给定的组件构造URI。
`URI(String scheme, String userInfo, String host, int port, String path, String query, String fragment)`	根据给定组件构造分层URI。
`URI(String scheme, String host, String path, String fragment)`	根据给定组件构造分层URI。
`URI(String scheme, String authority, String path, String query, String fragment)`	根据给定组件构造分层URI。

方法摘要

所有方法静态方法实例方法具体的方法
变量和类型	方法	描述
`int`	`compareTo(URI that)`	将此URI与另一个对象进行比较，该对象必须是URI。
`static URI`	`create(String str)`	通过解析给定的字符串来创建URI。
`boolean`	`equals(Object ob)`	测试此URI与另一个对象的相等性。
`String`	`getAuthority()`	返回此URI的已解码授权组件。
`String`	`getFragment()`	返回此URI的已解码片段组件。
`String`	`getHost()`	返回此URI的主机组件。
`String`	`getPath()`	返回此URI的已解码路径组件。
`int`	`getPort()`	返回此URI的端口号。
`String`	`getQuery()`	返回此URI的已解码查询组件。
`String`	`getRawAuthority()`	返回此URI的原始授权组件。
`String`	`getRawFragment()`	返回此URI的原始片段组件。
`String`	`getRawPath()`	返回此URI的原始路径组件。
`String`	`getRawQuery()`	返回此URI的原始查询组件。
`String`	`getRawSchemeSpecificPart()`	返回此URI的原始方案特定部分。
`String`	`getRawUserInfo()`	返回此URI的原始用户信息组件。
`String`	`getScheme()`	返回此URI的scheme组件。
`String`	`getSchemeSpecificPart()`	返回此URI的已解码方案特定部分。
`String`	`getUserInfo()`	返回此URI的已解码用户信息组件。
`int`	`hashCode()`	返回此URI的哈希码值。
`boolean`	`isAbsolute()`	判断此URI是否是绝对的。
`boolean`	`isOpaque()`	判断此URI是否不透明。
`URI`	`normalize()`	规范化此URI的路径。
`URI`	`parseServerAuthority()`	尝试将此URI的权限组件（如果已定义）解析为用户信息，主机和端口组件。
`URI`	`relativize(URI uri)`	根据此URI重新激活给定的URI。
`URI`	`resolve(String str)`	通过解析给定的字符串然后针对此URI解析它来构造新的URI。
`URI`	`resolve(URI uri)`	根据此URI解析给定的URI。
`String`	`toASCIIString()`	以US-ASCII字符串形式返回此URI的内容。
`String`	`toString()`	以字符串形式返回此URI的内容。
`URL`	`toURL()`	根据此URI构造URL。

声明方法的类 java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 构造方法详细信息
  - URI
```
public URI(String str)    throws URISyntaxException
```
    通过解析给定的字符串构造URI。
    此构造函数完全按照RFC 2396附录A中的语法指定解析给定字符串， 但以下偏差除外：
    
    只要后面跟着非空路径，查询组件或片段组件，就允许空权限组件。这允许解析URI，例如"file:///foo/bar" ，这似乎是RFC 2396的意图，尽管语法不允许它。如果权限组件为空，则用户信息，主机和端口组件未定义。
    
    允许空的相对路径; 这似乎是RFC 2396的意图，尽管语法不允许它。这种偏差的主要后果是，诸如"#foo"的独立片段作为具有空路径和给定片段的相对URI进行解析，并且对于基URI可以是有用的resolved 。
    
    主机组件中的IPv4地址严格解析，如RFC 2732所指定：虚线四元组地址的每个元素必须包含不超过三个十进制数字。每个元素进一步约束为具有不大于255的值。
    
    仅包含单个域标签的主机组件中的主机名允许以字母字符开头。这似乎是RFC 2396第3.2.2节的意图，尽管语法不允许它。这种偏差的后果是分层URI的权限组件（如s://123 ）将作为基于服务器的权限进行解析。
    
    主机组件允许使用IPv6地址。 IPv6地址必须用']'指定的方括号（ '['和']' ）括起来。 IPv6地址本身必须根据RFC 2373进行解析。 IPv6地址进一步受限于描述不超过16个字节的地址信息，这是RFC 2373中隐含但在语法中不可表达的约束。
    
    RFC 2396允许转义的八位字节，即用户信息，路径，查询和片段组件，以及权限是基于注册表的权限组件中允许的是其他类别中的字符。这允许URI包含超出US-ASCII字符集中的Unicode字符。
    参数
    
    str - 要解析为URI的字符串
    
    异常
    
    NullPointerException - 如果 str是 null
    
    URISyntaxException - 如果给定的字符串违反RFC 2396， URISyntaxException因上述偏差而增加
  - URI
```
public URI(String scheme,           String userInfo,           String host,           int port,           String path,           String query,           String fragment)    throws URISyntaxException
```
    根据给定组件构造分层URI。
    如果给出了一个方案，那么路径（如果也是给定的话）必须为空或以斜杠字符开头（ '/' ）。否则，新的URI的一个部件可以被留下通过使未定义null对于相应的参数，或者在所述的情况下port参数，通过使-1 。
    
    此构造函数首先根据RFC 2396 ，第5.2节，第7步中指定的规则从给定组件构建URI字符串：
    
    最初，结果字符串为空。
    
    如果给出了一个方案，那么它将附加到结果中，后跟一个冒号字符（ ':' ）。
    
    如果给出用户信息，主机或端口，则附加字符串"//" 。
    
    如果给出了用户信息，则附加它，然后是商业广告字符（ '@' ）。任何不在非保留，突破，转义或其他类别中的字符是quoted 。
    
    如果给出主机，则附加主机。如果主机是文字IPv6地址但未包含在方括号（ '['和']' ）中，则会添加方括号。
    
    如果给出了端口号，则附加一个冒号字符（ ':' ），后跟十进制的端口号。
    
    如果给出了路径，则附加路径。引用任何不在未保留 ，突破，转义或其他类别中且不等于斜杠字符（ '/' ）或商业广告字符（ '@' ）的字符。
    
    如果给出查询，则追加问号字符（ '?' ），然后追加查询。引用任何不是legal URI character的字符。
    
    最后，如果给出片段，则附加散列字符（ '#' ），然后是片段。引用任何非合法URI字符的字符。
    
    然后通过调用URI(String)构造函数然后在结果上调用parseServerAuthority()方法来解析生成的URI字符串; 这可能会导致URISyntaxException被抛出。
    参数
    
    scheme - 方案名称
    
    userInfo - 用户名和授权信息
    
    host - 主机名
    
    port - 端口号
    
    path - 路径
    
    query - 查询
    
    fragment - 片段
    
    异常
    
    URISyntaxException - 如果同时给出了方案和路径，但路径是相对的，如果从给定组件构造的URI字符串违反RFC 2396，或者字符串的权限组件存在但无法解析为基于服务器的权限
  - URI
```
public URI(String scheme,           String authority,           String path,           String query,           String fragment)    throws URISyntaxException
```
    根据给定组件构造分层URI。
    如果给出了一个方案，那么路径（如果也是给定的话）必须为空或以斜杠字符开头（ '/' ）。否则，通过传递null作为相应参数，可以保留新URI的组件未定义。
    
    此构造函数首先根据RFC 2396第5.2节第7步中指定的规则从给定组件构建URI字符串：
    
    最初，结果字符串为空。
    
    如果给出了一个方案，那么它将附加到结果中，后跟一个冒号字符（ ':' ）。
    
    如果给出了"//"则附加字符串"//" ，然后是权限。如果权限包含文字IPv6地址，则地址必须用方括号括起来（ '['和']' ）。任何不属于无保留 ，被盗，逃脱或其他类别且不等于商业角色（ '@' ）的角色是quoted 。
    
    如果给出了路径，则附加路径。引用任何不在未保留 ，突破，转义或其他类别中且不等于斜杠字符（ '/' ）或商业广告字符（ '@' ）的字符。
    
    如果给出查询，则追加问号字符（ '?' ），然后追加查询。引用任何不是legal URI character的字符。
    
    最后，如果给出了片段，则附加散列字符（ '#' ），然后是片段。引用任何非合法URI字符的字符。
    
    然后通过调用URI(String)构造函数然后在结果上调用parseServerAuthority()方法来解析生成的URI字符串; 这可能导致URISyntaxException被抛出。
    参数
    
    scheme - 方案名称
    
    authority - 权威
    
    path - 路径
    
    query - 查询
    
    fragment - 片段
    
    异常
    
    URISyntaxException - 如果同时给出了方案和路径，但路径是相对的，如果从给定组件构造的URI字符串违反RFC 2396，或者字符串的权限组件存在但无法解析为基于服务器的权限
  - URI
```
public URI(String scheme,           String host,           String path,           String fragment)    throws URISyntaxException
```
    根据给定组件构造分层URI。
    通过传递null可能未定义组件。
    
    这个便捷构造函数就好像通过调用七参数构造函数一样工作，如下所示：
    
    new URI (scheme, null, host, -1, path, null, fragment);
    
    参数
    
    scheme - 方案名称
    
    host - 主机名
    
    path - 路径
    
    fragment - 碎片
    
    异常
    
    URISyntaxException - 如果从给定组件构造的URI字符串违反RFC 2396
  - URI
```
public URI(String scheme,           String ssp,           String fragment)    throws URISyntaxException
```
    根据给定的组件构造URI。
    通过null可能未定义组件。
    
    此构造函数首先使用给定的组件以字符串形式构建URI，如下所示：
    
    最初，结果字符串为空。
    
    如果给出了一个方案，那么它将被附加到结果中，后跟一个冒号字符（ ':' ）。
    
    如果给出了特定于方案的部分，则附加它。任何不是legal URI character的字符都是quoted 。
    
    最后，如果给出一个片段，则将一个散列字符（ '#' ）附加到该字符串，然后是该片段。引用任何非合法URI字符的字符。
    
    然后解析生成的URI字符串，以便通过调用URI(String)构造函数来创建新的URI实例; 这可能会导致URISyntaxException被抛出。
    参数
    
    scheme - 方案名称
    
    ssp - 特定于方案的部分
    
    fragment - 片段
    
    异常
    
    URISyntaxException - 如果从给定组件构造的URI字符串违反RFC 2396
- 方法详细信息
  - create
```
public static URI create(String str)
```
    通过解析给定的字符串来创建URI。
    这个便利工厂方法就好像通过调用URI(String)构造函数一样工作; 构造函数抛出的任何URISyntaxException被捕获并包装在一个新的IllegalArgumentException对象中，然后抛出该对象。
    
    提供此方法是为了在已知给定字符串是合法URI的情况下使用，例如对于在程序中声明的URI常量，因此将其视为不能解析的字符串的编程错误。直接抛出URISyntaxException的构造函数应该用于从用户输入或可能容易出错的其他源构造URI的情况。
    
    参数
    
    str - 要解析为URI的字符串
    
    结果
    
    新的URI
    
    异常
    
    NullPointerException - 如果 str是 null
    
    IllegalArgumentException - 如果给定的字符串违反RFC 2396
  - parseServerAuthority
```
public URI parseServerAuthority()                         throws URISyntaxException
```
    尝试将此URI的权限组件（如果已定义）解析为用户信息，主机和端口组件。
    如果此URI的权限组件已被识别为基于服务器，则它已经被解析为用户信息，主机和端口组件。在这种情况下，或者如果此URI没有权限组件，此方法只返回此URI。
    
    否则，此方法再次尝试将权限组件解析为用户信息，主机和端口组件，并抛出异常，描述无法以这种方式解析权限组件的原因。
    
    提供此方法是因为RFC 2396中指定的通用URI语法无法始终将基于服务器的格式错误的权限与基于合法注册表的权限区分开来。因此，它必须将前者的一些实例视为后者的实例。例如，URI字符串"//foo:bar"的授权组件不是基于合法服务器的授权，但作为基于注册表的授权是合法的。
    
    在许多常见情况下，例如，当处理已知为URN或URL的URI时，使用的分层URI将始终基于服务器。因此，它们必须要么被解析，要么被视为错误。在这些情况下的声明如
    
    URI u = new URI(str).parseServerAuthority();
    
    可用于确保u始终引用URI，如果URI具有权限组件，则具有基于服务器的权限，该权限具有适当的用户信息，主机和端口组件。调用此方法还可确保如果无法以此方式解析权限，则可以根据引发的异常发出相应的诊断消息。
    
    结果
    
    一个URI，其权限字段已被解析为基于服务器的权限
    
    异常
    
    URISyntaxException - 如果定义了此URI的授权组件，但根据RFC 2396无法将其解析为基于服务器的授权
  - normalize
```
public URI normalize()
```
    规范化此URI的路径。
    如果此URI不透明，或者其路径已经是正常形式，则返回此URI。否则，构造一个与此URI相同的新URI，除了通过以与RFC 2396 ，第5.2节，第6步，子步骤c到f一致的方式规范化该URI的路径来计算其路径; 那是：
    
    所有"."段都已删除。
    
    如果".."段前面有非".."段，则会删除这两个段。重复该步骤直到不再适用。
    
    如果路径是相对路径，并且其第一个段包含冒号字符（ ':' ），则会预先添加"."段。这防止相对URI与诸如路径"a:b/c/d"从后来被重新解析为一个不透明带URI的方案"a"和的一个具体方案的部分"b/c/d" 。 （与RFC 2396的偏差）
    
    如果在它们之前没有足够的非".."段以允许它们被移除，则标准化路径将以一个或多个".."段开始。如果在上面的步骤3中插入一个段，则标准化路径将以"."段开始。否则，规范化路径将不包含任何"."或".."段。
    结果
    
    与此URI等效的URI，但其路径为正常形式
  - resolve
```
public URI resolve(URI uri)
```
    根据此URI解析给定的URI。
    如果给定的URI已经是绝对的，或者此URI是不透明的，则返回给定的URI。
    
    如果定义了给定URI的片段组件，其路径组件为空，并且其方案，权限和查询组件未定义，则返回具有给定片段但所有其他组件等于此URI的URI的URI。这允许表示独立片段引用的URI（例如"#foo"针对基URI进行有用的解析。
    
    否则，此方法以与RFC 2396 ，第5.2节一致的方式构造新的分层URI; 那是：
    
    使用此URI方案和给定URI的查询和片段组件构造新URI。
    
    如果给定的URI具有权限组件，那么新URI的权限和路径将从给定的URI中获取。
    
    否则，将从此URI复制新URI的权限组件，并按如下方式计算其路径：
    
    如果给定URI的路径是绝对路径，那么新URI的路径将从给定的URI中获取。
    
    否则，给定URI的路径是相对的，因此通过根据此URI的路径解析给定URI的路径来计算新URI的路径。这是通过连接此URI路径的最后一段（如果有）与给定URI的路径，然后将结果标准化，就好像通过调用normalize方法来完成的。
    
    当且仅当此URI是绝对的或给定的URI是绝对的时，此方法的结果才是绝对的。
    参数
    
    uri - 要针对此URI解析的URI
    
    结果
    
    生成的URI
    
    异常
    
    NullPointerException - 如果 uri是 null
  - resolve
```
public URI resolve(String str)
```
    通过解析给定的字符串然后针对此URI解析它来构造新的URI。
    这种方便的方法就好像调用它等同于评估表达式resolve (URI. create (str)) 。
    
    参数
    
    str - 要解析为URI的字符串
    
    结果
    
    生成的URI
    
    异常
    
    NullPointerException - 如果 str是 null
    
    IllegalArgumentException - 如果给定的字符串违反RFC 2396
  - relativize
```
public URI relativize(URI uri)
```
    根据此URI重新激活给定的URI。
    给定URI对此URI的相对化计算如下：
    
    如果此URI或给定的URI不透明，或者两个URI的方案和权限组件不相同，或者此URI的路径不是给定URI的路径的前缀，则给定的URI是回。
    
    否则，使用从给定URI获取的查询和片段组件以及通过从给定URI的路径的开头移除该URI路径计算的路径组件来构造新的相对分层URI。
    参数
    
    uri - 要针对此URI进行相对化的URI
    
    结果
    
    生成的URI
    
    异常
    
    NullPointerException - 如果 uri是 null
  - toURL
```
public URL toURL()          throws MalformedURLException
```
    根据此URI构造URL。
    这种方便的方法就好像调用它等同于在首次检查此URI是绝对的之后计算表达式new URL(this.toString()) 。
    
    结果
    
    从此URI构造的URL
    
    异常
    
    IllegalArgumentException - 如果此URL不是绝对的
    
    MalformedURLException - 如果找不到URL的协议处理程序，或者在构造URL时发生了其他错误
  - getScheme
```
public String getScheme()
```
    返回此URI的scheme组件。
    URI的scheme组件（如果已定义）仅包含alphanum类别和字符串"-.+"中的字符。方案始终以字母字符开头。
    
    URI的方案组件不能包含转义的八位字节，因此此方法不执行任何解码。
    
    结果
    
    此URI的方案组件，如果方案未定义， null
  - isAbsolute
```
public boolean isAbsolute()
```
    判断此URI是否是绝对的。
    当且仅当它具有方案组件时，URI才是绝对的。
    
    结果
    
    true if且仅当此URI是绝对的
  - isOpaque
```
public boolean isOpaque()
```
    判断此URI是否不透明。
    如果且仅当它是绝对的并且其特定于方案的部分不以斜杠字符（'/'）开头时，URI是不透明的。不透明的URI有一个方案，一个方案特定的部分，可能还有一个片段; 所有其他组件都未定义。
    
    结果
    
    true当且仅当此URI不透明时
  - getRawSchemeSpecificPart
```
public String getRawSchemeSpecificPart()
```
    返回此URI的原始方案特定部分。特定于方案的部分永远不会被定义，尽管它可能是空的。
    URI的特定于方案的部分仅包含合法的URI字符。
    
    结果
    
    此URI的原始方案特定部分（从不 null ）
  - getSchemeSpecificPart
```
public String getSchemeSpecificPart()
```
    返回此URI的已解码方案特定部分。
    此方法返回的字符串等于getRawSchemeSpecificPart方法返回的字符串，但所有转义八位字节序列均为decoded 。
    
    结果
    
    此URI的解码方案特定部分（从不 null ）
  - getRawAuthority
```
public String getRawAuthority()
```
    返回此URI的原始授权组件。
    URI的权限组件（如果已定义）仅包含商业广告字符（ '@' ）以及未保留 ，删节，转义和其他类别中的字符。如果权限是基于服务器的，则进一步限制为具有有效的用户信息，主机和端口组件。
    
    结果
    
    此URI的原始授权组件，如果未定义权限， null
  - getAuthority
```
public String getAuthority()
```
    返回此URI的已解码授权组件。
    此方法返回的字符串等于getRawAuthority方法返回的字符串，但所有转义八位字节序列均为decoded 。
    
    结果
    
    此URI的已解码权限组件，如果未定义权限， null
  - getRawUserInfo
```
public String getRawUserInfo()
```
    返回此URI的原始用户信息组件。
    URI的用户信息组成部分，如果所定义，只包含在未保留 ，字符PUNCT， 躲过，和其他类别。
    
    结果
    
    此URI的原始用户信息组件，如果未定义用户信息， null
  - getUserInfo
```
public String getUserInfo()
```
    返回此URI的已解码用户信息组件。
    此方法返回的字符串等于getRawUserInfo方法返回的字符串，但所有转义八位字节序列均为decoded 。
    
    结果
    
    此URI的已解码用户信息组件，如果未定义用户信息， null
  - getHost
```
public String getHost()
```
    返回此URI的主机组件。
    URI的主机组件（如果已定义）将具有以下形式之一：
    
    由一个或多个以句点字符（ '.' ）分隔的标签组成的域名，可选地后跟句点字符。每个标签由字母字符和连字符（ '-' ）组成，但连字符不会作为标签中的第一个或最后一个字符出现。由两个或多个标签组成的域名最右边的标签以字母字符开头。
    
    形式的数字的点分IPv4地址+. 数字 +. 数字 +. 数字 + ，其中没有数字序列长于三个字符并且没有序列具有值大于255。
    
    包含在方括号（ '['和']' ）中的IPv6地址，由十六进制数字，冒号字符（ ':' ）和可能的嵌入式IPv4地址组成。 IPv6地址的完整语法在RFC 2373: IPv6 Addressing Architecture中指定。
    
    URI的主机组件不能包含转义的八位字节，因此此方法不执行任何解码。
    结果
    
    此URI的主机组件，如果主机未定义， null
  - getPort
```
public int getPort()
```
    返回此URI的端口号。
    URI的端口组件（如果已定义）是非负整数。
    
    结果
    
    此URI的端口组件，如果端口未定义， -1
  - getRawPath
```
public String getRawPath()
```
    返回此URI的原始路径组件。
    URI的路径组件（如果已定义）仅包含斜杠字符（ '/' ），商业广告字符（ '@' ）以及未保留 ，删节，转义和其他类别中的字符。
    
    结果
    
    此URI的路径组件，如果路径未定义， null
  - getPath
```
public String getPath()
```
    返回此URI的已解码路径组件。
    此方法返回的字符串等于getRawPath方法返回的字符串，但所有转义八位字节序列均为decoded 。
    
    结果
    
    此URI的已解码路径组件，如果路径未定义， null
  - getRawQuery
```
public String getRawQuery()
```
    返回此URI的原始查询组件。
    URI的查询组件（如果已定义）仅包含合法的URI字符。
    
    结果
    
    此URI的原始查询组件，如果查询未定义， null
  - getQuery
```
public String getQuery()
```
    返回此URI的已解码查询组件。
    此方法返回的字符串等于getRawQuery方法返回的字符串，但所有转义八位字节序列均为decoded 。
    
    结果
    
    此URI的已解码查询组件，如果查询未定义， null
  - getRawFragment
```
public String getRawFragment()
```
    返回此URI的原始片段组件。
    URI的片段组件（如果已定义）仅包含合法的URI字符。
    
    结果
    
    此URI的原始片段组件，如果片段未定义， null
  - getFragment
```
public String getFragment()
```
    返回此URI的已解码片段组件。
    此方法返回的字符串等于getRawFragment方法返回的字符串，但转义八位字节的所有序列均为decoded 。
    
    结果
    
    此URI的已解码片段组件，如果片段未定义， null
  - equals
```
public boolean equals(Object ob)
```
    测试此URI与另一个对象的相等性。
    如果给定对象不是URI，则此方法立即返回false 。
    
    要使两个URI相等，要求两者都是不透明的，或者两者都是分层的。他们的计划要么两者都不明确，要么在不考虑案件的情况下是平等的。他们的片段既可以是未定义的，也可以是相同的。
    
    要使两个不透明的URI相等，它们的特定于方案的部分必须相等。
    
    要使两个分层URI相等，它们的路径必须相等，并且它们的查询必须都是未定义的，否则必须相等。他们的权限既可以是未定义的，也可以是基于注册表的，或者都是基于服务器的。如果他们的权限是定义的并且是基于注册表的，那么它们必须是平等的。如果它们的权限是定义的并且是基于服务器的，那么它们的主机必须相等而不考虑大小写，它们的端口号必须相等，并且它们的用户信息组件必须相等。
    
    在测试两个URI的用户信息，路径，查询，片段，权限或方案特定部分是否相等时，比较原始表单而不是这些组件的编码形式，并且比较转义八位字节的十六进制数字而不考虑案件。
    
    该方法满足Object.equals方法的一般合同。
    
    重写：
    
    equals在类 Object
    
    参数
    
    ob - 要与此对象进行比较的对象
    
    结果
    
    true当且仅当给定对象是与此URI相同的URI时
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - hashCode
```
public int hashCode()
```
    返回此URI的哈希码值。哈希码基于所有URI的组件，并且满足Object.hashCode方法的一般契约。
    
    重写：
    
    hashCode在类 Object
    
    结果
    
    此URI的哈希码值
    
    另请参见：
    
    Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.Object)
  - compareTo
```
public int compareTo(URI that)
```
    将此URI与另一个对象进行比较，该对象必须是URI。
    当比较两个URI的相应组件时，如果一个组件未定义但另一个组件已定义，则第一个组件被认为小于第二个组件。除非另有说明，否则字符串组件按照String.compareTo方法定义的自然区分大小写排序。通过比较它们的原始形式而不是它们的编码形式来比较要进行编码的字符串组件。
    
    URI的排序定义如下：
    
    根据其方案的顺序对具有不同方案的两个URI进行排序，而不考虑大小写。
    
    分层URI被认为小于具有相同方案的不透明URI。
    
    具有相同方案的两个不透明URI根据其方案特定部分的顺序排序。
    
    具有相同方案和方案特定部分的两个不透明URI根据其片段的顺序排序。
    
    具有相同方案的两个分层URI根据其权限组件的顺序排序：
    
    如果两个权限组件都是基于服务器的，那么URI将根据其用户信息组件进行排序; 如果这些组件是相同的，则根据其主机的顺序对URI进行排序，而不考虑大小写; 如果主机相同，则根据其端口的顺序对URI进行排序。
    
    如果一个或两个授权组件是基于注册表的，那么URI将根据其授权组件的顺序进行排序。
    
    最后，根据路径的顺序对具有相同方案和权限组件的两个分层URI进行排序; 如果他们的路径相同，那么他们会根据他们的查询顺序排序; 如果查询相同，则根据其片段的顺序对它们进行排序。
    
    该方法满足Comparable.compareTo方法的一般合同。
    Specified by:
    
    compareTo在界面 Comparable<URI>
    
    参数
    
    that - 要与此URI进行比较的对象
    
    结果
    
    一个负整数，零或正整数，因为此URI小于，等于或大于给定的URI
    
    异常
    
    ClassCastException - 如果给定对象不是URI
  - toString
```
public String toString()
```
    以字符串形式返回此URI的内容。
    如果此URI是通过调用此类中的一个构造函数创建的，则返回等效于原始输入字符串的字符串，或者根据需要返回从最初给定的组件计算的字符串。否则，此URI是通过规范化，解析或相对化创建的，因此根据RFC 2396第5.2节第7步中指定的规则从此URI的组件构造字符串。
    
    重写：
    
    toString在类 Object
    
    结果
    
    此URI的字符串形式
  - toASCIIString
```
public String toASCIIString()
```
    以US-ASCII字符串形式返回此URI的内容。
    如果此URI不包含其他类别中的任何字符，则调用此方法将返回与调用toString方法相同的值。否则此方法的工作方式就像调用该方法然后encoding结果一样。
    
    结果
    
    此URI的字符串形式，根据需要进行编码，以便它只包含US-ASCII字符集中的字符

Class URI

URI语法和组件

URI实例的操作

人物类别

转义的八位字节，引用，编码和解码

身份

URI，URL和URN

构造方法摘要

方法摘要

声明方法的类 java.lang.Object

构造方法详细信息

URI

URI

URI

URI

URI

方法详细信息

create

parseServerAuthority

normalize

resolve

resolve

relativize

toURL

getScheme

isAbsolute

isOpaque

getRawSchemeSpecificPart

getSchemeSpecificPart

getRawAuthority

getAuthority

getRawUserInfo

getUserInfo

getHost

getPort

getRawPath

getPath

getRawQuery

getQuery

getRawFragment

getFragment

equals

hashCode

compareTo

toString

toASCIIString