How in Java 1.8 Streams to perform logic before a foreach only if there is at least one element

Question

// the results can be anything, errors always start with 'ERROR'
List<String> results= { 
    "Success 100 - Operation worked John", 
    "Success 100 - It also worked for Harry", 
    "ERROR 4514 for Sally. It's always Sally." 
}

// I want this to output something like 
//     warn: There were errors
//     warn: ERROR 4514 for Sally. It's always Sally.
//
// in the case there are no ERROR's I want no warn:'s
results.stream()
    .filter( name->name.startsWith( "ERROR" ) )
    .DO_THIS_IF_NOT_EMPTY( ()-> LOG.warn( "There were errors"; )
    .forEach( error -> { LOG.warn( "ERROR: " + error }

The DO_THIS_IF_NOT_EMPTY is wishful. I don't see an obvious elegant way to do this with java streams. Can anyone think of a good one?

Answer 1

In this case, there is no intrinsic Stream operation, so falling back to use an Iterator is the simplest solution:

Iterator<String> it = results.stream()
    .filter(name -> name.startsWith( "ERROR" ))
    .iterator();
if(it.hasNext()) {
    LOG.warn("There were errors");
    it.forEachRemaining(error -> LOG.warn("ERROR: " + error));
}

---

That said, there is no sense in logging a message like “There were errors" that doesn’t provide any context. Especially when you are going to produce a meaningful log record right afterwards, which provides the actual message and implies that there were errors..

Apparently, this is supposed to be a title, in other words, you are trying to do log file formatting at the entirely wrong end of the logging framework.

Since there is no guaranty that these messages appear adjacent in a log file, just consider that there might be other log messages from other threads or subsystems, this doesn’t make sense.

Instead, you should use a log analyzing tool, which is able to filter the log file to find records from the same origin, perhaps looking for those that were filed shortly after each other from the same thread, which makes you independent from their actual location in the log file.

You know that “There were errors” when the tool shows you at least one matching record…

Answer 2

Filter the list :

List<String> errors = names.stream()
    .filter(name -> name.startsWith("ERROR"))
    .collect(Collectors.toList());

And if not empty, print your static line and then do forEach

if (!errors.isEmpty()) {
    LOG.warn("There were errors");
    errors.forEach(error -> LOG.warn("ERROR: " + error));
}

Answer 3

Here another, more compact, solution:

Given:

List<String> names = Arrays.asList(
        "Success 100 - Operation worked John",
        "Success 100 - It also worked for Harry",
        "ERROR 4514 for Sally. It's always Sally.");

Predicate<String> IS_ERROR = name -> name.startsWith("ERROR");

Compact Solution:

if (names.stream().anyMatch(IS_ERROR)) {
    LOG.warn("There were errors");
    names.stream().filter(IS_ERROR).forEach(LOG::warn);
}

Answer 4

You could keep a final AtomicBoolean to keep track of whether this is the first or not.

static String[] results = {
        "Success 100 - Operation worked John",
        "Success 100 - It also worked for Harry",
        "ERROR 4514 for Sally. It's always Sally."
};

public void test() {
    List<String> names = Arrays.asList(results);
    final AtomicBoolean first = new AtomicBoolean(true);
    names.stream()
            .filter(name -> name.startsWith("ERROR"))
            .forEach(error -> {
                if (first.getAndSet(false)) {
                    System.out.println("There were errors ");
                }

                System.out.println("ERROR: " + error);
            });
}

IMHO @abubakkar's solution is a better one.

Answer 5

You could try something like

results.stream().filter(s -> s.startsWith("ERROR")).forEach(s -> System.out.println("Warning found match: "+ s));