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};

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

（或多或少我的问题就像..地图＆＃39; A＆＃39;与＃34; Apple，Axe，Aero＆＃34;＆＃39; B＆＃39;与＆＃34; Box ，Ball..etc＆＃34;）

我通过我的方式取得了成功，但问题是时间复杂度超过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），因为你的外部哈希值不变。

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

2 个答案: