Java中的NavigableSet及其示例-yiteyi-C++库

NavigableSet表示中的可导航集集合框架 .NavigableSet接口继承自分类数据集接口。它的行为类似于SortedSet，但除了SortedSet的排序机制外，我们还有可用的导航方法。例如，与SortedSet中定义的顺序相比，NavigableSet接口可以以相反的顺序导航集合。可以按升序或降序访问和遍历NavigableSet。实现这个接口的类是，有序树和 ConcurrentSkipListSet

null

NavigableSet in Java with Examples

这里，E是由该集合维护的元素类型。

所有高级界面：

收藏，可编辑，设置 , SortedSet

所有已知的实现类：

ConcurrentSkipListSet , 树集

宣言： NavigableSet被宣布为

公共接口NavigableSet 扩展了SortedSet

创建NavigableSet对象

由于NavigableSet是一个接口，因此无法创建NavigableSet类型的对象。为了创建一个对象，我们总是需要一个扩展这个列表的类。而且，在Java 1.5中引入泛型之后，可以限制可存储在NavigableSet中的对象类型。这种类型的安全设置可以定义为：

//Obj是要存储在NavigableSet中的对象类型

NavigableSet set=新树集（）；

例子：

JAVA

                         // Java program to demonstrate                       
                         // the working of NavigableSet                       
                         import                                     java.util.NavigableSet;                       
                         import                                     java.util.TreeSet;                       
           
                         public                                     class                                     NavigableSetDemo                       
                         {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 NavigableSet<Integer> ns =                                     new                                     TreeSet<>();                       
                                                 ns.add(                                     0                                     );                       
                                                 ns.add(                                     1                                     );                       
                                                 ns.add(                                     2                                     );                       
                                                 ns.add(                                     3                                     );                       
                                                 ns.add(                                     4                                     );                       
                                                 ns.add(                                     5                                     );                       
                                                 ns.add(                                     6                                     );                       
           
                                                 // Get a reverse view of the navigable set                       
                                                 NavigableSet<Integer> reverseNs = ns.descendingSet();                       
           
                                                 // Print the normal and reverse views                       
                                                 System.out.println(                                     "Normal order: "                                     + ns);                       
                                                 System.out.println(                                     "Reverse order: "                                     + reverseNs);                       
           
                                                 NavigableSet<Integer> threeOrMore = ns.tailSet(                                     3                                     ,                                     true                                     );                       
                                                 System.out.println(                                     "3 or  more:  "                                     + threeOrMore);                       
                                                 System.out.println(                                     "lower(3): "                                     + ns.lower(                                     3                                     ));                       
                                                 System.out.println(                                     "floor(3): "                                     + ns.floor(                                     3                                     ));                       
                                                 System.out.println(                                     "higher(3): "                                     + ns.higher(                                     3                                     ));                       
                                                 System.out.println(                                     "ceiling(3): "                                     + ns.ceiling(                                     3                                     ));                       
           
                                                 System.out.println(                                     "pollFirst(): "                                     + ns.pollFirst());                       
                                                 System.out.println(                                     "Navigable Set:  "                                     + ns);                       
           
                                                 System.out.println(                                     "pollLast(): "                                     + ns.pollLast());                       
                                                 System.out.println(                                     "Navigable Set:  "                                     + ns);                       
           
                                                 System.out.println(                                     "pollFirst(): "                                     + ns.pollFirst());                       
                                                 System.out.println(                                     "Navigable Set:  "                                     + ns);                       
           
                                                 System.out.println(                                     "pollFirst(): "                                     + ns.pollFirst());                       
                                                 System.out.println(                                     "Navigable Set:  "                                     + ns);                       
           
                                                 System.out.println(                                     "pollFirst(): "                                     + ns.pollFirst());                       
                                                 System.out.println(                                     "Navigable Set:  "                                     + ns);                       
           
                                                 System.out.println(                                     "pollFirst(): "                                     + ns.pollFirst());                       
                                                 System.out.println(                                     "pollLast(): "                                     + ns.pollLast());                       
                                                 }                       
                         }                       

输出

Normal order: [0, 1, 2, 3, 4, 5, 6]Reverse order: [6, 5, 4, 3, 2, 1, 0]3 or  more:  [3, 4, 5, 6]lower(3): 2floor(3): 3higher(3): 4ceiling(3): 3pollFirst(): 0Navigable Set:  [1, 2, 3, 4, 5, 6]pollLast(): 6Navigable Set:  [1, 2, 3, 4, 5]pollFirst(): 1Navigable Set:  [2, 3, 4, 5]pollFirst(): 2Navigable Set:  [3, 4, 5]pollFirst(): 3Navigable Set:  [4, 5]pollFirst(): 4pollLast(): 5

在NavigableSet上执行各种操作

