All Implemented Interfaces:: Serializable ， Comparable<URI>

public final class URI
extends Object
implements Comparable<URI>, Serializable

表示统一资源标识符（URI）参考。

除了下面指出的一些微小偏差，这个类的一个实例表示由所定义的URI引用RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax ，通过修正RFC 2732: Format for Literal IPv6 Addresses in URLs 。文字IPv6地址格式也支持scope_ids。 scope_ids的语法和用法描述为here 。该类提供了用于从其组件创建URI实例或通过解析其字符串表单，访问实例的各种组件的方法以及用于归一化，解析和相对化URI实例的方法的构造函数。这个类的实例是不可变的。

URI语法和组件

在最高级别，字符串形式的URI引用（以下简称为“URI”）具有语法

[ scheme :] scheme-specific-part[ # fragment]

其中方括号[...]描绘可选组件，字符:和#代表自己。

绝对 URI指定方案; 一个不是绝对的URI被认为是相对的 。 URI也根据它们是不透明还是分层次分类 。

不透明 URI是一个绝对URI，其特定于方案的部分不以斜杠字符开头（ '/' ）。不透明的URI不需要进一步解析。不透明URI的一些示例是：

mailto:java-net@java.sun.com

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的路径组件中删除不必要的"."和".."段的过程。每个"."段都被简单地删除。 A ".."段仅在前面带有非".."段时被删除。规范化对不透明的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（2）相对于相对基本URI（1）产生归一化但仍然相对的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

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)

如果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

构造方法摘要

构造方法
Constructor	描述
`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。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	方法	描述
`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的方案组件。
`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()`	将此URI的内容作为US-ASCII字符串返回。
`String`	`toString()`	以字符串形式返回此URI的内容。
`URL`	`toURL()`	从此URI构造一个URL。

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 构造方法详细信息
  - URI
```
public URI(String str)
    throws URISyntaxException
```
    通过解析给定的字符串构造一个URI。
    该构造函数完全按照RFC 2396附录A中的语法所指定的字符串进行解析， 但以下偏差除外：
    
    只要后面跟着非空路径，查询组件或片段组件，就允许使用空的权限组件。这样就可以解析诸如"file:///foo/bar"这样的URI，尽管语法不允许它，但似乎是RFC 2396的意图。如果权限组件为空，则用户信息，主机和端口组件未定义。
    
    允许空的相对路径; 这似乎是RFC 2396的意图，尽管语法不允许。这种偏离的主要后果是，诸如"#foo"类的独立片段将解析为具有空路径和给定片段的相对URI，并且对基本URI可以有用地为resolved 。
    
    主机组件中的IPv4地址被严格地解析，如RFC 2732所指定的：虚拟地址的每个元素必须包含不超过三位十进制数字。每个元素被进一步限制为不大于255的值。
    
    仅包含单个域标签的主机组件中的主机名允许以字母字符开头。这似乎是RFC 2396第3.2.2节的意图，尽管语法不允许它。这种偏差的后果是分层URI（如s://123的权限组件将解析为基于服务器的权限。
    
    主机组件允许IPv6地址。 IPv6地址必须由RFC 2732所指定的方括号（ '['和']' ）括起来。 IPv6地址本身必须根据RFC 2373进行解析。 IPv6地址被进一步限制为描述不超过十六个字节的地址信息，RFC 2373中隐含的约束，但在语法中不能表达。
    
    在RFC 2396允许转义的八位字节（即用户信息，路径，查询和片段组件）以及权限组件（如果权限是基于注册表的）中，则允许其他类别中的字符。这允许URI包含除US-ASCII字符集之外的Unicode字符。
    参数
    
    str - 要解析为URI的字符串
    
    异常
    
    NullPointerException - 如果 str是 null
    
    URISyntaxException - 如果给定的字符串违反RFC 2396，则由上述偏差所增加
  - URI
