URI (Java Platform SE 8 )

java.lang.Object
- java.net.URI

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://java.sun.com/j2se/1.3/
docs/guide/collections/designfaq.html#28
../../../demo/jfc/SwingSet2/src/SwingSet2.java
file:///~/calendar

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

[ scheme :][ // authority][ path][ ? query][ # fragment]

其中人物 :， /， ?，和 #代表自己。一个分层的URI方案的具体组成部分的字符之间的方案和片段组成。

一个层次的URI权限组件，如果指定，要么基于服务器的或基于注册表的。基于服务器的权威解析根据熟悉的语法

[ user-info @] host[ : port]

在自己的特点 @和 :站。目前使用的几乎所有的URI方案是基于服务器的。一个不以这种方式解析的权限组件被认为是基于注册表的。

一个层次的URI路径组件本身是说是绝对的如果它从一个斜杠字符（'/'）；否则它是相对的。一个层次的URI是绝对或指定路径的权威是绝对的。

总之，然后，一个URI实例有以下九部分组成：

Component Type

scheme String

scheme-specific-part String

authority String

user-info String

host String

port int

path String

query String

fragment String

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的路径部分去除不必要的"."和".."细分的过程。每个"."段干脆去掉。一个".."段只有前面有一non-".."段删除。归一化在不透明的URI没有影响。

分辨率是解决一个URI对另一个的过程，基础URI。由此产生的URI是由URI中都由RFC 2396指定的方式组件，从基URI组件与原未指定。分层的URI，原来的道路是解决对基地然后归一化路径。结果，例如，解决

docs/guide/collections/designfaq.html#28 (1)

对基URI http://java.sun.com/j2se/1.3/反过来结果URI

http://docs.oracle.com/javase/1.3/docs/guide/collections/designfaq.html#28

解决相对URI

../../../demo/jfc/SwingSet2/src/SwingSet2.java (2)

对这个结果产生，，的绝对和相对URI，

http://java.sun.com/j2se/1.3/demo/jfc/SwingSet2/src/SwingSet2.java

分辨率并在分层uri时绝对路径和相对路径，支持。解析URI file:///~calendar反对任何其他URI只是产生的原始URI，因为它是绝对的。解决相对URI（2）在相对的基URI（1）收益率标准，但仍然相对URI

demo/jfc/SwingSet2/src/SwingSet2.java

关系化，最后是分辨率逆：任何两U和V 归一化的URI，

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

这个操作往往是有用的时候，构建文档的URI必须相对于文档的基URI可能。例如，相对化的URI

http://docs.oracle.com/javase/1.3/docs/guide/index.html

对基URI

http://java.sun.com/j2se/1.3

产量相对URI docs/guide/index.html。

字符类

RFC 2396指定的字符恰恰是一个URI引用的各种组件允许。以下几类，其中大部分是从规范，使用以下描述这些约束：

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)

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的目的

对编码非美国ASCII字符时，URI必须严格遵守RFC 2396不含任何其他字符。
对引用，否则部件中的非法字符。用户信息，路径，查询和片段组件略有不同，其中字符被认为是合法的和非法的。

这些目的都曾参与这类三的相关操作：

字符是编码取代它逃跑的字节表示在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字符以及解码任何非美国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，它总是这样的任何URI U不包含如前空局两减少冗余的语法

new URI( u .toString()).equals( u ) .

（如 file:///tmp/ ）或冒号后的主机名称但没有港口（如 http://java.sun.com: ），和不编码字符除了那些必须引用，F本文认为：在所有情况下，身份也

新的URI（美国getscheme()，美国getschemespecificpart()，美国getfragment()）等于（U）

，

新的URI（美国getscheme()，美国getuserinfo()，美国getauthority()，美国getpath()，美国getquery()，美国getfragment()）等于（U）

如果你是分层次的，和

新的URI（美国getscheme()，美国getuserinfo()，美国gethost()，美国getport()，美国getpath()，美国getquery()，美国getfragment()）等于（U）

如果你是分等级的，有没有权威的或基于服务器的权限。

URI、URL，和骨灰盒

URI是统一资源标识符而URL统一资源定位器。因此，每一个URL是一个URI，抽象地说，但不是每个URI是一个URL。这是因为有另一个类别的URI，统一资源名称（瓮），这名称资源但不指定如何定位。的 mailto， news，和 isbn URI上面显示的例子是瓮。

URI和URL之间的概念区别反映在这类与类之间的差异URL。

