JAVA网Java中的URI类-yiteyi-C++库

此类提供了从其组件创建URI实例的方法，或通过解析这些组件的字符串形式来访问和检索URI实例的不同组件的方法。 什么是乌里？ URI代表统一资源标识符。统一资源标识符是用于标识特定资源的字符序列。它支持使用特定协议通过网络进行资源表示的交互。

null

URI、URL和URN：有什么区别？

你必须想到的问题是，如果URI标识了一个资源，URL会做什么？人们经常交替使用这些术语，但这是不正确的。根据蒂姆·伯纳斯·李

“统一资源标识符（URI）是一个紧凑的字符序列，用于标识抽象资源或物理资源。” “URI还可以进一步分类为定位器、名称或两者。术语“统一资源定位器”（URL）指的是URI子集，它通过资源的主要访问机制（例如，其网络“位置”）的表示来识别资源，而不是通过名称或该资源的某些其他属性来识别资源。术语“统一资源名”（Uniform Resource Name，URN）指的是URI的子集，即使资源不再存在或变得不可用，它也需要保持全局唯一性和持久性。”

例如

https://www.geeksforgeeks.org/url-class-java-examples/

表示一个URL，因为它告诉在网络上可以找到URL类文章的确切位置。

url-class-java-examples

表示URN，因为它不告诉任何有关位置的信息，只为资源提供唯一的名称。

URI类的对象和URL类之间的区别在于，URI字符串的解析只考虑语法，在创建时不执行主机查找。两个URI对象的比较仅对字符串中包含的字符进行。但另一方面，URL字符串是用特定的模式解析的，两个URL对象的比较是通过查看网络上的实际资源来执行的。

URI语法：