```
public URI(String scheme,
           String userInfo,
           String host,
           int port,
           String path,
           String query,
           String fragment)
    throws URISyntaxException
```
    从给定的组件构造一个分层URI。
    如果给出了一个方案，那么路径（如果也是给定的）必须是空的，或者以斜杠字符开头（ '/' ）。否则，通过传递null相应的参数，或者在port参数的情况下，通过传递-1可能不定义新URI的组件。
    
    此构造函数首先根据RFC 2396第5.2节第7步中规定的规则从给定的组件生成URI字符串：
    
    最初，结果字符串为空。
    
    如果给出了一个方案，那么它将被附加到结果后跟一个冒号字符（ ':' ）。
    
    如果给出用户信息，主机或端口，则附加字符串"//" 。
    
    如果给出了用户信息，则会附加用户信息，后跟广告字符（ '@' ）。任何字符不是在毫无保留的 ，PUNCT， 逃脱，或其他类别为quoted 。
    
    如果给出主机，那么它被附加。如果主机是一个文字的IPv6地址，但不包含在方括号（ '['和']' ）中，则会添加方括号。
    
    如果给出端口号，则附加冒号字符（ ':' ），后跟端口号以十进制形式。
    
    如果给出一个路径，那么它被附加。引用了不保留，标点，转义或其他类别，不等于斜杠字符（ '/' ）或商业字符（ '@' ）的任何字符。
    
    如果给出了一个查询，则附加一个问号字符（ '?' ），后跟查询。任何不是legal URI character的字符均被引用。
    
    最后，如果给出了一个片段，则附加一个散列字符（ '#' ），后跟片段。引用不符合法定URI字符的任何字符。
    
    然后，结果URI字符串将被解析为通过调用URI(String)构造函数，然后根据结果调用parseServerAuthority()方法; 这可能会导致抛出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 。
    
    如果给出一个路径，那么它被附加。任何字符不是在毫无保留的 ，PUNCT， 逃脱，或其他类别，以及不等于斜线字符（ '/' ）或商用的字符（ '@' ），是引用。
    
    如果给出查询，则附加一个问号字符（ '?' ），后跟该查询。任何不是legal URI character的字符均被引用。
    
    最后，如果给出一个片段，则附加一个散列字符（ '#' ），然后是片段。引用不符合法定URI字符的任何字符。
    
    结果URI字符串的解析就好像是通过调用URI(String)构造函数，然后根据结果调用parseServerAuthority()方法; 这可能会导致抛出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
    
    异常
    
    URISyntaxException - 如果此URI的权限组件被定义，但根据RFC 2396不能被解析为基于服务器的权限
  - normalize
```
public URI normalize()
```
    规范此URI的路径。
    如果该URI是不透明的，或者如果其路径已经是正常形式，则返回此URI。否则，构造与该URI相同的新URI，除了通过以符合RFC 2396 ，第5.2节，步骤6，子步骤c至f的方式归一化该URI的路径来计算其路径; 那是：
    
    全部删除"."段。
    
    如果一个".."段前面有一个非".."段，那么这两个段都被删除。重复此步骤直到不再适用。
    
    如果路径是相对的，并且如果其第一个段包含冒号字符（ ':' ），则会添加一个"."段。这样可以防止具有诸如"a:b/c/d"的路径的相对URI稍后被重新解析为具有方案"a"和方案专用部分"b/c/d"的不透明URI。 （偏离RFC 2396）
    
    如果在它们之前没有足够的非".."段以允许其移除，则归一化路径将从一个或多个".."段开始。如果通过上面的步骤3插入了标准化路径，则将以"."段开头。否则，归一化路径将不包含任何"."或".."段。
    结果
    
    与此URI相当的URI，但其路径为正常形式
  - resolve
```
public URI resolve(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的方案组件。
    URI的方案组件（如果已定义）仅包含字母类别和字符串"-.+"中的字符。方案始终以字母字符开头。
    
    URI的方案组件不能包含转义的八位字节，因此此方法不执行任何解码。
    
    结果
    
    该URI的方案组件，如果方案未定义， null
  - isAbsolute
```
public boolean isAbsolute()
```
    告诉这个URI是否是绝对的。
    一个URI是绝对的，只有当它有一个方案组件。
    
    结果
    
    true如果，只有这个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的用户信息组件（如果已定义）仅包含未保留 ，标记，转义和其他类别中的字符。
    
    结果
    
    该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()
```
    将此URI的内容作为US-ASCII字符串返回。
    如果此URI不包含其他类别中的任何字符，则此方法的调用将返回与调用toString方法相同的值。否则，这个方法的工作原理就是通过调用该方法，然后再结果encoding 。
    
    结果
    
    此URI的字符串形式，根据需要进行编码，以使其仅包含US-ASCII字符集中的字符

Component	Type
scheme	`String`
scheme-specific-part	`String`
authority	`String`
user-info	`String`
host	`String`
port	`int`
path	`String`
query	`String`
fragment	`String`

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)

Class URI

URI语法和组件

URI实例的操作

字符类别

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

身份

URI，URL和URN

构造方法摘要

方法摘要

Methods inherited from class 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