Java Lambda

Map<String, String> insured = Stream.of("Adults:1", "Children:1", "Senior Citizen:10")
                                    .map(pair -> pair.split(":"))
                                    .collect(Collectors.toMap(pair -> pair[0], pair->pair[1]));

Double totalInsured = insured.values().stream().mapToDouble(d -> Double.parseDouble(d)).sum();
Double totalInsured = insured.values().stream().mapToDouble(Double::parseDouble).sum();

Integer totalInsured = insured.values().stream().mapToInt(d -> Integer.parseInt(d)).sum();
Integer totalInsured = insured.values().stream().mapToInt(Integer::parseInt).sum();

Map<String, String> filter  = insured.entrySet().stream()
                                     .filter(map -> !"Children".equals(map.getKey()))
                                     .collect(Collectors.toMap(map -> map.getKey(), map -> map.getValue()));

Integer totalInsured = filter.values().stream().mapToInt(Integer::parseInt).sum();

---

Map<String, String> mapping =  Stream.of("travel_adult:Adults", "travel_children:Children", "travel_senior_citizen:Senior Citizen")
                                     .map(pair -> pair.split(":"))
                                     .collect(Collectors.toMap(pair -> pair[0], pair->pair[1]));

Map<String, String> reverse = mapping.entrySet().stream()
                                     .collect(Collectors.toMap(map -> map.getValue(), map -> map.getKey()));

---

int totalInsured = properties.entrySet().stream()
        .filter(map-> ArrayUtils.contains(INSURED_OBJECT_MAP.values().toArray(), map.getKey()))
        .collect(Collectors.toMap(map -> map.getKey(), map -> (Integer)map.getValue()))
        .values().stream().mapToInt(Integer::new).sum();

---

private static Map<String, Object> decode(String encode) {
    return Stream.of(encode.split(LIST_SPLITTER))
            .map(String::trim).collect(Collectors.toList())
            .stream().map(pair -> pair.split(PAIR_SPLITTER))
            .collect(Collectors.toMap(array -> array[0], array -> array[1]));
}

Collectors

import java.util.Map;
import java.util.List;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.Collections;
import java.util.stream.Collectors;

Collectors » Example 1

List<Map> list = new ArrayList<>();
Map<String, Object> commission1 = new HashMap<>();
commission1.put("Total", 1000);
commission1.put("rate", 10);
list.add(commission1);

Map<String, Object> commission2 = new HashMap<>();
commission2.put("Total", 10000);
commission2.put("rate", 10);
list.add(commission2);

Map<String, Object> commission3 = new HashMap<>();
commission3.put("Tutal", 10000);
commission3.put("rate", 10);
list.add(commission3);

//list.stream().filter(m-> m.containsKey("Total")).collect(Collectors.toList());
System.out.println(list.stream().filter(m-> m.containsKey("Total")).collect(Collectors.toList()));
list.stream().filter(m-> m.containsKey("Total")).collect(Collectors.toList()).forEach(m -> System.out.println(m.get("Total")));

//list.stream().filter(m-> m.containsKey("Total")).mapToInt(m -> (int)m.get("Total")).sum()
System.out.println(list.stream().filter(m-> m.containsKey("Total")).mapToInt(m -> (int)m.get("Total")).sum());

//list.stream().filter(m-> m.containsKey("Total")).map(m->m.get("Total")).collect(Collectors.toList())
System.out.println(list.stream().filter(m-> m.containsKey("Total")).map(m->m.get("Total")).collect(Collectors.toList()));

List<Map> filteredList = list.stream().filter(m-> m.containsKey("Total")).collect(Collectors.toList());
System.out.println(filteredList.stream().map(m->m.get("Total")).collect(Collectors.toList()));

System.out.println(filteredList.stream().map(m->String.valueOf(m.get("Total"))).collect(Collectors.toList()));
System.out.println(filteredList.stream().map(m->String.valueOf(m.get("Total"))).collect(Collectors.joining(",")));

Collectors » Example 2

Map<String, String> requestHeaders = new HashMap<>();
requestHeaders.put("X-Auth-Token", "JWT");
requestHeaders.put("Content-Type", "Application/Json");
requestHeaders.put("Accept", "Application/Json");

