There is not a very much better way of doing it than you have it - it might be nicer if you extracted it to a method, but that's really it.

Another way might be to construct Optionals from all values, and then use Optional.filter to map empty values to empty optionals:

yearStreams.map(Optional::of)
           .map(opt -> opt.filter(Predicate.not(String::isEmpty)));

Is this better? Probably not.

Yet another way would be to make use of something like Guava's Strings.emptyToNull (other libraries are available), which turns your empty strings into null first; and then use Optional.ofNullable to turn non-nulls and nulls into non-empty and empty Optionals, respectively:

yearStreams.map(Strings::emptyToNull)
           .map(Optional::ofNullable)

Just put the condition into the lambda itself, e.g.

animalMap.entrySet().stream()
        .forEach(
                pair -> {
                    if (pair.getValue() != null) {
                        myMap.put(pair.getKey(), pair.getValue());
                    } else {
                        myList.add(pair.getKey());
                    }
                }
        );

This can be simplified and made more readable using Map.forEach, as suggested by Jorn Vernee:

animalMap.forEach(
        (key, value) -> {
            if (value != null) {
                myMap.put(key, value);
            } else {
                myList.add(key);
            }
        }
);

Of course, these solutions assume that both collections (myMap and myList) are declared and initialized prior to the above pieces of code.

Java 8 streams weren't designed to support this kind of operation. From the jdk:

A stream should be operated on (invoking an intermediate or terminal stream operation) only once. This rules out, for example, "forked" streams, where the same source feeds two or more pipelines, or multiple traversals of the same stream.

If you can store it in memory you can use Collectors.partitioningBy if you have just two types and go by with a Map<Boolean, List>. Otherwise use Collectors.groupingBy.

You can simply extend the callback and use and if/else statement inside this callback. Like this:

List<Dimension> dimensions = new ArrayList<>();

metricNames.stream()
    .map(metricName - > {
        if (matches(metricName)) return new MetricForAccount().withAccountId(subscriberId)
            .withMetricName(metricName)
            .withStat(SUM)
            .withPeriod(PERIOD)
            .withNamespace(AWS_DYNAMO_DB_NAMESPACE)
            .withRegion(region)
            .withDimensions(dimensions)
            .withRange(range);
        else return new MetricForAccount().withAccountId(subscriberId)
            .withMetricName(metricName)
            .withStat(SUM)
            .withPeriod(PERIOD)
            .withNamespace(AWS_DYNAMO_DB_NAMESPACE)
            .withRegion(region)
            .withDimensions(otherDimensions)
            .withRange(range);
    })
    .collect(Collectors.toList());

You can do something like this:

if(returnOptional().isPresent) {
List<Object> list = db.findAllById(id);

list.stream().map(object -> {
    if(/*predicate logic*/) {
        // perform function if predicate logic true
    }
    else {
        // perform function if predicate logic false
    }
    return object;
  });
}

but as philip mentioned technically you cannot split a stream into two streams and collect.

You've filtered out all elements that aren't PLACEHOLDER. You need to add that filter logic to your map operation:

final Map<String, String> output = input.entrySet().stream()
        .map(e -> {
            if (!e.getKey().equals("PLACEHOLDER")) {
                return e;
            }
            if (condition) {
                return new AbstractMap.SimpleImmutableEntry<>("Apple", e.getValue());
            }
            return new AbstractMap.SimpleImmutableEntry<>("Netflix", e.getValue());
        }).collect(toMap(Map.Entry::getKey, Map.Entry::getValue));

But as you are guaranteed to only have a single instance of PLACEHOLDER in the Map, you can just do

String placeholderData = input.remove("PLACEHOLDER");
if (placeholderData != null) {
    input.put(condition ? "Apple" : "Netflix", placeholderData);
}

Perhaps you are overcomplicating this.

    List<User> users = new ArrayList<>();
    users.stream()
            .filter(Objects::nonNull)
            .forEach(u -> u.setRole(u.isActive()?"ABC":"XYZ"));

Try using map:

map(x -> x % 2 == 0? x / 2: x * x);

Let me know if this works for you.
You can learn more about map and filter here

You can use

public ShapeType resolveShapeType(final List<Shape> shapes) {
    int sides = shapes.stream()
        .mapToInt(Shape::getSideCount)
        .filter(count -> count==4 || count==6)
        .max().orElse(0);
    return sides==6? ShapeType.HEXA: sides==4? ShapeType.RECT: ShapeType.GENERIC;
}

This maps each element to its side count and reduces them to the preferred type, which happens to be the maximum count here, so no custom reduction function is needed.

This isn’t short-circuiting, but for most use cases, it will be sufficient. If you want to reduce the number of operations to the necessary minimum, things will be more complicated.

public ShapeType resolveShapeType(final List<Shape> shapes) {
    OptionalInt first = IntStream.range(0, shapes.size())
        .filter(index -> {
            int count = shapes.get(index).getSideCount();
            return count == 6 || count == 4;
        })
        .findFirst();
    if(!first.isPresent()) return ShapeType.GENERIC;
    int ix = first.getAsInt(), count = shapes.get(ix).getSideCount();
    return count==6? ShapeType.HEXA: shapes.subList(ix+1, shapes.size()).stream()
        .anyMatch(shape -> shape.getSideCount()==6)? ShapeType.HEXA: ShapeType.RECT;
}

We know that we can stop at the first HEXA, but to avoid a second pass, it’s necessary to remember whether there was an occurence of RECT for the case there is no HEXA. So this searches for the first element that is either, a RECT or HEXA. If there is none, GENERIC is returned, otherwise, if the first was not a HEXA, the remaining elements are checked for an element of the HEXA kind. Note that for processing the remainder after the first RECT, no filter is needed as it is implied that shapes that are neither, RECT nor HEXA, can’t fulfill the condition.

But it should also be obvious that this code, trying to minimize the numbers of checks, is harder to read than an equivalent for loop.

You may do it like so,

List<String> interchanged = cs.stream()
    .map(s -> s.equals("manager") ? "agent" : s.equals("agent") ? "manager" : s)
    .collect(Collectors.toList());

This is what you want in case you use java-9 or newer (I recommend you to tag the version used):

String rel = release
        .or(() -> project.getReleases().stream()
                                       .filter(Release::isActive)
                                       .map(Release::getName)
                                       .findFirst())
        .orElse("");

Basically Optional#or returns either the present value from the original Optional or provides a Supplier<Optional> providing such value in lazy way (will not be called in case the former value is present).

Use the advantage that Stream#findFirst returns Optional hence such call is compatible with the method needs. Finally call orElse("") as the last possible value if no usable value was present in the previous attempts.

You can put the condition in the map operation. The easiest way is using the ternary condition operator.

BTW, there's no reason to convert the Integer to a String and then parse it again to an int.

public static String getString(List<Integer> list){
    return list.stream()
               .map(i->i%2==0?"e"+i:"u"+i)
               .collect(Collectors.joining(","));
}

EDIT: you can also use an if-else statement, but that would look less elegant:

public static String getString(List<Integer> list){
    return list.stream()
               .map(i -> {
                    if (i%2==0) {
                        return "e"+i;
                    } else {
                        return "u"+i;
                    }
                })
               .collect(Collectors.joining(","));
}