LinkedHashMap 与 LinkedHashSet 用于检索特定元素并按插入顺序检索

Question

我正在做一个显然需要使用 Set 的问题，但我需要按插入顺序从集合中检索元素 + 检索特定元素。

但是找到特定元素太慢了（我猜是O(n)，因为我必须遍历整个集合才能找到并返回它）。

所以我选择了LinkedHashMap<someClass,someClass>，其中键值映射包含相同的对象。

虽然这样更快，但它占用了两倍的内存，如果我的键/值（无论如何都相同）碰巧占用了大量空间，这尤其令人担忧。

我希望是否有人对我的问题或优化有更好的解决方案。

编辑： 顺便说一句，SO answer 的 cmets 可能会有所帮助

编辑：

 public Set<CompanyDummy> run(int numberOfCompanies) 
 {
        Set<CompanyDummy> companies=new LinkedHashSet<>();
        
        //Create companies
        CompanyDummy company;
        for(int idx=0;idx<=numberOfCompanies-1;idx++)
        {
            company=new CompanyDummy(idx);
            companies.add(company);
        }
        
        
        //Some code here to fill up each CompanyDummy element with engineers
        
        //At this point,there will be input 
        //specifying which companies to merge via their index(not reference)
        //Problem guarantees those companies exist. Hence, my reason why 
        //I didn't  do something like
        //if (set.contains(value)) return value;
        
        //Do note when we merge companies u & v, v is closed down
        
        for(int idx=0;idx<=transactions-1;idx++)
        {
            companyID= scanner.nextInt();
            anotherCompanyID= scanner.nextInt();
            
            //This part is where I search through companies to find if one exists
            //which is O(n)
            //Replacing sets with maps somehow makes the program faster
            //despite LinkedHashSet being backed by LinkedHashMap
            company=findCompany(companies, companyID);
            anotherCompany=findCompany(companies, anotherCompanyID);
            
            if(company!=null && anotherCompany!=null)
            {
                company.union(anotherCompany);
                companies.remove(anotherCompany);
            }
            

        }
 }
 
 private CompanyDummy findCompany(Set<CompanyDummy> companies,int id)
 {
        
        for(CompanyDummy company : companies)
        {
            if(company.getIndex()==id)
            {
                return company;
            }
        }
        
        return null;
  }

}

---

class CompanyDummy
{
private int index;
private Set<Integer> engineers;//The Integer here just denotes the engineer

public  CompanyDummy(int index) 
{
    this.index=index;
}

public int getindex()
{
    return index;
}

public void union(CompanyDummy someCompany)
{
    this.engineers.addAll(someCompany.engineers);
}

}

Answer 1

好的，所以现在我看到了代码，我可以很好地理解问题并给你一个解决方案。

您不只是从集合中检索特定元素。如果它是集合的成员，则实际上是在特定字段中检索具有特定值的元素。这就是为什么您不能使用集合（或地图）的快速查找操作¹。

解决方案：

如果您想以比O(N) 更好的方式进行检索，则需要Map<Integer, CompanyDummy>。必须填充该映射，以便它从id 映射到CompanyDummy，并将id 作为其index。然后您可以将findCompany 调用替换为Map.get 调用。

请注意，将Set<CompanyDummy> 替换为Map<CompanyDummy, CompanyDummy> 将无助于解决此问题。两者都会给你O(N) 性能。

---

您是这样评价您的实验，将LinkedHashSet<CompanyDummy> 替换为LinkedHashMap<CompanyDummy, CompanyDummy>：

虽然这样更快，但它占用了两倍的内存，如果我的键/值（无论如何都一样）碰巧占用了大量空间，这尤其令人担忧。

我怀疑这两件事是否真的是真的。

1. 两个数据结构的空间利用率应该相同，因为LinkedHashSet 实际上是LinkedHashMap。

2. （IMO）不太可能在性能上存在显着的真正差异。当然不是2倍的差异。最可能的解释是，您测量和比较性能的方法确实适当考虑了由（各种）JVM 启动开销引起的可能的时序失真；例如类加载、堆大小调整、垃圾回收和 JIT 编译。

---

^{1 - 只是为了完整起见，如果不要求您的集合/地图按插入顺序排序，您可以使用 TreeSet<CompanyDummy> 和自定义 Comparator 来订购 CompanyDummy 对象他们的index 值。然后你可以使用OrderedSet.ceiling 和一个虚拟的CompanyDummy 实例来探测O(logN) 中的集合。}

Answer 2

在java中，HashSet是使用HashMap实现的。

HashSet 确实不适用于特定元素检索。映射中的键应该是标识映射到它的值对象的东西。此外，将复杂对象用作映射键通常不是一个好主意，除非您有一个非常好的 HashCode() 实现。

map 也不会维护插入顺序（LinkedHashMap 可能会保留它，因为它由 LinkedList 支持）。您可以将键设置为表示插入顺序的整数序列。例如：

Map<Integer, SomeClass> map = new HashMap<>();
map.put(0, object1);
map.put(1, object2);

等等。这将比 LinkedList 更好，因为获取时间是 O(1)。稍后，您可以在带有运行索引的 for 循环中获取它们，以按插入顺序获取它们。

如果您需要 HashSet 的属性来防止集合中的重复，您将需要保留每个对象的某个唯一标识符的 Set。例如一个人的 ID#。在将每个对象插入地图之前，您还要检查“唯一键”是否不在集合中，如果是，则将“唯一键”插入集合和地图。这一切都取决于您的对象的性质。

如果您需要其他任何东西，请在 cmets 中告诉我。祝你好运！

Answer 3

虽然这样更快，但它占用了两倍的内存，如果我的键/值（无论如何都相同）碰巧占用了大量空间，这尤其令人担忧。

我不知道LinkedHashMap 会更快。考虑到LinkedHashSet 是使用支持LinkedHashMap 实例实现的，可能会快一点，因此与直接使用LinkedHashMap 相比，它会有一点开销。

至于内存，无论键/值实例的大小如何，两者都将占用完全相同的内存量。您会看到，当您将元素 X 添加到 LinkedHashSet 时，它实际上将条目 <X,PRESENT> 放入底层 LinkedHashMap（其中 PRESENT 是对某个虚拟 Object 的引用）。将<X,X> 替换为<X,PRESENT> 没有区别，因为LinkedHashMap 只包含对键和值的引用，而不是键/值实例的副本。

但是找到特定元素太慢了（我猜是 O(n)，因为我必须遍历整个集合才能找到它）

HashSet/LinkedHashSet 使用 O(1) 来确定特定元素是否已经在 Set 中。您不必遍历整个 Set。如果Set 包含该元素，则您已经拥有对它的引用。您不必寻找与您正在搜索的元素相同的 Set 元素。