由于NavigableSet是一个接口，因此它只能与实现该接口的类一起使用。TreeSet是实现NavigableSet接口的类。现在，让我们看看如何在TreeSet上执行一些常用的操作。

1.添加元素： 为了向NavigableSet添加元素，我们可以使用添加（）方法但是，插入顺序不会保留在树集中。在内部，每个元素的值都会按升序进行比较和排序。我们需要注意的是，不允许重复元素，并且忽略所有重复元素。此外，NavigableSet不接受空值。

JAVA

                         // Java code to demonstrate                       
                         // adding of elements in                       
                         // NavigableSet                       
                         import                                     java.util.*;                       
                         import                                     java.io.*;                       
           
                         class                                     NavigableSetDemo {                       
           
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 NavigableSet<String> ts =                                     new                                     TreeSet<String>();                       
           
                                                 // Elements are added using add() method                       
                                                 ts.add(                                     "A"                                     );                       
                                                 ts.add(                                     "B"                                     );                       
                                                 ts.add(                                     "C"                                     );                       
                                                 ts.add(                                     "A"                                     );                       
           
                                                 System.out.println(ts);                       
                                                 }                       
                         }                       

输出：

[A, B, C]

2.访问元素： 在添加元素之后，如果我们希望访问这些元素，我们可以使用内置方法，比如contains（）、first（）、last（）等。

JAVA

                         // Java program to access                       
                         // the elements of NavigableSet                       
                         import                                     java.util.*;                       
                         import                                     java.io.*;                       
           
                         class                                     NavigableSetDemo {                       
           
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 NavigableSet<String> ts =                                     new                                     TreeSet<String>();                       
           
                                                 // Elements are added using add() method                       
                                                 ts.add(                                     "A"                                     );                       
                                                 ts.add(                                     "B"                                     );                       
                                                 ts.add(                                     "C"                                     );                       
                                                 ts.add(                                     "A"                                     );                       
           
                                                 System.out.println(                                     "Navigable Set is "                                     + ts);                       
           
                                                 String check =                                     "D"                                     ;                       
           
                                                 // Check if the above string exists in                       
                                                 // the NavigableSet or not                       
                                                 System.out.println(                                     "Contains "                                     + check +                                     " "                       
                                                 + ts.contains(check));                       
           
                                                 // Print the first element in                       
                                                 // the NavigableSet                       
                                                 System.out.println(                                     "First Value "                                     + ts.first());                       
           
                                                 // Print the last element in                       
                                                 // the NavigableSet                       
                                                 System.out.println(                                     "Last Value "                                     + ts.last());                       
                                                 }                       
                         }                       

输出：

Navigable Set is [A, B, C]Contains D falseFirst Value ALast Value C

3.删除值： 可以使用remove（）、pollFirst（）和pollLast（）方法从NavigableSet中删除这些值。

JAVA

                         // Java Program to remove the                       
                         // elements from NavigableSet                       
                         import                                     java.util.*;                       
                         import                                     java.io.*;                       
           
                         class                                     NavigableSetDemo {                       
           
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 NavigableSet<String> ts =                                     new                                     TreeSet<String>();                       
           
                                                 // Elements are added using add() method                       
                                                 ts.add(                                     "A"                                     );                       
                                                 ts.add(                                     "B"                                     );                       
                                                 ts.add(                                     "C"                                     );                       
                                                 ts.add(                                     "B"                                     );                       
                                                 ts.add(                                     "D"                                     );                       
                                                 ts.add(                                     "E"                                     );                       
           
                                                 System.out.println(                                     "Initial TreeSet "                                     + ts);                       
           
                                                 // Removing the element b                       
                                                 ts.remove(                                     "B"                                     );                       
           
                                                 System.out.println(                                     "After removing element "                                     + ts);                       
           
                                                 // Remove the First element of TreeSet                       
                                                 ts.pollFirst();                       
           
                                                 System.out.println(                       
                                                 "After the removal of First Element "                                     + ts);                       
           
                                                 // Remove the Last element of TreeSet                       
                                                 ts.pollLast();                       
           
                                                 System.out.println(                       
                                                 "After the removal of Last Element "                                     + ts);                       
                                                 }                       
                         }                       

输出：

Initial TreeSet [A, B, C, D, E]After removing element [A, C, D, E]After the removal of First Element [C, D, E]After the removal of Last Element [C, D]

4.遍历NavigableSet： 有多种方法可以迭代NavigableSet。最著名的是使用增强的for循环。

