Java 如何按属性在ArrayList中查找对象

如何在

ArrayList

中找到对象

Carnet

，知道其属性

codeIsin

List<Carnet> listCarnet = carnetEJB.findAll();

public class Carnet {

    private String codeTitre;
    private String nomTitre;
    private String codeIsin;

    // Setters and getters

}

List listCarnet=carnetEJB.findAll（）；
公共类单证册{
私有字符串代码标题；
私有字符串名称；
私有字符串编码；
//二传手和接球手
}

没有迭代，你就不能成功

选项1

Carnet findCarnet(String codeIsIn) {
    for(Carnet carnet : listCarnet) {
        if(carnet.getCodeIsIn().equals(codeIsIn)) {
            return carnet;
        }
    }
    return null;
}

选项2

重写

Carnet

的

equals（）

方法

选项3

将

列表

存储为

地图

，使用

codeIsIn

键：

HashMap<String, Carnet> carnets = new HashMap<>();
// setting map
Carnet carnet = carnets.get(codeIsIn);

HashMap carnets=newhashmap（）；
//设定图
Carnet Carnet=carnets.get（codeIsIn）；

要查找有意义的相等对象，需要重写类的

equals

和

hashcode

方法。你可以在这里找到一个很好的教程

以下是一个使用

private User findUserByName（List userList，最终字符串名）{
可选用户可选=
FluentIterable.from（userList）.firstMatch（新谓词（）{
@凌驾
公共布尔应用（@Nullable User input）{
返回input.getName（）.equals（name）；
}
});
return userOptional.isPresent（）？userOptional.get（）：null；//如果找到，则返回用户；否则，如果用户名在用户列表中不存在，则返回null
}

在Java8中，您可以使用流：

public static Carnet findByCodeIsIn(Collection<Carnet> listCarnet, String codeIsIn) {
    return listCarnet.stream().filter(carnet -> codeIsIn.equals(carnet.getCodeIsin())).findFirst().orElse(null);
}

---

如果您使用Java8，并且您的搜索可能返回null，那么您可以尝试使用该类

要查找carnet，请执行以下操作：

private final Optional<Carnet> findCarnet(Collection<Carnet> yourList, String codeIsin){
    // This stream will simply return any carnet that matches the filter. It will be wrapped in a Optional object.
    // If no carnets are matched, an "Optional.empty" item will be returned
    return yourList.stream().filter(c -> c.getCodeIsin().equals(codeIsin)).findAny();
}

private final可选findCarnet（集合列表，字符串代码输入）{
//此流将只返回与筛选器匹配的任何carnet。它将被包装在可选对象中。
//如果没有匹配的Carnet，将返回“可选.空”项
返回list.stream（）.filter（c->c.getCodeIsin（）.equals（codeIsin））.findAny（）；
}

现在介绍一下它的用法：

public void yourMethod(String codeIsin){
    List<Carnet> listCarnet = carnetEJB.findAll();

    Optional<Carnet> carnetFound = findCarnet(listCarnet, codeIsin);

    if(carnetFound.isPresent()){
        // You use this ".get()" method to actually get your carnet from the Optional object
        doSomething(carnetFound.get());
    }
    else{
        doSomethingElse();
    }
}

public方法（字符串codeIsin）{
List listCarnet=carnetEJB.findAll（）；
可选的carnetFound=findCarnet（列表carnet，codeIsin）；
if（carnetFound.isPresent（））{
//您可以使用此“.get（）”方法从可选对象实际获取carnet
doSomething（carnetFound.get（））；
}
否则{
doSomethingElse（）；
}
}

这里是另一个使用Java 8的解决方案，如果列表中存在匹配的元素，则返回匹配的元素。如果匹配了多个元素，则收集器抛出IllegalArgumentException。如果没有匹配项，则返回null

Carnet carnet = listCarnet.stream()
                    .filter(c -> c.getCodeIsin().equals(wantedCodeIsin))
                    .collect(MoreCollectors.toOptional())
                    .orElse(null);

---

在Oleg回答之后，如果您想在列表中查找由属性过滤的所有对象，可以执行以下操作：

//Search into a generic list ALL items with a generic property
public final class SearchTools {
       public static <T> List<T> findByProperty(Collection<T> col, Predicate<T> filter) {
           List<T> filteredList = (List<T>) col.stream().filter(filter).collect(Collectors.toList());
           return filteredList;
     }

//Search in the list "listItems" ALL items of type "Item" with the specific property "iD_item=itemID"
public static final class ItemTools {
         public static List<Item> findByItemID(Collection<Item> listItems, String itemID) {
             return SearchTools.findByProperty(listItems, item -> itemID.equals(item.getiD_Item()));
         }
     }
}

