Question

如何在Carnet知道其属性ArrayList<Carnet>的情况下找到对象codeIsin。

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

public class Carnet {

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

    // Setters and getters

}

Answer 1

你不能没有迭代。

选项1

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

选项2

覆盖equals()的{{1}}方法。

选项3

使用Carnet作为关键字，将您的List存储为Map：

codeIsIn

Answer 2

在 Java8 中，您可以使用流：

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

此外，如果您有许多不同的对象（不仅是Carnet），或者您希望通过不同的属性（不仅仅是cideIsin）找到它，您可以构建一个实用程序类来进行封装这个逻辑在其中：

public final class FindUtils {
    public static <T> T findByProperty(Collection<T> col, Predicate<T> filter) {
        return col.stream().filter(filter).findFirst().orElse(null);
    }
}

public final class CarnetUtils {
    public static Carnet findByCodeTitre(Collection<Carnet> listCarnet, String codeTitre) {
        return FindUtils.findByProperty(listCarnet, carnet -> codeTitre.equals(carnet.getCodeTitre()));
    }

    public static Carnet findByNomTitre(Collection<Carnet> listCarnet, String nomTitre) {
        return FindUtils.findByProperty(listCarnet, carnet -> nomTitre.equals(carnet.getNomTitre()));
    }

    public static Carnet findByCodeIsIn(Collection<Carnet> listCarnet, String codeIsin) {
        return FindUtils.findByProperty(listCarnet, carnet -> codeIsin.equals(carnet.getCodeIsin()));
    }
}

Answer 3

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

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

Answer 4

以下是使用Guava

的解决方案

private User findUserByName(List<User> userList, final String name) {
    Optional<User> userOptional =
            FluentIterable.from(userList).firstMatch(new Predicate<User>() {
                @Override
                public boolean apply(@Nullable User input) {
                    return input.getName().equals(name);
                }
            });
    return userOptional.isPresent() ? userOptional.get() : null; // return user if found otherwise return null if user name don't exist in user list
}

Answer 5

如果您使用 Java 8 ，并且您的搜索可能返回null，则可以尝试使用Optional类。

寻找一张证物：

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

现在用它：

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

Answer 6

覆盖hashcode和equals方法

Answer 7

要查找有意义相等的对象，您需要覆盖该类的equals和hashcode方法。你可以在这里找到一个很好的教程。

http://www.thejavageek.com/2013/06/28/significance-of-equals-and-hashcode/

Answer 8

按照Oleg的答案，如果要在按属性筛选的列表中找到 ALL 个对象，可以执行以下操作：

//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()));
         }
     }
}

，如果您要过滤具有特定属性的 HashMap 中的 ALL 个项目，则类似

//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()));
        }
    }

Answer 9

在这里，我们可以使用这样的函数：

查找所有具有特定代码的对象：

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

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

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

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

9 个答案: