In most cases, when you find yourself using forEach on a Stream, you should rethink whether you are using the right tool for your job or whether you are using it the right way.

Generally, you should look for an appropriate terminal operation doing what you want to achieve or for an appropriate Collector. Now, there are Collectors for producing Maps and Lists, but no out of-the-box collector for combining two different collectors, based on a predicate.

Now, this answer contains a collector for combining two collectors. Using this collector, you can achieve the task as

Pair<Map<KeyType, Animal>, List<KeyType>> pair = animalMap.entrySet().stream()
    .collect(conditional(entry -> entry.getValue() != null,
            Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue),
            Collectors.mapping(Map.Entry::getKey, Collectors.toList()) ));
Map<KeyType,Animal> myMap = pair.a;
List<KeyType> myList = pair.b;

But maybe, you can solve this specific task in a simpler way. One of you results matches the input type; it’s the same map just stripped off the entries which map to null. If your original map is mutable and you don’t need it afterwards, you can just collect the list and remove these keys from the original map as they are mutually exclusive:

List<KeyType> myList=animalMap.entrySet().stream()
    .filter(pair -> pair.getValue() == null)
    .map(Map.Entry::getKey)
    .collect(Collectors.toList());

animalMap.keySet().removeAll(myList);

Note that you can remove mappings to null even without having the list of the other keys:

animalMap.values().removeIf(Objects::isNull);

or

animalMap.values().removeAll(Collections.singleton(null));

If you can’t (or don’t want to) modify the original map, there is still a solution without a custom collector. As hinted in Alexis C.’s answer, partitioningBy is going into the right direction, but you may simplify it:

Map<Boolean,Map<KeyType,Animal>> tmp = animalMap.entrySet().stream()
    .collect(Collectors.partitioningBy(pair -> pair.getValue() != null,
                 Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
Map<KeyType,Animal> myMap = tmp.get(true);
List<KeyType> myList = new ArrayList<>(tmp.get(false).keySet());

The bottom line is, don’t forget about ordinary Collection operations, you don’t have to do everything with the new Stream API.

        Optional.ofNullable(list).ifPresent( y -> {
                    if (y.stream().anyMatch(x -> /*predicate*/)) {
                        System.out.println("a");
                    } else {
                        System.out.println("b");
                    }
                });

I am guessing the desired behavior, please correct me if I'm wrong.

You can use a block inside lambda expressions:

List<User> users = userDao.getAllByCompanyId(companyId);
users.stream().filter(Objects::nonNull).forEach(user -> {
    if (user.isPresent()) {
        user.setRole("ABC");
    } else {
        user.setRole("XYZ");
    }
});

You can use String.replace():

String firstName = student.getFirstName().replace('.', '');

Though I'm not sure why you need to use a Stream in your scenario, you could simply just do:

String result = student.getFirstName().replace('.', '') + "." + student.getLastName();

Or something similar.

In case only one parser can parse the message at a time you could add a default parser:

class DefaultParser implements Parser {
    public void parse() {
        System.out.println("Could not parse");
    }
    public boolean canParse(String message) {
        return true;
    }
}

And then use it via

// make sure the `DefaultParser` is the last parser in the `parsers`
parsers.stream().filter(p -> p.canParse(message)).findFirst().get().parse();

or alternatively drop the DefaultParser and just do

Optional<Parser> parser = parsers.stream().filter(p -> p.canParse(message)).findFirst();
if (parser.isPresent()) {
    parser.get().parse();
} else {
    // handle it 
}

It's not really clear about the task you need to accomplish, but in general, everything that you need to write in your if statements you can do with filter() method from Stream API. Then, in map() method you'd have the exact logic which is needed to be done with the data (e.g. transforming it to some other type or getting values which are needed). collect() method is used to create a result from the Stream, e.g. list, set, map, single object or anything else. For example:

map.entrySet().stream()
                .filter(e -> {
                    // filter the data here, so if isStrOrInt or containsUserData is false - we will not have it in map() method
                    boolean isStrOrInt = e.getValue() instanceof String || e.getValue() instanceof Integer;
                    boolean containsUserData = e.getKey().contains("userrole") || e.getKey().contains("userid") || e.getKey().contains("username");
                    return isStrOrInt && containsUserData;
                })
                .map(e -> {
                    if (e.getKey().contains("userrole")) {
                        // do something
                    }
                    // some more logic here
                    return e.getValue();
                })
                .collect(Collectors.toList());
                // or e.g. .reduce((value1, value2) -> value1 + value2);

If you need to create a single object in the end, you would probably need reduce() method. I recommend you to check reduction operations, general information about Stream API to understand how they work.