Java 中 HashSet 、LinkedHashSet 和 TreeSet 之间的区别和相似之处

HashSet、LinkedHashSet 和 TreeSet 是主要用于存储元素的集合接口类。

• HashSet − HashSet 是一个容器实例，它仅以非同步方式存储唯一元素，以处理与集合相关的高性能操作。集合允许不遵循插入顺序的空值。

• LinkedHashSet − LinkedHashSet 是一个克隆数据结构，它同时具有哈希表和链接列表的功能作为集合接口。LinkedHashSet 的有序版本始终作为输入元素上的双向链接列表工作。

• TreeSet − TreeSet 是一种排序数据结构，通过使用树形图的存储作为接口工作。该集合遵循一般顺序，其中比较器类使用构造函数设置延迟值。

尽管这些接口类之间存在一些差异，也存在一些相似之处，但我们已尝试在此进行讨论。

示例

Input :
[ ARB, RDD, KOL, DHKA ]

Output :
Insertion Order of objects in HashSet : 
[ ARB, RDD, KOL, DHKA ]
Insertion Order of objects in LinkedHashSet : 
[ ARB, RDD, DHKA, KOL ]
Insertion Order of objects in TreeSet :
[ ARB, DHKA, KOL, RDD ]

HashSet、LinkedHashSet 和 TreeSet 之间的相似之处

HashSet、LinkedHashSet 和 TreeSet 在偏好和操作方式上有很多相似之处。

• 数据集的接口 - HashSet、LinkedHashSet 和 TreeSet 是一些常见的类，它们通过使用继承作为接口应用。

• 无重复 - 这些集合不允许任何重复的内容，因为它们本质上是唯一的。

• 框架 - 这些是一些众所周知的 Java 集合框架，能够以独特的方式提供操作。

HashSet、LinkedHashSet 和 TreeSet 之间的差异

尽管有一些相似之处，但这些集合有很多差异如下所述 -

在这里，我们可以说 HashSet 是一般集合操作中最有效和最突出的过程。另一方面，LinkedHashSet 始终遵循插入方式，其中 TreeSet 以自动结构对元素本身进行排序。

使用的方法

使用插入顺序和插入时间方法

算法

该算法将向您展示使用一些计时器值实现 HashSet、LinkedHashSet 和 TreeSet 结构的系统过程。

• 步骤 1 - 启动该过程。

• 步骤 2 - 声明输入输出流。

• 步骤 3 - 导入内置类和声明的函数。

• 步骤 4 - 声明一个公共类。

• 步骤 5 - 设置函数。

• 步骤 6 - 查找插入顺序。

• 步骤 7 - 声明一个数组列表并填充它。

• 步骤 8 - 声明设置值。

• 步骤 9 - 按照插入方式打印值。

• 步骤 10 - 声明一个循环来迭代该过程。

• 步骤 11 - 设置计时器值。

• 步骤 12 - 运行该过程并获取输出值。

• 步骤 13 - 终止过程。

语法

语法将首先使用一些整数值检查树集。之后，我们将声明一个映射集，从这些元素中创建一些对，以根据免疫力对它们进行过滤。

TreeSet < Integer > STTREE = new TreeSet < > () ;
STTREE . add ( 4 ) ;
STTREE . add ( 5 ) ;
STTREE . add ( 6 ) ;
STTREE . add ( 8 ) ;
STTREE . add ( 4 ) ;

TreeMap < Integer , Integer > MAPTREE = new TreeMap < > () ;
MAPTREE . put ( 2,5 ) ;
MAPTREE . put ( 3,6 ) ;
MAPTREE . put ( 4,6 ) ;
MAPTREE . put ( 2,3 ) ;

使用插入顺序和插入时间方法

插入顺序是用户使用特定插入时间将更多元素添加到数据集的协议。插入时间是一个间隔跨度，用于记录元素所消耗的时间。在这种方法中，我们在链接的哈希集上使用insertionOrder()函数以O(1)时间复杂度执行该过程。

示例

在示例代码中，我们通过使用迭代在特定时间跨度内执行了插入和删除等各种过程，以获得上述映射的差异。

