Java 从另一个具有指定ID的列表中获取元素列表

我有一个

列表元素

，其中class元素具有属性

id

——它很长。我还有

列表ID

。现在我需要从

元素

列表中获取存在于

id

列表中的具有

id

prop的对象

我用这两个for循环，但我认为这不是最好的选择

如何提高我的绩效

 public class Element{

   Long id;

   public Element(Long id){
     this.id = id;
   }

   public Long getId( ){
     return id;
   }

   public static void main(String []args){
     List<Element> elements= Arrays.asList(new Element(1),new Element(2),new Element(3), new Element(5), new Element(5));
     List<Long> ids= Arrays.asList(3,4,1);
     List<Element> returnList = new ArrayList<Alement>();

     for(int i = 0; i < elements.size(); i++) {
        for(int j = 0; j < ids.size(); j++) {
            if (elements.get(i).getId() == ids.get(j))
                returnList.add(elements.get(i));
        }
     }

   }
 }

公共类元素{
长id；
公共元素（长id）{
this.id=id；
}
公共长getId（）{
返回id；
}
公共静态void main（字符串[]args）{
列表元素=数组.asList（新元素（1）、新元素（2）、新元素（3）、新元素（5）、新元素（5））；
List id=Arrays.asList（3,4,1）；
List returnList=new ArrayList（）；
对于（int i=0；i

如何提高我的绩效

 public class Element{

   Long id;

   public Element(Long id){
     this.id = id;
   }

   public Long getId( ){
     return id;
   }

   public static void main(String []args){
     List<Element> elements= Arrays.asList(new Element(1),new Element(2),new Element(3), new Element(5), new Element(5));
     List<Long> ids= Arrays.asList(3,4,1);
     List<Element> returnList = new ArrayList<Alement>();

     for(int i = 0; i < elements.size(); i++) {
        for(int j = 0; j < ids.size(); j++) {
            if (elements.get(i).getId() == ids.get(j))
                returnList.add(elements.get(i));
        }
     }

   }
 }

您可以使用

id

作为键为元素使用a。然后，在

ID

列表上使用单个循环进行查找。
HashMap
具有恒定的查找复杂性

如何提高我的绩效

 public class Element{

   Long id;

   public Element(Long id){
     this.id = id;
   }

   public Long getId( ){
     return id;
   }

   public static void main(String []args){
     List<Element> elements= Arrays.asList(new Element(1),new Element(2),new Element(3), new Element(5), new Element(5));
     List<Long> ids= Arrays.asList(3,4,1);
     List<Element> returnList = new ArrayList<Alement>();

     for(int i = 0; i < elements.size(); i++) {
        for(int j = 0; j < ids.size(); j++) {
            if (elements.get(i).getId() == ids.get(j))
                returnList.add(elements.get(i));
        }
     }

   }
 }

您可以使用
id
作为键为元素使用a。然后，在
ID
列表上使用单个循环进行查找。
HashMap
具有恒定的查找复杂性。
创建一组ID，如下所示：

    Set<Long> idSet = new HashSet<>(ids);
    List<Element> selected = elements.stream()
        .filter(element -> idSet.contains(element.getId()))
        .collect(Collectors.toList());

Set idSet=newhashset（ids）；
List selected=elements.stream（）
.filter（element->idSet.contains（element.getId（）））
.collect（Collectors.toList（））；
制作一组ID，如下所示：

    Set<Long> idSet = new HashSet<>(ids);
    List<Element> selected = elements.stream()
        .filter(element -> idSet.contains(element.getId()))
        .collect(Collectors.toList());

Set idSet=newhashset（ids）；
List selected=elements.stream（）
.filter（element->idSet.contains（element.getId（）））
.collect（Collectors.toList（））；
您可以使用：

    Iterable<Element> filteredElements = Iterables.filter(elements, new Predicate<Element>() {
        @Override
        public boolean apply(Element element) {
            return ids.contains(element.getId());
        }
    });

Iterable filteredElements=Iterables.filter（元素，新谓词（）{
@凌驾
公共布尔应用（元素）{
返回id.contains（element.getId（））；
}
});
您可以使用：

    Iterable<Element> filteredElements = Iterables.filter(elements, new Predicate<Element>() {
        @Override
        public boolean apply(Element element) {
            return ids.contains(element.getId());
        }
    });

Iterable filteredElements=Iterables.filter（元素，新谓词（）{
@凌驾
公共布尔应用（元素）{
返回id.contains（element.getId（））；
}
});
我用于这两个for循环，你能发布你的循环以便我们了解你做了什么吗？我用示例编辑了我用于这两个for循环，你能发布你的循环以便我们了解你做了什么吗？我用示例
HashSet
编辑会更好。我不能完全确定这一点，因为HashSet有HashMap支持，你能给我一个提示为什么它更好（除了我同意OP最可能需要的明显的set属性之外）？因为
set
只包含一组项目，而
Map
包含
键/值对。OP只需要存在而不需要从键到值的转换，所以
集
更合适。
哈希集
会更好。我不完全确定这一点，因为哈希集有哈希映射支持，你能给我一个为什么它更好的提示吗（除了我认为OP最需要的明显的Set属性之外）？由于
集合
仅包含一组项目，因此
映射
包含
键/值
对。OP只需要存在，而不需要从键到值的转换，因此设置
更合适。。