As it almost but not really matches Optional, maybe you might reconsider the logic:

Java 8 has a limited expressiveness:

Optional<Elem> element = ...
element.ifPresent(el -> System.out.println("Present " + el);
System.out.println(element.orElse(DEFAULT_ELEM));

Here the map might restrict the view on the element:

element.map(el -> el.mySpecialView()).ifPresent(System.out::println);

Java 9:

element.ifPresentOrElse(el -> System.out.println("Present " + el,
                        () -> System.out.println("Not present"));

In general the two branches are asymmetric.

The essential observation here is that your problem involves a non-isomorphic transformation: a single input element may map to zero, one, or two output elements. Whenever you notice this, you should immediately start looking for a solution which involves flatMap instead of map because that's the only way to achieve such a general transformation. In your particular case you can first apply filter for a one-to-zero element mapping, then flatMap for one-to-two mapping:

List<Integer> result =
    IntStream.rangeClosed(1, 10)
             .filter(i -> 10 % i == 0)
             .flatMap(i -> i == 5 ? IntStream.of(i) : IntStream.of(i, 10 / i))
             .boxed()
             .collect(toList());

(assuming import static java.util.stream.Collectors.toList)

As a stream call chain is complex make two streams - avoiding the conditional branches.

String ncourseIds = equivalentCourses.stream()
   .filter(equivalentCourse -> equivalentCourse.getNcourse() != null)
   .map(EquivalentCourse::getNcourse)
   .map(x -> String.valueOf(x.getId()))
   .collect(Collectors.joining(", "));

String pastCourseIds = equivalentCourses.stream()
   .filter(equivalentCourse -> equivalentCourse.getNcourse() == null
          && equivalentCourse.getPastCourse() != null)
   .map(EquivalentCourse::getPastCourse)
   .map(x -> String.valueOf(x.getId()))
   .collect(Collectors.joining(", "));

This also is code focusing on the resulting two strings, with an efficient joining.

By the way, if this is for an SQL string, you may use a PreparedStatement with an Array.

Embellishment as commented by @Holger:

String ncourseIds = equivalentCourses.stream()
   .map(EquivalentCourse::getNcourse)
   .filter(Objects::nonNull)
   .map(NCourse::getId)
   .map(String::valueOf)
   .collect(Collectors.joining(", "));

String pastCourseIds = equivalentCourses.stream()
   .filter(equivalentCourse -> equivalentCourse.getNcourse() == null)
   .map(EquivalentCourse::getPastCourse)
   .filter(Objects::nonNull)
   .map(EquivalentCourse::getPastCourse)
   .map(PastCourse::getId)
   .map(String::valueOf)
   .collect(Collectors.joining(", "));

You can write, given for instance a List<Boolean>:

if (!list.stream().allMatch(x -> x)) {
    // not every member is true
}

Or:

if (list.stream().anyMatch(x -> !x)) {
    // at least one member is false
}

If you have an array of booleans, then use Arrays.stream() to obtain a stream out of it instead.

More generally, for a Stream providing elements of (generic) type X, you have to provide a Predicate<? super X> to .{all,any}Match() (either a "full" predicate, or a lambda, or a method reference -- many things go). The return value of these methods are self explanatory -- I think.

Now, to count elements which obey a certain predicate, you have .count(), which you can combine with .filter() -- which also takes (whatever is) a Predicate as an argument. For instance checking if you have more than 2 elements in a List<String> whose length is greater than 5 you'd do:

if (list.stream().filter(s -> s.length() > 5).count() > 2L) {
    // Yup...
}

Are you asking for suggestions to format the code?

I know that you asked for one line layout. But this often decreases readability of your code. Most companies prefer readability over "one line wonder"

//This doesnt look that bad?
if (settingsChanged){
    read().setHandler(arRead -> { 
        if (arRead.succeeded()) handler.handle(arRead.result()); 
    });
}

combobox.addActionListener(
    event -> {if (boolean) runMethod();});

Missing a semicolon.

Some example of lambda usage:

You can group your sites by active and not active, after that you can perform some logic to both. Put the big logic into a method and then call in the map() function.

You can use filter() as well to get only a part of the stream.

public class Lambda {

    static class Site {

        public boolean isActive;
        public boolean otherCondition;
        public boolean isActive() {
            return isActive;
        }

        public boolean isOtherCondition() {
            return otherCondition;
        }

        public void setProperty(String property) {

        }
    }
    public static Site someOperation(Site site) {

        //some code

        return site;
    }
    public static void main(String[] args) {

        ArrayList<Site> sites = new ArrayList<>();

        Map<Boolean, List<Site>> groupedSites = sites.stream().collect(Collectors.groupingBy(Site::isActive));          
        groupedSites.get(Boolean.TRUE).stream().filter(Site::isOtherCondition).map(Lambda::someOperation).forEach(p -> p.setProperty("something"));

    }
}

If/else or even switch are not the "good OO design" answer. Neither are lambdas. Retrieving the status from somewhere, to make then a decision based on that - that is procedural programming; not OO.

You see, what you actually have in front of you - is a state machine. You have different states; and the point is: if your "thing" is in state A; then you want to do something ( invoke handleA() ). If your are in state B; you want to do something too ( like invoke handleB() ).

So, what you actually have is:

abstract class State {
  abstract void doIt();
...

StateA extends State {
  @Override
  void doIt() { handleA(); }

So, from the client side, you just call doIt() on same object of class State.

Thus: if you are really interested in improving your code base, learn how to use polymorphism to get rid of your if/else/switch statements.

You can watch this video to get an idea what I am talking about.