Java Lambda: Difference between revisions
Jump to navigation
Jump to search
Line 269: | Line 269: | ||
| valign="top" | | | valign="top" | | ||
* [https://www.dropwizard.io/en/stable/ Dropwizard » Stable] | |||
| valign="top" | | | valign="top" | | ||
|} | |} |
Revision as of 20:23, 24 October 2024
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
| ||