Optimize Java 8 functional algorithm compared to its procedural counter part

Question

I'm trying to optimize a functional operation in Java 8 compared to its procedural equivalent but I'm having some serious performance issue.

Situation

I must parse HTTP Headers String, List<String> from the value of a given enumeration which maps a HeaderName to many possible variations String, Set<String>.

Example

Given the following HttpHeaders :

public static final Map<String, List<String>> httpHeaders = new HashMap<>();

httpHeaders.put("Content-Type", Arrays.asList("application/json", "text/x-json"));
httpHeaders.put("SID", Arrays.asList("ABC123"));
httpHeaders.put("CORRELATION-ID", Arrays.asList("ZYX666"));

And my custom enumeration :

LogHeaders

protected final String key;
protected final Set<String> variation;

SESSION_ID("_sid", Arrays.asList("SESSION-ID", "SID"));    
CORRELATION_ID("cid", Arrays.asList("CORRELATION-ID", "CID")),


  private LogHeaders(final String logKey, final List<String> logKeyVariations) {

        this.logKey = logKey;
        this.logKeyVariations = new HashSet<>(logKeyVariations);
    }

@Override
    public String toString() {

        return this.logKey;
    }

The result should be the a map of "LogHeaders.key" with the value set of the corresponding variations from the HttpHeaders. Only one variation is possible for a given header :

// {LogHeaders.key : HttpHeaderValue>
{
_sid=[ABC123], 
_cid=[ZYX666]
}

Procedural code

final Map<String, List<String>> logHeadersToValue = new HashMap<>();

for (final LogHeaders header : LogHeaders.values()) {
  for (final String variation : header.getLogKeyVariations()) {
    final List<String> headerValue = httpHeaders.get(variation);
      if (headerValue != null) {
        logHeadersToValue.put(header.logKey, headerValue);
        break;
      }
  }
}

Functional code

final Map<String, List<String>> logHeadersToValue =
EnumSet.allOf(LogHeaders.class)
  .stream()
  .collect(Collectors.toMap(
    LogHeaders::toString,
    logHeader -> logHeader.getLogKeyVariations().stream()
      .map(variation -> httpHeaders.get(variation)).filter(Objects::nonNull)
      .collect(singletonCollector())));


public static <T> Collector<T, ?, T> singletonCollector() {

  return Collectors.collectingAndThen(Collectors.toList(), list -> {
      if (list.size() < 1) {
        return null;
      }
      return list.get(0);
    });
}

Current Benchmark

FunctionalParsing : 0.086s

ProceduralParsing : 0.001s

Do you have any idea how I could optimize my functional part?

Thank you

UPDATE BENCHMARK

I ran a 100k warmup + 100k iteration with @Tagir Valeev code :

FunctionalParsing : 0.040s

ProceduralParsing : 0.010s

UPDATE BENCHMARK #2

I ran a 100k warmup + 100k iteration with @Misha code :

FunctionalParsing : 0.025s

ProceduralParsing : 0.017s

Answer 1

I absolutely sure that you did the benchmark incorrectly. It's likely that you executed it only once. You don't care if your program works 0.001 second or 0.086 seconds, right? It's still faster than you can blink. So you probably want to run this code many times. But it seems that you measured the time only once and erroneously suppose that every successive run will take roughly the same time. During the first launch code is mostly executed by interpreter, while it will be JIT-compiled later and will work much faster. This is really crucial for stream-related code.

As for your code it seems that having custom collector is unnecessary. You may implement it like this:

final Map<String, List<String>> logHeadersToValue =
        EnumSet.allOf(LogHeaders.class)
          .stream()
          .collect(Collectors.toMap(
            LogHeaders::toString,
            logHeader -> logHeader.getLogKeyVariations().stream()
              .map(httpHeaders::get).filter(Objects::nonNull)
              .findFirst().orElse(null)));

This solution may also be faster as it will not read more than one http header (like it's done via break in procedural code).

Answer 2

Your functional code doesn't do the same thing as your original. If one of the LogHeaders fails to match a header, the old code would just skip it, while the functional code would throw a NullPointerException.

A direct translation of your original code to streams would look like this:

Map<String, List<String>> logHeadersToValue =  Arrays.stream(LogHeaders.values())
    .collect(
        HashMap::new,
        (map, logHeader) -> logHeader.getLogKeyVariations().stream()
            .filter(httpHeaders::containsKey)
            .findAny()
            .ifPresent(x -> map.put(logHeader.key, httpHeaders.get(x))),
        Map::putAll
    );

If you want this to be more performant and easy to read, consider precomputing a Map<String,String> of every variation to its key. You can do it by modifying the enum like this:

enum LogHeaders {

    SESSION_ID("_sid", "SESSION-ID", "SID"),
    CORRELATION_ID("cid", "CORRELATION-ID", "CID");

    final String key;
    final Map<String, String> variations;

    private LogHeaders(final String key, String... variation) {
        this.key = key;
        variations = Arrays.stream(variation).collect(collectingAndThen(
                toMap(x -> x, x -> key),
                Collections::unmodifiableMap
        ));
    }

    // unmodifiable map of every variation to its key
    public final static Map<String, String> variationToKey =
        Arrays.stream(LogHeaders.values())
            .flatMap(lh -> lh.variations.entrySet().stream())
            .collect(collectingAndThen(
                            toMap(Map.Entry<String, String>::getKey, Map.Entry<String, String>::getValue),
                            Collections::unmodifiableMap
            ));  // will throw if 2 keys have the same variation
}

This approach has the advantage of failing fast if there are duplicate variations. And now the code becomes very simple:

Map<String, List<String>> logHeadersToValue = LogHeaders.variationToKey.keySet().stream()
    .filter(httpHeaders::containsKey)
    .collect(toMap(LogHeaders.variationToKey::get, httpHeaders::get));