Java lambda - filter list with two separate conditions

what if you will try to find an unwanted item an then will remove it from the list instead of complicated filtering? I guess this works nice:

@Test
  public void testTest() {
    List<TestClass> list = new ArrayList<>(Arrays.asList(new TestClass("animal", new Date())
        , new TestClass("fruit", DateUtils.addDays(new Date(), -2))
        , new TestClass("veg", DateUtils.addDays(new Date(), -1))));
    TestClass toRemove = list.stream().filter(item -> !Objects.equals("animal", item.getName()))
        .min(Comparator.comparing(TestClass::getDate)).get();
    list.remove(toRemove);

    System.out.println(list);
  }

  class TestClass {
    private String name;
    private Date date;

    public TestClass(String name, Date date) {
      this.name = name;
      this.date = date;
    }

    public String getName() {
      return name;
    }

    public void setName(String name) {
      this.name = name;
    }

    public Date getDate() {
      return date;
    }

    public void setDate(Date date) {
      this.date = date;
    }

    @Override public String toString() {
      final StringBuilder sb = new StringBuilder("TestClass{");
      sb.append("name='").append(name).append('\'');
      sb.append(", date=").append(date);
      sb.append('}');
      return sb.toString();
    }
  }

What I need to do is to filter those items in such way: an object of type animal will be always pass to new list, but only one item of type fruit and vegetable (the one with most recent date of modification) will be passed, so the result list would be the following:

If I understand this right, what you're looking for is (simplified): from a given list, obtain an item of animal type and an item of non-animal type, keeping only those with maximum last modified date.

I'm going to play on a side implementation detail of the animal item always being the single one in the list. What that means is, you can partiton stream with a maxBy downstream, and this both keep the animal item in, and it will find the correct non-animal item:

List<Item> input = ... // your list here

// a small inconvenience with types here, because maxBy's
// reduction type is Optional
Map<Boolean, Optional<Item>> map = list.stream()
    .collect(Collectors.partitioningBy(
            item -> "animal".equals(item.getType()),
            Collectors.maxBy(Comparator.comparing(Item::getLastModifiedDate))
        )
    );

List<Item> result = new ArrayList<>(2);
map.values().forEach(option -> option.ifPresent(result::add));

consume(result);

Note: on my machine it puts non-animals first into the list, because of how partitioning collector's result is iterated over (that map's first entry is for Boolean.FALSE). You can reverse the partitioning predicate to make it so the animal comes first, without chaning anything else in the code.

Another approach would be to sort the list twice. First sort the list so that the element of type animal is always at the beginning of the list then the others are listed by modification date. Then limit the list to two elements and sort again by modification date. I'm using here that "animal" is alphabetically before the other types, but you could also implement a simple logic which makes the animal < fruit / vegetables

Function<Item,Integer> byType = i -> i.type.equals("animal")?1:0;
List<Item> myList = list.stream()
                        .sorted(Comparator.comparing(byType)
                                .thenComparing(Item::getModificationDate).reversed())
                        .limit(2)
                        .sorted(Comparator.comparing(Item::getModificationDate).reversed())
                        .collect(Collectors.toList());

The advantage here is that it can be done in one step.