如何返回具有該方法的枚舉參數的 HashMap？

Question

我有方法 returnSpecificOrder(Type type) （如下面的代碼），其中 Type 是枚舉 class，此方法應僅返回包含 item.type = "Clothes" 的訂單，其中 Item 是另一個 class 女巫具有可變的公共類型類型；我嘗試返回來自 hashMap 但 java 的訂單說無法解析符號，我應該如何改變我的方法？

public class Order {
    public long id;
    public LocalDate dateTime;
    public User user;
    public List<Item> items;

//set seters and geters  

    public HashMap<Long, Order>  createOrder() {
    Order myFirstOrder = new Order();
        myFirstOrder.setId(1);
        myFirstOrder.setDateTime(LocalDate.now());
        myFirstOrder.setUser(user);
        myFirstOrder.setItems(items);

    Order mySecondOrder = new Order();
        mySecondOrder.setId(2);
        mySecondOrder.setDateTime(LocalDate.now());
        mySecondOrder.setUser(user);
        mySecondOrder.setItems(item2);

    //hash map of orders
    HashMap<Long, Order> orders = new HashMap<>();
        orders.put(myFirstOrder.getId(), myFirstOrder);
        orders.put(mySecondOrder.getId(), mySecondOrder);
        return orders;
}

    //method that will return only Orders containing item.type = "Clothes"
    public static Map<Long, Order> returnSpecificOrder(Type type) {
        return orders.entrySet()
                .stream()
                .filter(o -> o.getValue().getItems().stream().anyMatch(item -> item.getType() == Type.clothes))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    }            }

Answer 1

您的過濾器應該可以工作。

以下是工作代碼。

我重構了您的實體類，並在需要時添加了注釋。

class Order {
    public long id;
    public List<Item> items;

    //convenient constructor.
    public Order(long id, Type... items) {
        this.id = id;
        this.items = Arrays.stream(items).map(Item::new).collect(Collectors.toList());
    }
}

class Item {
    Type type;

    public Item(Type type) {
        this.type = type;
    }
}

enum Type {
    Clothes, NotClothes, Car, Bicycle, Shoes
}

然后將您的過濾方法添加到 main

public class Main {
    public static void main(String[] args) {
        

        //pre-populate with sample data
        Order o1 = new Order(1, Type.Bicycle, Type.Car, Type.Clothes);
        Order o2 = new Order(2, Type.NotClothes, Type.Bicycle);
        HashMap<Long, Order> orders = new HashMap<>();
        orders.put(1L, o1);
        orders.put(2L, o2);

        //method that will return only Orders containing item.type = "Clothes"
        Map<Long, Order> result = orders.entrySet().stream()
                .filter(o -> {
                    //I Split into two lines to make it less cluttered.
                    List<Item> list = o.getValue().items;
                    return list.stream().anyMatch(item  -> item.type == Type.Clothes);
                }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

        //The answer shows that only 1 item is returned.
        System.out.println("result = " + result.size());
    }

}