JAVA

                         // Java program to iterate                       
                         // through NavigableSet                       
           
                         import                                     java.util.*;                       
                         import                                     java.io.*;                       
           
                         class                                     NavigableSetDemo {                       
                                   
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 NavigableSet<String> ts =                                     new                                     TreeSet<String>();                       
           
                                                 // Elements are added using add() method                       
                                                 ts.add(                                     "C"                                     );                       
                                                 ts.add(                                     "D"                                     );                       
                                                 ts.add(                                     "E"                                     );                       
                                                 ts.add(                                     "A"                                     );                       
                                                 ts.add(                                     "B"                                     );                       
                                                 ts.add(                                     "Z"                                     );                       
           
                                                 // Iterating though the NavigableSet                       
                                                 for                                     (String value : ts)                       
                                                 System.out.print(value +                                     ", "                                     );                       
                                                 System.out.println();                       
                                                 }                       
                         }                       

输出：

A, B, C, D, E, Z,

通航集方法

以下是NavigableSet界面中的方法。

方法	描述
天花板（E）	返回此集合中大于或等于给定元素的最小元素，如果没有此类元素，则返回null。
下降迭代器（）	按降序返回此集合中元素的迭代器。
下降集（）	返回此集合中包含的元素的逆序视图。
地板（E）	返回此集合中小于或等于给定元素的最大元素，如果没有此类元素，则返回null。
头戴式耳机（E）	返回此集合中元素严格小于toElement的部分的视图。
头戴式耳机（E-toElement，含布尔值）	返回此集合中元素小于（或等于，如果inclusive为true）toElement的部分的视图。
较高的（E）	返回此集合中严格大于给定元素的最小元素，如果没有此类元素，则返回null。
迭代器（）	按升序返回此集合中元素的迭代器。
降低（E）	返回该集合中严格小于给定元素的最大元素，如果没有此类元素，则返回null。
pollFirst（）	检索并删除第一个（最低）元素，如果此集合为空，则返回null。
pollLast（）	检索并删除最后一个（最高）元素，如果此集合为空，则返回null。
子集（E）元素，布尔值 fromInclusive、E-toElement、boolean-toInclusive）	返回此集合中元素范围从Element到toElement的部分的视图。
子集（E from元素，E toElement）	返回此集合中元素范围从fromElement，inclusive到toElement，exclusive的部分的视图。
尾翼（E from元素）	返回此集合中元素大于或等于fromElement的部分的视图。
尾翼（E from元素，包含布尔值）	返回此集合中元素大于（或等于，如果inclusive为true）fromElement的部分的视图。

方法继承自java接口。util。分类集

方法	描述
比较器（）	此方法返回用于对该集合中的元素进行排序的比较器，如果该集合使用其元素的自然排序，则返回null。
第一（）	此方法返回此集合中的第一个（最低）元素。
最后（）	此方法返回集合中存在的最后一个（最高）元素。
拆分器（）	在该排序集中的元素上创建拆分器。

方法继承自java接口。util。设置

方法	描述
添加（元素）	此方法用于向集合中添加特定元素。仅当指定的元素在集合中不存在时，函数才会添加该元素；否则，如果元素在集合中已存在，函数将返回False。
addAll（收藏）	此方法用于将上述集合中的所有元素附加到现有集合中。元素是随机添加的，不遵循任何特定顺序。
清除（）	此方法用于删除集合中的所有元素，但不删除集合。集合的引用仍然存在。
包含（元素）	此方法用于检查集合中是否存在特定元素。
CONTANSALL（收藏）	此方法用于检查集合是否包含给定集合中的所有元素。如果集合包含所有元素，则此方法返回true；如果缺少任何元素，则返回false。
等于	将指定的对象与此集合进行相等性比较。
hashCode（）	此方法用于获取集合的此实例的hashCode值。它返回一个整数值，该整数值是集合的这个实例的hashCode值。
isEmpty（）	此方法用于检查NavigableSet是否为空。
移除（元素）	此方法用于从集合中删除给定元素。如果集合中存在指定的元素，则此方法返回True，否则返回False。
removeAll（收藏）	此方法用于从集合中删除集合中存在的所有元素。如果此集合因调用而更改，则此方法返回true。
保留（收藏）	此方法用于保留给定集合中提到的集合中的所有元素。如果此集合因调用而更改，则此方法返回true。
大小（）	此方法用于获取集合的大小。这将返回一个表示元素数的整数值。
toArray（）	此方法用于形成与集合相同元素的数组。
托雷（T[]a）	返回包含此集合中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

在java接口中声明的方法。util。收集

方法	描述
parallelStream（）	返回一个可能与此集合并行的流作为其源。
移除（谓词过滤器）	删除此集合中满足给定谓词的所有元素。
流（）	返回以此集合为源的连续流。
托雷（IntFunction 生成器）	使用提供的生成器函数分配返回的数组，返回包含此集合中所有元素的数组。

在java接口中声明的方法。lang.Iterable

方法	描述
弗雷奇（消费者行动）	对Iterable的每个元素执行给定的操作，直到所有元素都已处理或该操作引发异常。

本文由 普拉蒂克·阿加瓦尔 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

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

THE END

Java