在提取的实体列表中查找重复项

Question

private boolean hasDuplicates(Recipe recipe) {
    List<Recipe> currentRecipes = new ArrayList<>();

    Stream.of(this.breakfast, this.lunch, this.dinner).forEach(meal -> {
        currentRecipes.add(meal.getRecipe());
        currentRecipes.add(meal.getSnack());
    });
    currentRecipes.add(this.snack);

    return currentRecipes.contains(recipe);
    };

}

//想象所有字段的getter和setter。

public class Menuplan {
  private Meal breakfast;
  private Meal lunch;
  private Meal dinner;
  private Recipe snack;
}

public class Meal {
  private Recipe recipe;
  private Reicpe snack;
}

我用上面的方法来测试Menuplan是否已经分配了给定的食谱(作为点心或食谱)。

我想知道是否有更优雅/更短的方法来编写函数。

Answer 1

你应该避开溪流

private boolean hasDuplicates(Recipe recipe) {
    for (Meal each : Arrays.asList(breakfast, lunch, dinner)) {
        if (each.getRecipe().equals(recipe) || each.getSnack().equals(recipe) {
            return true;
        }
    }
    return snack.equals(recipe);
}

Answer 2

在一个流中完成所有工作的解决方案是

private boolean hasDuplicates(Recipe recipe) {
    return Stream.concat(
        Stream.of(this.breakfast, this.lunch, this.dinner)
            .flatMap(meal -> Stream.of(meal.getRecipe(), meal.getSnack())),
        Stream.of(this.snack))
   .anyMatch(Predicate.isEqual(recipe));
}

三个流元素＜code＞this。早餐，这个。午餐，这个。晚餐获得与调用＜code＞晚餐相同的处理。getRecipe（）和＜code＞用餐。getSnack（）以形成一个新流，该新流与仅包含＜code＞this.snack

anyMatch一旦找到满足条件的元素，就会返回true。否则，它将返回false。

您可以考虑将一个不适合其他元素通用模式的元素移出Stream操作：

private boolean hasDuplicates(Recipe recipe) {
    return this.snack.equals(recipe) ||
        Stream.of(this.breakfast, this.lunch, this.dinner)
            .flatMap(meal -> Stream.of(meal.getRecipe(), meal.getSnack())
            .anyMatch(Predicate.isEqual(recipe));
}

另一种选择是

private boolean hasDuplicates(Recipe recipe) {
    return this.snack.equals(recipe) ||
        Stream.of(this.breakfast, this.lunch, this.dinner)
            .anyMatch(meal -> meal.getRecipe().equals(recipe)
                           || meal.getSnack().equals(recipe));
}