//在通用列表中搜索具有通用属性的所有项目
公共最终类搜索工具{
公共静态列表findByProperty（集合列、谓词筛选器）{
List filteredList=（List）col.stream（）.filter（filter.collect（Collectors.toList（））；
返回过滤器列表；
}
//在列表“listItems”中搜索具有特定属性“iD\u Item=itemID”的“Item”类型的所有项目
公共静态最终类ItemTools{
公共静态列表findByItemID（集合listItems、字符串itemID）{
返回SearchTools.findByProperty（listItems，item->itemID.equals（item.getiD_item（））；
}
}
}

类似地，如果要使用某个属性筛选HashMap中的所有项目

//Search into a MAP ALL items with a given property
public final class SearchTools {
       public static <T> HashMap<String,T> filterByProperty(HashMap<String,T> completeMap, Predicate<? super Map.Entry<String,T>> filter) {
           HashMap<String,T> filteredList = (HashMap<String,T>) completeMap.entrySet().stream()
                                .filter(filter)
                                .collect(Collectors.toMap(map -> map.getKey(), map -> map.getValue()));
           return filteredList;
     }

     //Search into the MAP ALL items with specific properties
public static final class ItemTools {

        public static HashMap<String,Item> filterByParentID(HashMap<String,Item> mapItems, String parentID) {
            return SearchTools.filterByProperty(mapItems, mapItem -> parentID.equals(mapItem.getValue().getiD_Parent()));
        }

        public static HashMap<String,Item> filterBySciName(HashMap<String,Item> mapItems, String sciName) {
            return SearchTools.filterByProperty(mapItems, mapItem -> sciName.equals(mapItem.getValue().getSciName()));
        }
    }

//在映射中搜索具有给定属性的所有项
公共最终类搜索工具{
公共静态HashMap filterByProperty（HashMap completeMap，谓词在这里，我们可以使用如下函数：

  public static List<Item> findBycodeIsin(Collection<Carnet> listCarnet, String codeIsIn) {
            
         return items.stream().filter(item -> codeIsIn.equals(item.getCodeIsIn()))
        .collect(Collectors.toList());
     }

要查找具有特定代码的所有对象，请参见：

  public static List<Item> findBycodeIsin(Collection<Carnet> listCarnet, String codeIsIn) {
            
         return items.stream().filter(item -> codeIsIn.equals(item.getCodeIsIn()))
        .collect(Collectors.toList());
     }

公共静态列表findBycodeIsin（集合列表carnet，字符串codeIsIn）{
return items.stream（）.filter（item->codeIsIn.equals（item.getCodeIsIn（）））
.collect（Collectors.toList（））；
}

查找单个项目（如果每个对象的代码都是唯一的）：

public static Carnet findByCodeIsIn（集合列表Carnet，字符串codeIsIn）{
返回listCarnet.stream（）.filter（carnet->codeIsIn.equals（carnet.getCodeIsIn（））
.findFirst（）.orElse（null）；
}
使用
indexOf（）
，前提是对象重写了
equals（）
。类Carnet在jar文件中，我无法重写equals（）如果我是你，我会从哪里找到源代码，并实现它的equals和hashCode。唯一的替代方法是手动迭代集合并检查成员的equality。我宁愿使用映射而不是列表。如果您经常查找对象，并且性能是个问题，则排序映射可能更好。实现在我看来，使用equal来达到这个目的是很难看的。对于Java 8，你可以从ArrayList获取流并对其应用过滤器（e->e.codeIsIn.equals（…）。我没有选择2。我重写
equals（）
，然后做什么？@idclev463035818我猜应该使用
ArrayList.indexOf
方法谓词
  public static List<Item> findBycodeIsin(Collection<Carnet> listCarnet, String codeIsIn) {
            
         return items.stream().filter(item -> codeIsIn.equals(item.getCodeIsIn()))
        .collect(Collectors.toList());
     }

public static Carnet findByCodeIsIn(Collection<Carnet> listCarnet, String codeIsIn) {
    return listCarnet.stream().filter(carnet-> codeIsIn.equals(carnet.getCodeIsIn()))
            .findFirst().orElse(null);
}