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));

// [id:1000001, slug:motor-bike-insurance], [id:1000002, slug:motor-car-insurance], [id:1000003, slug:travel-insurance]]
Object products = Stream.of(workflows.split(";")).map(
    workflow -> Stream.of(workflow.split(",")).collect(Collectors.toList())
).collect(Collectors.toList());

// [{id=1000001, slug=motor-bike-insurance}, {id=1000002, slug=motor-car-insurance}, {id=1000003, slug=travel-insurance}]
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());

// Optional[{id=1000001, slug=motor-bike-insurance}]
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")))
.findFirst();

// Optional[1000001]
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();

// 1000001
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().orElseGet(()-> null);

// null
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-boat-insurance".equals(map.get("slug")))
.map(map -> map.get("id")).findFirst().orElseGet(()-> null);

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
Spring Exception Handling Spring Cloud OpenFeign JSON Schema Validation Spring Security Apache Camel Netflix Eureka Camunda Jasypt Redis Java	Dropwizard » Stable