import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
public class ARBRDD {
   private static void insertionOrder (){
      LinkedHashSet < String > ARBRDDLINKEDSET
         = new LinkedHashSet <> ();
      TreeSet <String> ARBRDDTREESET = new TreeSet <> ();
      HashSet <String> ARBRDDHASHSET = new HashSet <String> ();
      for ( String str : Arrays.asList ( "ARB", "RDD", "DHKA", "KOL" ) ) {
         ARBRDDLINKEDSET . add ( str ) ;
         ARBRDDTREESET . add ( str ) ;
         ARBRDDHASHSET . add ( str ) ;
      }
      
      System.out.println ( "Insertion Order " + " of objects in HashSet :" + ARBRDDHASHSET ) ;
      System.out.println ( " Insertion Order of " + "objects in LinkedHashSet : " + ARBRDDLINKEDSET ) ;
      System.out.println ( "Insertion Order of" + " objects in TreeSet : " + ARBRDDTREESET ) ;
   }
   private static void insertionTime () {
      HashSet <Integer> numbersHS = new HashSet <> () ;
      long startTime = System . nanoTime () ;
      for  ( int i = 0; i < 1000; i ++ ) {
         numbersHS . add ( i ) ;
      }
      
      long endTime = System . nanoTime () ;
      System.out.println ( "Total time to insert" + " 1000 elements in" + " HashSet in nanoseconds: " + ( endTime - startTime ) ) ;
      LinkedHashSet <Integer> numbersLLS
         = new LinkedHashSet <> () ;

      startTime = System . nanoTime () ;
      for ( int i = 0; i < 1000; i ++ ) {
         numbersLLS . add ( i ) ;
      }
      
      endTime = System . nanoTime () ;
      System.out.println ( "Total time to insert" + " 1000 elements in" + " LinkedHashSet nanoseconds: " + ( endTime - startTime ) ) ;
      TreeSet <Integer> numbersTS = new TreeSet <> () ;

      startTime = System . nanoTime () ;
      for  ( int i = 0; i < 1000; i++ ) {
         numbersTS . add ( i ) ;
      }
      
      endTime = System . nanoTime () ;
      System.out.println ( "Total time to insert" + " 1000 elements in" + " TreeSet in nanoseconds: " + ( endTime - startTime ) ) ;
   }
   private static void deletion () {
      HashSet <Integer> deletionHS = new HashSet <> () ;

      for ( int i = 0; i < 1000; i ++ ) {
         deletionHS . add ( i ) ;
      }

      long startingTime = System . nanoTime () ;
      for ( int i = 0; i < 1000; i ++ ) {
         deletionHS . remove ( i ) ;
      }

      long endedTime = System . nanoTime () ;
      System.out.println("Total time to Deletion " + "1000 elements in HashSet in nanoseconds : " + Math . abs ( startingTime - endedTime ) ) ;
      LinkedHashSet <Integer> deletionLLS
         = new LinkedHashSet <> () ;

      for ( int i = 0; i < 1000; i ++ ) {
         deletionLLS . add ( i ) ;
      }
      startingTime = System . nanoTime () ;
      for ( int i = 0; i < 1000; i ++ ) {
         deletionLLS . remove ( i ) ;
      }

      endedTime = System . nanoTime () ;
      System.out.println (
         "Total time to Deletion 1000"
         + " elements in LinkedHashSet in nanoseconds: "
         + Math . abs ( startingTime - endedTime ) ) ;
         
      TreeSet <Integer> deletionTS = new TreeSet <> () ;
      for ( int i = 0; i < 1000; i ++ ) {
         deletionTS . add ( i ) ;
      }
      
      startingTime = System . nanoTime () ;
      for ( int i = 0; i < 1000; i ++ ) {
         deletionTS . remove ( i ) ;
      }
      
      endedTime = System . nanoTime () ;
      System.out.println(
         "Total time to Deletion 1000"
         + " elements in TreeSet in nanoseconds: "
         + Math . abs ( startingTime - endedTime ) ) ;
   }
   public static void main ( String args [] ){
      insertionOrder () ;
      insertionTime () ;
      deletion () ;
   }
}

输出

Insertion Order  of objects in HashSet : [ ARB, RDD, KOL, DHKA ]
Insertion Order of objects in LinkedHashSet : [ ARB, RDD, DHKA, KOL ]
Insertion Order of objects in TreeSet : [ ARB, DHKA, KOL, RDD ]
Total time to insert 1000 elements in HashSet in nanoseconds : 584880
Total time to insert 1000 elements in LinkedHashSet nanoseconds : 343136
Total time to insert 1000 elements in TreeSet in nanoseconds : 1445318
Total time to Deletion 1000 elements in HashSet in nanoseconds : 339148
Total time to Deletion 1000 elements in LinkedHashSet in nanoseconds : 261723
Total time to Deletion 1000 elements in TreeSet in nanoseconds : 877681

结论

因此，在今天的这篇文章中，我们将了解 HashSet 、 LinkedHashSet 和 TreeSet 之间的显著差异。它们之间也有很多相似之处，因为它们都实现了 Set 接口。这三种结构不允许重复，并且不同步。我们可以使用迭代器克隆它们并调整它们的大小，因为这些数据集本质上是先失败的。

相关文章

• Java 中 IdentityHashMap、WeakHashMap 和 EnumMap 之间的区别
• Java 中继承和接口的区别
• Java 中 InputStream 和 OutputStream 之间的区别
• Java 中 HashSet 、LinkedHashSet 和 TreeSet 之间的区别和相似之处
• Java 中 HashMap 和 IdentityHashMap 之间的区别
• Java 中 Hashtable 和同步映射之间的区别
• 如何在 Java 中迭代 LinkedHashMap?
• 如何使用反射动态地通过名称调用 Java 中的方法?
• 如何在 Java 中以相反的顺序迭代向量元素?
• 如何在 Java 中以反向顺序迭代 LinkedHashMap?