How to translate this into Java 8 features?

[John Freeman]

I have the following simple class:

package algorithms;

public class ErrorMessage {

	private String errorType;
	private String errorCode;
	private String errorDesc;
	public String getErrorType() {
		return errorType;
	}
	public void setErrorType(String errorType) {
		this.errorType = errorType;
	}
	public String getErrorCode() {
		return errorCode;
	}
	public void setErrorCode(String errorCode) {
		this.errorCode = errorCode;
	}
	public String getErrorDesc() {
		return errorDesc;
	}
	public void setErrorDesc(String errorDesc) {
		this.errorDesc = errorDesc;
	}
	public ErrorMessage(String errorType, String errorCode, String errorDesc) {
		super();
		this.errorType = errorType;
		this.errorCode = errorCode;
		this.errorDesc = errorDesc;
	}
	
	
}

As well as the following driver program:

package algorithms;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class ErrorDriver {

	static Map<String, Map<String,String>> generateResultWithoutJava8(List<ErrorMessage> errors)
	{
		
		Map<String, Map<String,String>> test2 = new HashMap<String, Map<String,String>>();
		
		
		for(ErrorMessage em : errors)
		{
			if(test2.get(em.getErrorType()) == null)
			{
				Map<String, String> innerMapping = new HashMap<String, String>();
				
				for(int x=0; x<errors.size(); x++)
				{
					if(errors.get(x).getErrorType().equals(em.getErrorType()))
					{
						innerMapping.put(errors.get(x).getErrorCode(), errors.get(x).getErrorDesc());
					}	
				}
				test2.put(em.getErrorType(), innerMapping);
			}
		}
		return test2;
	}
	
	
	
	Map<String, Map<String,String>> generateResultWithJava8(List<ErrorMessage> errors)
	{
		
		Map<String, Map<String,String>> test2 = new HashMap<String, Map<String,String>>();
		
		//implementation 
		
		return test2;
	}
	
	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		List<ErrorMessage> errors = new ArrayList<ErrorMessage>();
		
		ErrorMessage oneA = new ErrorMessage("Network","AA","NetworkUnavailable");
		ErrorMessage oneB = new ErrorMessage("Network","AB","NetworkDown");
		ErrorMessage oneC = new ErrorMessage("Network","AC","NetworkSlow");
		ErrorMessage twoA = new ErrorMessage("Data","AA","DataCorrupted"); //note that the middle parameter can be duplicated across different parent errorType codes.
		ErrorMessage twoB = new ErrorMessage("Data","BC","DataOutdated");
		
		errors.add(oneA);
		errors.add(oneB);
		errors.add(oneC);
		errors.add(twoA);
		errors.add(twoB);
		
		Map<String, Map<String,String>> outputWithoutJava8 = generateResultWithoutJava8(errors);
		
		System.out.println(outputWithoutJava8);
		
	}

}

And I get the output as expected/required:

{Network={AA=NetworkUnavailable, AB=NetworkDown, AC=NetworkSlow}, Data={AA=DataCorrupted, BC=DataOutdated}}

My question is, how can I get the same logic using Java 8 features? I spent some time trying to wrap my mind around it, but I did not get anywhere.

Thanks!

[Campbell Ritchie]

I can never remember how to create a Map, but let's try. You can get a Stream out of any Collection with its stream() method. There is also a parallelStream method, but I can see no point in parallelism for a five‑element List. So line 2 creates that List Stream.
You can collect the contents of a Stream into something with the collect() method (line 3). That takes a Collector instance as its parameter (overloaded method), and the easiest way to find a Collector is with a method of the Collectors class. This is a method that returns a Collector to create a Map.
Actually both the collect method and the Collector link show examples of the usage of groupingBy, which makes it easier to work out what to write .

Map<String, List<ErrorMessage>> map =
        errorsList.stream()
                  .collect(Collectors.groupingBy(
                         ErrorMessage::getErrorType));

I am not sure whether that is what you really wanted, but it is as far as I can remember just at the moment. Somebody else will doubtess give a better suggestion.
The idiom ErrorMessage::getErrorType is called a method reference and you can read about it in that Java™ Tutorials link.

Note the different indentation from what you are used to: make the dot operators line up vertically.

[Knute Snortum]

This is a method that returns a Collector to create a Map. 

You could also use the function toMap in Collectors.

[Campbell Ritchie]

Knute Snortum wrote:. . . You could also use the function toMap in Collectors.

Niiiiice

That's nice misspelt for anybody having difficulty with it.

[Stephan van Hulst]

In your pre-Java 8 code, there's no need to use a nested loop. You can achieve the same like this:

for (ErrorMessage error: errors) {
  String errorType = error.getErrorType();
  if (errorType == null)
    continue;

  Map<String, String> inner = outer.get(errorType);
  if (inner == null) {
    inner = new HashMap<>();
    outer.put(errorType, inner);
  }

  inner.put(error.getErrorCode(), error.getErrorDesc());
}

Since Java 8, Map has a computeIfAbsent() method. You can simplify the above to the following:

for (ErrorMessage error: errors) {
  String errorType = error.getErrorType();
  if (errorType == null)
    continue;

  outer.computeIfAbsent(errorType, absent -> new HashMap<>())
       .put(error.getErrorCode(), error.getErrorDesc());
}

However, as Campbell and Knute have pointed out, and even more functional way can be achieved using collectors:

errors.stream()
  .filter(error -> error.getErrorType() != null)
  .collect(groupingBy(
    ErrorMessage::getErrorType, toMap(
      ErrorMessage::getErrorCode,
      ErrorMessage::getErrorDesc
    )
  ));

[Rob Spoor]

I think those checks and the filter for the error type being null can be omitted though. There's no such check in the original code; you probably misread the Map.get call on line 18.

[John Freeman]

Thank you all for the responses everyone!

Campbell, your output was not quite what I was looking for, because my values for the outer map are Map<String, String> rather than List<ErrorMessage>, but thanks for your tip about the indentation style.

Knute, thanks for bringing up toMap and Stephan for the thorough response of the alternatives in Java 8, it has given me a much better understanding of how to use it fit a requirement, as well as for the optimization of my current code, it has definitely opened up my mind to put an effort into making my code more efficient. And finally, Rob you are right, the filter check is not needed in this scenario because all of the ErrorMessage objects in the stream are assumed to have a valid errorType String.

Looks like I need to book my books again for Java 8 as well as just keep practicing!

[Campbell Ritchie]

I said somebody else would have a better suggestions, didn't I.