returning Hashmap having different mappings in stream

Question

I am learning some cool stuff about Java StreamAPI and got stuck'd into one problem: I have a use case where I want to return newly create hashmap using stream. I am using the traditional way of defining a HashMap in the function and adding up values to it. I was more interested in knowing some better ways to achieve so

public Map<String,String> constructMap(List<CustomObject> lists){
Map<String,String> newMap = new HashMap<>();
lists.stream().filter(x->x!=null).forEach(map -> newMap.putAll(map.getSomeMapping(studentId));
return newMap;
}

Can I achieve this using reduceAPI or any other way without having to create a custom hashmap (directly return the stream one liner)?

Edit: for Example:

CustomObject c1 = new CustomObject("bookId1", "book1");
CustomObject c2 = new CustomObject("bookId2", "book2");
List<CustomObject> lists = new ArrayList();
lists.add(c1); lists.add(c2);

The getter in class CustomObject is: getSomeMapping(input)
 which return Map<BookID, Book> 

Expected output: 
{"bookId1" : "book1", "bookId2" : "book2"}

Edit2:

One more thing to clarify, the CustomObject class does not have any other getters defined. The only function I have access to is getSomeMapping(input) which returns a mapping

thank you for any help.

Answer 1

Assuming CustomObject has the following structure and getter getSomeMapping which returns a map:

class CustomObject {
    private Map<String, String> someMapping;

    public CustomObject(String key, String value) {
        this.someMapping = new HashMap<>();
        someMapping.put(key, value);
    }


    public Map<String, String> getSomeMapping() {
        return someMapping;
    }
}

Then constructMap will use already mentioned Collectors.toMap after flattening the entries in someMapping:

public static Map<String, String> constructMap(List<CustomObject> list) {
    return list.stream()
            .filter(Objects::nonNull)
            .map(CustomObject::getSomeMapping)
            .flatMap(map -> map.entrySet().stream())
            .collect(Collectors.toMap(
                    Map.Entry::getKey,
                    Map.Entry::getValue,
                    (v1, v2) -> v1, // merge function to handle possible duplicates
                    LinkedHashMap::new
            ));
}

Test

CustomObject c1 = new CustomObject("bookId1", "book1");
CustomObject c2 = new CustomObject("bookId2", "book2");
List<CustomObject> lists = Arrays.asList(c1, c2);

Map<String, String> result = constructMap(lists);
System.out.println(result);

Output:

{bookId1=book1, bookId2=book2}

Answer 2

You can use Collectors#toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier) to create a LinkedHashMap using the bookId as the key, and bookName as the value.

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

class CustomObject {
    private String bookId;
    private String bookName;

    public CustomObject(String bookId, String bookName) {
        this.bookId = bookId;
        this.bookName = bookName;
    }

    public String getBookId() {
        return bookId;
    }

    public String getBookName() {
        return bookName;
    }
    
    // Other stuff e.g. equals, hashCode etc.
}

public class Main {
    public static void main(String[] args) {
        List<CustomObject> list = List.of(new CustomObject("bookId1", "book1"), new CustomObject("bookId2", "book2"));
        System.out.println(constructMap(list));
    }

    public static Map<String, String> constructMap(List<CustomObject> list) {
        return list.stream()
                .filter(Objects::nonNull)
                .collect(Collectors.toMap(CustomObject::getBookId, CustomObject::getBookName, (a, b) -> a, LinkedHashMap::new));
    }
}

Output:

{bookId1=book1, bookId2=book2}

Note: The mergeFunction, (a, b) -> a resolves the collision between values associated with the same key e.g. in this case, we have defined it to select a out of a and b having the same key. If the order of elements does not matter, you can use Collectors#toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper) as shown below:

public static Map<String, String> constructMap(List<CustomObject> list) {
    return list.stream()
            .filter(Objects::nonNull)
            .collect(Collectors.toMap(CustomObject::getBookId, CustomObject::getBookName));
}

A sample output:

{bookId2=book2, bookId1=book1}

Answer 3

Look into [Collectors.toMap()] 1. This can return the items as a new Map.

lists.stream().filter(x->x!=null).collect(Collectors.toMap(CustomObject::getMapKey(), CustomObject::getMapValue()));

getMapKey and getMapValue are here methods returning the key and value of the CustomObject for the map. Instead of using simple getters it might also be necessary to execute some more advanced logic.

lists.stream().filter(x->x!=null).collect(Collectors.toMap(l -> {...; return key;}, l -> { ...; return value;}));

Answer 4

To turn a stream into a map you're better off using collect(). For instance:

public Map<String,String> toMap(List<Entry<String,String>> entries) {
  return entries.stream().collect(Collectors.toMap(Entry::getKey, Entry::getValue));
}

Or if your keys are non-unique and you want the values to be combined as a list:

public Map<String,List<CustomObject>> toMap(List<CustomObject> entries) {
  return entries.stream().collect(Collectors.groupingBy(CustomObject::getKey));
}

Answer 5

Let's assume your CustomObject class has getters to retrieve a school id with a name. You could do it like this. I declared it static as it does not appear to depend on instance fields.

public static Map<String,String> constructMap(List<CustomObject> lists){
    return lists.stream()
           .filter(Objects::nonNull)
           .collect(Collectors.toMap(CustomObject::getName, CustomObject::getID));
}

This presumes that names and Id's are one-to-one, as this does not handle duplicate keys.