这个类的一个实例是由RFC 2396定义的语法意义 URI引用。一个URI可以是绝对或相对。一个URI字符串解析根据通用的语法不考虑的方案，如果有，它指定。没有查找主机，如果有的话，并没有计划依赖的流处理程序构建。平等、散列和比较，在实例的字符内容中被严格定义。换句话说，一个URI的实例是一个结构化的字符串，支持句法，独立操作方案比较，正常化，分辨率，和相对性。

与此相反的URL类的实例，代表了一个URL的句法成分和一些需要访问它所描述的资源的信息。一个网址必须是绝对的，也就是说，它必须始终指定一个计划。一个网址字符串被解析，根据它的计划。始终为一个网址建立一个流处理程序，事实上，它是不可能的，为一个没有可用的处理程序的方案的一个实例来创建一个。平等和散列取决于主机的方案和互联网地址，如果有的话，没有定义的比较。换言之，一个链接是一个结构化的字符串，支持分辨率的句法操作以及查找主机的网络I / O操作和打开一个连接到指定的资源。

从以下版本开始：: 一点四
另请参见：: 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 and Description
`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	Method and Description
`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()` 为US-ASCII字符串返回这个URI的内容。
`String`	`toString()` 以字符串的形式返回此URI的内容。
`URL`	`toURL()` 构建了从URI一个URL。

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

- Constructor Detail
  - URI
```
public URI(String str)
    throws URISyntaxException
```
    通过解析给定的字符串构造一个URI。
    此构造函数将给定的字符串是由RFC 2396语法规定，附录，除了以下偏差：
    - 一个空的权限组件是允许的，只要它是由一个非空的路径，一个查询组件，或一个片段组件。这可以解析URI如"file:///foo/bar"，这似乎是RFC 2396 意图虽然语法不允许。如果权限组件是空的，那么用户信息、主机和端口组件都是未定义的。
    - 空的相对路径是允许的；这似乎是RFC 2396 意图虽然语法不允许。这种偏差的主要后果是，一个独立的片段如"#foo"解析为一个相对URI与一个空的路径和给定的片段，并可以有效地resolved对基URI。
    - 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包含Unicode字符以外的US-ASCII字符集。
    参数
    
    str -被解析成一个URI字符串
    
    异常
    
    如果是 null str NullPointerException
    
    URISyntaxException如果给定字符串违反RFC 2396，为增强上述偏差
  - URI
```
public URI(String scheme,
           String userInfo,
           String host,
           int port,
           String path,
           String query,
           String fragment)
    throws URISyntaxException
```
    构建了从给定的组件层次的URI。
    如果一个方案然后路径，如果也给予的，必须是空的或开始一个斜杠字符（'/'）。否则，新的URI组件可以通过null未定义为相应的参数，在port参数的情况下，通过-1。
    
    此构造函数首先构建了一个URI字符串从给定的组件按照RFC 2396规则，部分 5.2步 7：
    1. 最初，结果字符串是空的。
    2. 如果一个设计方案，然后添加到结果，后跟一个冒号（':'）。
    3. 如果用户信息，主机或端口给出字符串"//"追加。
    4. 如果用户信息被再追加，其次是商业性质（'@'）。任何字符不在毫无保留的，穿刺，逃脱，或其他类别是quoted。
    5. 如果一个主机被给定，然后它被添加。如果主机是字面的IPv6地址但不括在方括号（'['和']'）再加方括号。
    6. 如果一个端口号，再给出一个冒号（':'）追加，其次是十进制的端口号。
    7. 如果一个路径被给定，然后它被添加。任何字符不在毫无保留的，穿刺，逃脱，或其他类别，不等于斜杠字符（'/'）或商业性质（'@'），引用。
    8. 如果查询再给出一个问号字符（'?'）追加，其次是查询。任何字符，不是legal URI character报价。
    9. 最后，如果一个片段再给出一个哈希（'#'）追加，其次是片段。任何字符，是不是一个合法的URI字符引用。
    由此产生的URI字符串，然后解析如果通过调用构造函数，然后调用URI(String) parseServerAuthority()方法后的结果；这可能会导致URISyntaxException被。
    参数
    
    scheme方案名称
    
    userInfo用户名称和授权信息
    
    host主机名称
    
    port端口号
    
    path - Path
    
    query查询
    
    fragment片段
    
    异常
    
    URISyntaxException -如果两方案和路径给出但路径是相对的，如果由给定组件的URI字符串违反RFC 2396，或者如果该字符串的权威部分存在但不能被解析为一个基于服务器的权限
  - URI
```
public URI(String scheme,
           String authority,
           String path,
           String query,
           String fragment)
    throws URISyntaxException