Map<String, String> mapper = new HashMap<>();
mapper.put("X-Auth-Token", "Authorization");
mapper.put("Content-Type", "Content-Type");
mapper.put("Accept", "Accept");

Map<String, String> headers = requestHeaders.entrySet()
    .stream().filter(e -> mapper.containsKey(e.getKey()))
    .collect(Collectors.toMap(e -> mapper.get(e.getKey()), e -> e.getValue()));

Collectors » Example 3

String[] paths = new String[]{
    "/home/chorke/sites/staging/certificates/chorke-00-000.pdf",
    "/home/chorke/sites/staging/certificates/chorke-00-001.pdf",
    "/home/chorke/sites/staging/certificates/chorke-00-002.pdf",
};

List<String> suffixes = Arrays.stream(paths).map(path -> {
    String pathPrefix = "/home/chorke/sites/staging";
    if (!pathPrefix.endsWith("/")) pathPrefix = String.format("%s/", pathPrefix);
    return path.replace(pathPrefix, "");
}).collect(Collectors.toList());

Deserialize

import java.util.Map;
import java.util.List;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.stream.Stream;
import java.util.stream.Collectors;

Example » Seed Data

Stream<String> lines = Stream.of(
    "name:Anika,slug:hamida-anika,status:permitted",
    "name:Khaled,slug:galib-khaled,status:permitted",
    "name:Mannat,slug:halima-mannat,status:permitted",
    "name:Raiyan,slug:shahed-raiyan,status:permitted",
    "name:Aursha,slug:al-raji-aursha,status:permitted"
);

String workflows = "id:1000001,slug:motor-bike-insurance;id:1000002,slug:motor-car-insurance;id:1000003,slug:travel-insurance";

Example » Deserialize

List<Map<String, String>> nephews = new ArrayList<>();
//var nephews = new ArrayList<Map<String, String>>();

lines.forEach(line -> nephews.add(
    Stream.of(line.split(",")).map(pair -> pair.split(":"))
    .collect(Collectors.toMap(pair -> pair[0], pair->pair[1]))
));

System.out.println(String.format("%s", nephews));

//Object products = Stream.of(workflows.split(";")).map(
//    workflow -> Stream.of(workflow.split(",")).collect(Collectors.toList())
//).collect(Collectors.toList());

Object products = Stream.of(workflows.split(";")).map(
    workflow -> Stream.of(workflow.split(",")).map(pair -> pair.split(":"))
    .collect(Collectors.toMap(pair -> pair[0], pair->pair[1]))
).collect(Collectors.toList());

Object products = Stream.of(workflows.split(";")).map(
    workflow -> Stream.of(workflow.split(",")).map(pair -> pair.split(":"))
    .collect(Collectors.toMap(pair -> pair[0], pair->pair[1]))
)
.parallel().filter(map -> "motor-bike-insurance".equals(map.get("slug")))
.map(map -> map.get("id")).findFirst();

System.out.println(String.format("%s", products));

Example » Predication

boolean anyMatch  = nephews.stream().anyMatch( nephew -> "Anika".equals(nephew.get("name")));
boolean noneMatch = nephews.stream().noneMatch(nephew -> "Raida".equals(nephew.get("name")));
boolean allMatch  = nephews.stream().allMatch( nephew -> nephew.get("name").startsWith("A"));

Example » Filter

List<Map<String, String>> filter = nephews.stream().filter(nephew -> nephew.get("name").startsWith("A")).collect(Collectors.toList());

List<String> names = nephews.stream().map(nephew -> nephew.get("name")).collect(Collectors.toCollection(ArrayList::new));
List<String> names = nephews.stream().map(nephew -> nephew.get("name")).collect(Collectors.toList());

Example » Sorted

names.stream().forEach(System.out::println);
names.stream().forEachOrdered(System.out::println);
names.stream().sorted().forEach(System.out::println);
names.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);

References

Sum values in a Map with a stream Else method for ifPresent Stream Convert List of String to Integers Linq like 19WAS85/coollection Java stream filter sum of values Java Stream Filter for Sum Java equivalent for LINQ