从时间复杂度很重要的值数组映射键值

Question

我有两个这样的数组..

 Long key1= 1l;  Long key2= 2l;  Long key3= 3l;  Long key4= 4l;  
 Long key5= 2l;  Long key6= 3l;  Long key7= 1l;  Long key8= 2l;
 Long key9= 4l;

 MyObject ob1= new MyObject(1l);     MyObject ob2= new MyObject(3l);     MyObject ob3= new MyObject(2l);
 MyObject ob4= new MyObject(1l);     MyObject ob5= new MyObject(4l);     MyObject ob6= new MyObject(3l);
 MyObject ob7= new MyObject(4l);     MyObject ob8= new MyObject(2l);     MyObject ob9= new MyObject(1l);

 Long[] keys= new Long[]{key1,key2,key3,key4,key5,key5,key7,key8,key9};
 MyObject[] objects= new MyObject[]{ob1,ob2,ob3,ob4,ob5,ob6,ob7,ob8,ob9};

我想用键映射对象。所以每个键都有与之关联的对象列表。

（或多或少我的问题是......映射“A”与“Apple，Axe，Aero”；“B”与“Box，Ball..etc”）

按我的方式我是成功的，但问题是时间复杂度超过 O(n * n)（我正在拿一个键，将它与每个对象键进行比较。）。

有人可以帮助我以小于 o(n * n) 的时间复杂度完成这项工作。对我来说，时间复杂度很重要。

使用 JDK 1.6。

   My Program:


 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 public class Bar 
   {
 Long key1= 1l;  Long key2= 2l;  Long key3= 3l;  Long key4= 4l;  
 Long key5= 2l;  Long key6= 3l;  Long key7= 1l;  Long key8= 2l;
 Long key9= 4l;

 MyObject ob1= new MyObject(1l);     MyObject ob2= new MyObject(3l);     MyObject ob3= new MyObject(2l);
 MyObject ob4= new MyObject(1l);     MyObject ob5= new MyObject(4l);     MyObject ob6= new MyObject(3l);
 MyObject ob7= new MyObject(4l);     MyObject ob8= new MyObject(2l);     MyObject ob9= new MyObject(1l);

 Long[] keys= new Long[]{key1,key2,key3,key4,key5,key5,key7,key8,key9};
 MyObject[] objects= new MyObject[]{ob1,ob2,ob3,ob4,ob5,ob6,ob7,ob8,ob9};


 public void mapper()
 {
    Map<Long, List<MyObject>> keyToObjectMap= new HashMap<Long,List<MyObject>>(); 

    for(int i=0;i<keys.length;i++)
    {
        for(MyObject object:objects)
        {
            if(keyToObjectMap.containsKey(keys[i]))
            {
                if(keys[i].equals(object.getKey()))
                {
                    List<MyObject> objs= keyToObjectMap.get(keys[i]);
                    if(!objs.contains(object))
                    {
                        objs.add(object);
                    }
                    keyToObjectMap.put(keys[i], objs);  
                }
            }
            else if(keys[i].equals(object.getKey())) 
            {
                List<MyObject> objs= new ArrayList<MyObject>();
                objs.add(object);
                keyToObjectMap.put(keys[i], objs);  
            }                   
        }
    }       
 }   

 public static void main(String[] args) 
 {
     Bar b= new Bar();
     b.mapper();
}

   }



 class MyObject
 {
Long key;
String desc="description";  

MyObject(Long key)
{
    this.key=key;
}

public Long getKey(){
    return key;
}
}

Answer 1

你可以像这样在 O(n) 中做到这一点。

Map<Long, Set<MyObject>> keyToObjectMap = new HashMap<>();
for (MyObject o : objects) {
     Set<MyObject> set = ketToObjectMap.get(o.getKey());
     if (set == null)
         keyToObjectMap.put(o.getKey(), set = new HashSet<>());
     set.add(o);
}

在 Java 8 中你可以这样做

Map<Long, Set<MyObject>> map = objects.stream()
                .collect(Collectors.groupingBy(MyObject::getKey, Collectors.toSet()));

Answer 2

如果搜索性能如此重要，您应该只使用散列的散列而不是列表的散列。

顺便说一句，它不是 o(nn)，因为您的外部哈希具有恒定成本。