```
    构建了从给定的组件层次的URI。
    如果一个方案然后路径，如果也给予的，必须是空的或开始一个斜杠字符（'/'）。否则，新的URI组件可能是未定义的相应的参数传递null。
    
    此构造函数首先构建了一个URI字符串从给定的组件按照RFC 2396规则，部分 5.2步 7：
    1. 最初，结果字符串是空的。
    2. 如果一个设计方案，然后添加到结果，后跟一个冒号（':'）。
    3. 如果一个机构给出的字符串"//"追加，其次是权威。如果权威包含文字的IPv6地址然后地址必须括在方括号（'['和']'）。任何字符不在毫无保留的，穿刺，逃脱，或其他类别，不等于商业性质（'@'），是quoted。
    4. 如果一个路径被给定，然后它被添加。任何字符不在毫无保留的，穿刺，逃脱，或其他类别，不等于斜杠字符（'/'）或商业性质（'@'），引用。
    5. 如果查询再给出一个问号字符（'?'）追加，其次是查询。任何字符，不是legal URI character报价。
    6. 最后，如果一个片段再给出一个哈希（'#'）追加，其次是片段。任何字符，是不是一个合法的URI字符引用。
    由此产生的URI字符串，然后解析如果通过调用构造函数，然后调用URI(String) parseServerAuthority()方法后的结果；这可能会导致URISyntaxException被。
    参数
    
    scheme方案名称
    
    authority -权威
    
    path - 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 - Path
    
    fragment片段
    
    异常
    
    URISyntaxException如果由给定组件的URI字符串违反RFC 2396
  - URI
```
public URI(String scheme,
           String ssp,
           String fragment)
    throws URISyntaxException
```
    从给定的组件构建一个URI。
    一个组件可以通过null未定义。
    
    此构造函数首先建立一个URI字符串形式使用给定的组件如下：
    1. 最初，结果字符串是空的。
    2. 如果一个设计方案，然后添加到结果，后跟一个冒号（':'）。
    3. 如果给定一个方案特定的部分，则它被添加。任何字符，不是legal URI character是quoted。
    4. 最后，如果一个片段再给出一个哈希（'#'）附加到字符串，其次是片段。任何字符，是不是一个合法的URI字符引用。
    由此产生的URI字符串，然后解析为了创造新的URI实例如调用URI(String)构造函数；这可能会导致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
    
    异常
    
    如果是 null str NullPointerException
    
    IllegalArgumentException如果给定字符串违反RFC 2396
  - parseServerAuthority
```
public URI parseServerAuthority()
                         throws URISyntaxException