scheme:[//[user:password@]host[:port]][/]path[?query][#fragment]

方案： scheme组件列出了与URI关联的协议。在一些方案中，“/”是必需的，而其他方案则不需要。
```
abc://admin:admin@geeksforgeeks.org:1234/path/data
             ?key=value&key2=value2#fragid1
```
授权： Authority组件由几个组件组成——身份验证部分、一个主机和可选端口号，前面有一个“：”。身份验证部分包括用户名和密码。主机可以是任何ip地址。
```
abc://admin:admin@geeksforgeeks.org:1234/path/data
             ?key=value&key2=value2#fragid1
```

路径： 路径表示一个字符串，其中包含服务器中指向资源的地址。

abc://admin:admin@geeksforgeeks.org:1234/path/data
             ?key=value&key2=value2#fragid1

查询： 查询表示非层次数据，通常是用于搜索特定资源的查询。它们之间用“？”隔开从上一部分开始。
```
abc://admin:admin@geeksforgeeks.org:1234/path/data
             ?key=value&key2=value2#fragid1
```

片段： 片段用于将次要资源标识为页面中的标题或副标题等。

abc://admin:admin@geeksforgeeks.org:1234/path/data
             ?key=value&key2=value2#fragid1

施工人员：

URI（字符串str） ：通过解析指定的字符串来构造URI对象。解析时使用的语法是RFC 2396附录A中指定的语法。

Syntax :public URI(String str)
    throws URISyntaxException
Parameters : 
str : String to be parsed into URI
Throws : 
URISyntaxException : If the string violates RFC 2396

URI（字符串方案、字符串ssp、字符串片段） ：从给定组件构造URI。通过传递null，组件可能未定义。最初，结果字符串为空。如果scheme不为null，则追加它。类似地，如果提供ssp和片段部分，则附加ssp和片段部分。
```
Syntax :public URI(String scheme, String ssp, String fragment)
    throws URISyntaxException
Parameters : 
scheme : scheme name
ssp : scheme-specific part
fragment : fragment part
Throws : 
URISyntaxException : If the URI string constructed from the given
 components violates RFC 2396
```
类似地，根据创建时已知的组件提供其他构造函数。

URI（字符串方案、字符串用户信息、字符串主机、int端口、字符串路径、，字符串查询，字符串片段）

Syntax :public URI(String scheme, String userInfo, String host, int port, 
      String path, String query, String fragment)
Parameters :
scheme : string representing scheme
userInfo : userinfo of URI
host : host component of URI
port : listening port number
path : path of URI
query : String representing the query part
fragment :optional fragment

URI（字符串方案、字符串主机、字符串路径、字符串片段）

Syntax :public URI(String scheme, String host, String path, String fragment)
Parameters :
scheme : string representing scheme
host : host component of URI
path : path of URI
fragment :optional fragment

URI（字符串方案、字符串权限、字符串路径、字符串查询、字符串片段）

Syntax :public URI(String scheme, String authority, String path,
 String query, String fragment)
Parameters :
scheme : string representing scheme
authority : authority
path : path of URI
query : String representing the query part

方法：

create（）： 创建一个新的URI对象。这个方法可以称为伪构造函数。当已知给定字符串将作为URI对象进行解析，并且如果它不进行解析，将被视为程序员错误时，可以使用它。
```
Syntax : public static URI create(String str)
Parameters :
str : String to be parsed as URI
```
parseServerAuthority（）： 此方法用于将URI的权限组件解析为用户信息、主机和端口组件。此方法返回一个URI对象，其权限字段已被解析为基于服务器的权限。
```
Syntax : public URI parseServerAuthority()
```
normalize（）： 规范化此URI的路径。URI是通过规范化URI的路径构建的，该路径与RFC 2396一致。返回一个规范化的URI对象。
```
Syntax : public URI normalize()
```
解析（）： 用这个URI解析给定的URI。以与RFC 2396一致的方式返回新的分层URI。
```
Syntax : public URI resolve(URI uri)
Parameters :
uri : URI to be resolved
```
另一个重载方法，它以字符串作为参数，相当于调用resolve（URI.create（str））。
```
Syntax : public URI resolve(String str)
Parameters :
str : String to be parsed as URI
```
相对化（）： 将给定URI与此URI相对化。
```
Syntax : public URI relativize(URI uri)
```
参数： uri：相对化的uri

图尔（）： 从这个URI构造一个URL。

Syntax : public URL toURL()
          throws MalformedURLException
Throws :
MalformedURLException : If error occurs while constructing URL

getScheme（）： 返回URI的scheme组件
```
Syntax : public String getScheme()
```
getRawSchemeSpecificPart（）： 返回URI的原始方案特定组件。
```
Syntax : public String getRawSchemeSpecificPart()
```
getSchemeSpecificPart（）： 返回URI的解码方案特定组件
```
Syntax : public String getSchemeSpecificPart()
```
getRawAuthority（）： 返回URI的授权组件。如果授权基于服务器，则会返回更多用户信息、主机和端口组件。
```
Syntax : public String getRawAuthority()
```
getAuthority（）： 返回与上述方法完全相似的结果，但解码后的结果除外。
```
Syntax : public String getAuthority()
```
getRawUserInfo（）： 返回URI的用户信息组件，如果未定义，则返回null。
```
Syntax : public String getRawUserInfo()
```

getUserInfo（）： 以解码形式返回URI的用户信息组件，如果未定义，则返回null。

Syntax : public String getUserInfo()

Java实现：

                         // Java program to illustrate various                       
                         // URI class methods                       
                         import                                     java.net.*;                       
                                   
                         class                                     uridemo1                       
                         {                       
                                                 public                                     static                                     void                                     main(String[] args)                                     throws                                     Exception                       
                                                 {                       
                                                 String uribase =                                     "                           https://www.geeksforgeeks.org/                          "                                     ;                       
                                                 String urirelative =                                     "languages/../java"                                     ;                       
                                                 String str =                                     "                           https://www.google.co.in/?gws_rd=ssl#                          "                                     +                                     ""                       
                                                 +                                     "q=networking+in+java+geeksforgeeks"                                     +                                     ""                       
                                                 +                                     "&spf=1496918039682"                                     ;                       
                                   
                                                 // Constructor to create a new URI                       
                                                 // by parsing the string                       
                                                 URI uriBase =                                     new                                     URI(uribase);                       
                                   
                                                 // create() method                       
                                                 URI uri = URI.create(str);                       
                                   
                                                 // toString() method                       
                                                 System.out.println(                                     "Base URI = "                                     + uriBase.toString());                       
                                   
                                                 URI uriRelative =                                     new                                     URI(urirelative);                       
                                                 System.out.println(                                     "Relative URI = "                                     + uriRelative.toString());                       
                                   
                                                 // resolve() method                       
                                                 URI uriResolved = uriBase.resolve(uriRelative);                       
                                                 System.out.println(                                     "Resolved URI = "                                     + uriResolved.toString());                       
                                   
                                                 // relativized() method                       
                                                 URI uriRelativized = uriBase.relativize(uriResolved);                       
                                                 System.out.println(                                     "Relativized URI = "                                     + uriRelativized.toString());                       
                                   
                                                 // normalize() method                       
                                                 System.out.println(uri.normalize().toString());                       
                                   
                                                 // getScheme() method                       
                                                 System.out.println(                                     "Scheme = "                                     + uri.getScheme());                       
                                   
                                                 // getRawShemeSpecific() method                       
                                                 System.out.println(                                     "Raw Scheme = "                                     + uri.getRawSchemeSpecificPart());                       
                                   
                                                 // getSchemeSpecificPart() method                       
                                                 System.out.println(                                     "Scheme-specific part = "                                     + uri.getSchemeSpecificPart());                       
                                   
                                                 // getRawUserInfo() method                       
                                                 System.out.println(                                     "Raw User Info = "                                     + uri.getRawUserInfo());                       
                                   
                                                 // getUserInfo() method                       
                                                 System.out.println(                                     "User Info = "                                     + uri.getUserInfo());                       
                                   
                                                 // getAuthority() method                       
                                                 System.out.println(                                     "Authority = "                                     + uri.getAuthority());                       
                                   
                                                 // getRawAuthority() method                       
                                                 System.out.println(                                     "Raw Authority = "                                     + uri.getRawAuthority());                       
                                   
                                                 }                       
                         }                       

输出：

Base URI = https://www.geeksforgeeks.org/
Relative URI = languages/../java
Resolved URI = https://www.geeksforgeeks.org/java
Relativized URI = java
https://www.google.co.in/?gws_rd=ssl#q=networking+in+
java+geeksforgeeks&spf=1496918039682
Scheme = https
Raw Scheme = //www.google.co.in/?gws_rd=ssl
Scheme-specific part = //www.google.co.in/?gws_rd=ssl
Raw User Info = null
User Info = null
Authority = www.google.co.in
Raw Authority = www.google.co.in

getHost（）： 返回URI的主机组件。由于URI的主机组件不能包含转义的八位字节，因此该方法不执行任何解码。
```
Syntax : public String getHost()
```
getPort（）： 返回此URI的端口号。
```
Syntax : public int getPort()
```
getRawPath（）： 返回此URI的原始路径，如果未定义，则返回null。
```
Syntax : public String getRawPath()
```
getPath（）： 返回此URI的解码路径组件。
```
Syntax : public String getPath()
```
getRawQuery（）： 返回URI的查询组件，如果未定义，则返回null。
```
Syntax : public String getRawQuery()
```
getQuery（）： 以解码形式返回URI的查询组件，如果未定义，则返回null。
```
Syntax : public String getQuery()
```
getRawFragment（）： 返回URI的片段组件，如果未定义，则返回null。
```
Syntax : public String getRawFragment()
```
getFragment（）： 返回此URI的解码片段组件，如果未定义，则返回null。
```
Syntax : public String getFragment()
```
比较（）： 将此URI对象与另一个URI对象进行比较。根据字符串的自然顺序进行比较。compareTo（）方法。如果一个组件未定义，而另一个组件已定义，则认为第一个组件小于第二个组件。要分析的组件以原始形式而不是编码形式进行比较。
```
Syntax : public int compareTo(URI uri)
Parameters :
uri : URI to be compared with
```
等于（）： 使用此URI测试给定对象。如果对象不是URI，则返回false。要将两个URI视为相等，需要两者都是不透明的，或者都是分层的。当检查不同组件的相等性时，会考虑它们的原始形式，而不是编码形式。
```
Syntax : public boolean equals(Object ob)
Parameters :
ob : object to be compared for equality
```
isAbsolute（）： 如果此URI是绝对的，则返回true，否则返回false。URI是绝对的当且仅当它有一个scheme组件。
```
Syntax : public boolean isAbsolute()
```
isOpaque（）： 如果此URI不透明，则返回true，否则返回false。当且仅当URI是绝对的且其特定于方案的部分不以斜杠字符（“/”开头时，URI是不透明的
```
Syntax : public boolean isOpaque()
```
hashCode（）： 返回此URI对象的哈希代码。在为URI对象创建哈希代码时，会考虑所有组件。
```
Syntax : public int hashCode()
```
toString（）： 返回此URI对象的字符串表示形式。
```
Syntax : public String toString()
```

Toasciisting（）： 返回ASCII格式的字符串表示形式。

Syntax : public String toASCIIString()

Java实现 :

                         //Java Program to illustrate various                       
                         //URI class methods                       
                         import                                     java.net.*;                       
                         class                                     uridemo1                       
                         {                       
                                                 public                                     static                                     void                                     main(String[] args)                                     throws                                     Exception                       
                                                 {                       
                                                 String str =                                     "                           https://www.google.co.in/?gws_rd=ssl#                          "                                     +                                     ""                       
                                                 +                                     "q=networking+in+java+geeksforgeeks"                                     +                                     ""                       
                                                 +                                     "&spf=1496918039682"                                     ;                       
                                   
                                                 // Constructor to create a new URI                       
                                                 // by parsing the given string.                       
                                                 URI uri =                                     new                                     URI(str);                       
                                   
                                                 // getHost() method                       
                                                 System.out.println(                                     "Host = "                                     + uri.getHost());                       
                                   
                                                 // getPort() method                       
                                                 System.out.println(                                     "Port = "                                     + uri.getPath());                       
                                   
                                                 // getRawPath() method                       
                                                 System.out.println(                                     "Raw Path = "                                     + uri.getRawPath());                       
                                   
                                                 // getPath() method                       
                                                 System.out.println(                                     "Path = "                                     + uri.getPath());                       
                                   
                                                 // getQuery() method                       
                                                 System.out.println(                                     "Query = "                                     + uri.getQuery());                       
                                   
                                                 // getRawQuery() method                       
                                                 System.out.println(                                     "Raw Query = "                                     + uri.getRawQuery());                       
                                   
                                                 // getFragment() method                       
                                                 System.out.println(                                     "Fragment = "                                     + uri.getFragment());                       
                                   
                                                 // getRawFragment() method                       
                                                 System.out.println(                                     "Raw Fragment = "                                     + uri.getRawFragment());                       
                                   
                                                 URI uri2 =                                     new                                     URI(str +                                     "fr"                                     );                       
                                   
                                                 // compareTo() mrthod                       
                                                 System.out.println(                                     "CompareTo ="                                     + uri.compareTo(uri2));                       
                                   
                                                 // equals() method                       
                                                 System.out.println(                                     "Equals = "                                     + uri.equals(uri2));                       
                                   
                                                 // hashcode() method                       
                                                 System.out.println(                                     "Hashcode : "                                     + uri.hashCode());                       
                                   
                                                 // toString() method                       
                                                 System.out.println(                                     "toString : "                                     + uri.toString());                       
                                   
                                                 // toASCIIString() method                       
                                                 System.out.println(                                     "toASCIIString : "                                     + uri.toASCIIString());                       
                                   
                                                 }                       
                         }                       

输出：

Host = www.google.co.in
Port = /
Raw Path = /
Path = /
Query = gws_rd=ssl
Raw Query = gws_rd=ssl
Fragment = q=networking+in+java+geeksforgeeks&spf=1496918039682
Raw Fragment = q=networking+in+java+geeksforgeeks&spf=1496918039682
CompareTo =-2
Equals = false
Hashcode : 480379574
toString : https://www.google.co.in/?gws_rd=ssl#q=networking+
in+java+geeksforgeeks&spf=1496918039682
toASCIIString : https://www.google.co.in/?gws_rd=ssl#q=
networking+in+java+geeksforgeeks&spf=1496918039682

参考资料： 官方Java文档

本文由 Rishabh Mahrsee .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java