```
    试图解析这个URI的权限组件，如果定义为用户信息，主机和端口组件。
    如果这个URI的权限组件已经被公认为是基于服务器然后将已经被解析成用户信息、主机和端口组件。在这种情况下，如果这个URI没有权威的组成部分，此方法只返回该URI。
    
    否则，此方法将再次尝试将权限组件解析为用户信息、主机和端口组件，并抛出一个异常来描述为什么权限组件无法以这种方式解析。
    
    这种方法因为通用URI语法指定RFC 2396不能区分一个畸形的基于服务器的权限从一个合法的基于注册表的权限。因此，它必须把前者的某些实例作为后者的实例。例如在URI字符串"//foo:bar"，权力的组成部分，是不是基于权威的法律服务是法律作为一种基于注册表的权限。
    
    在许多常见的情况，比如工作时这些已知是瓮或URL，分层URI使用永远是基于服务器的。因此，他们必须被解析为这样或作为一个错误处理。在这些情况下，一个语句，如
    
    URI u = new URI(str).parseServerAuthority();
    
    可以用来确保你总是指一个URI，如果它有一个权威的组成部分，与适当的用户信息，基于主机的服务器权限，和端口组件。调用此方法还可以确保如果无法以这种方式解析权限，则可以根据引发的异常来发布一个适当的诊断消息。
    
    结果
    
    一个URI的权限字段已被解释为一个基于服务器的权限
    
    异常
    
    URISyntaxException -如果这个URI权限组件定义但不能被解析为一个基于服务器的权限根据RFC 2396
  - normalize
```
public URI normalize()
```
    对这个URI的路径。
    如果URI是不透明的，或者如果它的路径已在正常的形式，那么这个URI返回。否则，一个新的URI的构造，是这个URI相同，除了其路径是在符合RFC 2396这个URI的路径规范计算，部分 5.2步 6，分步骤 C通过 F；：
    1. 所有的"."段被删除。
    2. 如果一个".."段之前，non-".."段然后这两段被删除。这一步骤被重复，直到它不再适用。
    3. 如果路径是相对的，如果第一段包含一个冒号（':'），然后"."段前面。这可以防止相对URI和路径如"a:b/c/d"后来被重新分析为一个与"a"和"b/c/d"方案具体方案（2396请偏差）部分不透明的URI。
    一个规范化的路径将开始与一个或多个".."段如果没有足够的non-".."段前让他们去除。一个规范化的路径将开始一个"."段如果是由以上3步插入。否则，一个规范化的路径将不包含任何"."或".."段。
    结果
    
    一个URI等效这个URI，但其路径是在正常的形式
  - resolve
```
public URI resolve(URI uri)
```
    解决给定URI对这个URI。
    如果给定的URI已经是绝对的，如果这个URI是不透明的，那么给定URI返回。
    
    如果给定URI的片段组成的定义，其路径是空的，其方案，权威，和查询组件是不确定的，那么一个URI与给定的片段，但所有其他组件与此URI返回。这允许一个URI代表一个独立的片段引用，如"#foo"，可以有效地解决对基URI。
    
    否则，该方法建立在符合RFC 2396新层次的URI，部分，5.2：
    1. 一个新的URI是构建这个URI方案和给定的URI的查询和片段组成。
    2. 如果有一个权威组成新的URI的权威和路径是从给定的URI。
    3. 否则新的URI的权限组件是从这个URI复制，其路径计算如下：
      
      如果给定的URI的路径是绝对的那么新的URI的路径是从给定的URI。
      
      否则给定URI的路径是相对的，所以新的URI的路径是通过解决给定URI对这个URI路径计算。这是任何通过连接所有但这个URI的路径，最后一段，与给定的URI的路径然后归一化结果如果通过调用normalize方法。
    这种方法的结果是绝对的如果，如果，这URI是绝对的或给定的URI是绝对的。
    参数
    
    uri的URI来解决对这个URI
    
    结果
    
    由此产生的URI
    
    异常
    
    如果是 null uri NullPointerException
  - resolve
```
public URI resolve(String str)
```
    通过分析给定字符串然后解决它在构造一个新的URI的URI。
    这个方便的方法是如果调用它相当于计算表达式resolve(URI.create(str))。
    
    参数
    
    str -被解析成一个URI字符串
    
    结果
    
    由此产生的URI
    
    异常
    
    如果是 null str NullPointerException
    
    IllegalArgumentException如果给定字符串违反RFC 2396
  - relativize
```
public URI relativize(URI uri)
```
    化给定URI对这个URI。
    的相对化给定URI对这个URI计算如下：
    1. 如果这个URI或给定URI是不透明的，或如果方案和权威的两URI组件是不相同的，或者如果该URI的路径不是一个前缀路径给定的URI，然后给定URI返回。
    2. 否则，一个新的层次构造相对URI查询片段组件从给定的URI和路径组件从给定URI的路径开始删除这个URI的路径计算。
    参数
    
    uri的URI是相对论对这个URI
    
    结果
    
    由此产生的URI
    
    异常
    
    如果是 null uri NullPointerException
  - 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是不透明的，只有当它是绝对的，方案的特定部分，不是以一个斜杠字符（“/”）。一个不透明的有一个方案，一个方案的具体组成部分，可能是一个片段；所有其他组件的定义。
    
    结果
    
    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。
    此方法返回的字符串是否相等，返回除了序列的字节是decoded getRawFragment逃脱的方法。
    
    结果
    
    解码后的片段组成这个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被归一化，分辨率，或相对性创造的，所以一个字符串构造按照RFC 2396规则从这个URI的成分，部分 5.2步 7。
    
    重写：
    
    toString 方法重写，继承类 Object
    
    结果
    
    这个URI的字符串形式
  - toASCIIString
```
public String toASCIIString()
```
    为US-ASCII字符串返回这个URI的内容。
    如果这个URI不包含任何字符，然后其他类此方法的调用将在toString方法调用返回相同的值。否则，该方法是通过调用的方法，然后，如果encoding结果。
    
    结果
    
    这个URI字符串编码为所需要的形式，使其只包含US-ASCII字符集的字符

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

`mailto:java-net@java.sun.com`
`news:comp.lang.java`
`urn:isbn:096139210x`

Class URI

URI语法成分

在URI的实例操作

字符类

逃跑的字节，报价，编码，解码

恒等式

URI、URL，和骨灰盒

构造方法摘要

方法摘要

Methods inherited from class java.lang.Object

Constructor Detail

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