Java Lambda: Difference between revisions
Jump to navigation
Jump to search
No edit summary |
|||
(49 intermediate revisions by the same user not shown) | |||
Line 1: | Line 1: | ||
< | <syntaxhighlight lang="java"> | ||
Map<String, String> insured = Stream.of("Adults:1", "Children:1", "Senior Citizen:10") | Map<String, String> insured = Stream.of("Adults:1", "Children:1", "Senior Citizen:10") | ||
.map(pair -> pair.split(":")) | .map(pair -> pair.split(":")) | ||
.collect(Collectors.toMap(pair -> pair[0], pair->pair[1])); | .collect(Collectors.toMap(pair -> pair[0], pair->pair[1])); | ||
</ | </syntaxhighlight> | ||
< | <syntaxhighlight lang="java"> | ||
Double totalInsured = insured.values().stream().mapToDouble(d -> Double.parseDouble(d)).sum(); | Double totalInsured = insured.values().stream().mapToDouble(d -> Double.parseDouble(d)).sum(); | ||
</ | Double totalInsured = insured.values().stream().mapToDouble(Double::parseDouble).sum(); | ||
</syntaxhighlight> | |||
<syntaxhighlight lang="java"> | |||
Integer totalInsured = insured.values().stream().mapToInt(d -> Integer.parseInt(d)).sum(); | |||
Integer totalInsured = insured.values().stream().mapToInt(Integer::parseInt).sum(); | |||
</syntaxhighlight> | |||
<syntaxhighlight lang="java"> | |||
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(); | |||
</syntaxhighlight> | |||
---- | |||
<syntaxhighlight lang="java"> | |||
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())); | |||
</syntaxhighlight> | |||
---- | |||
<syntaxhighlight lang="java"> | |||
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(); | |||
</syntaxhighlight> | |||
---- | |||
<syntaxhighlight lang="java"> | |||
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])); | |||
} | |||
</syntaxhighlight> | |||
==Collectors== | |||
<syntaxhighlight lang="Java"> | |||
import java.util.Map; | |||
import java.util.Set; | |||
import java.util.List; | |||
import java.util.Queue; | |||
import java.util.HashMap; | |||
import java.util.TreeMap; | |||
import java.util.ArrayList; | |||
import java.util.Comparator; | |||
import java.util.Collections; | |||
import java.util.stream.Stream; | |||
import java.util.stream.Collectors; | |||
</syntaxhighlight> | |||
===Collectors » Example 1=== | |||
<syntaxhighlight lang="Java"> | |||
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(","))); | |||
</syntaxhighlight> | |||
===Collectors » Example 2=== | |||
<syntaxhighlight lang="Java"> | |||
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())); | |||
</syntaxhighlight> | |||
===Collectors » Example 3=== | |||
<syntaxhighlight lang="Java"> | |||
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()); | |||
</syntaxhighlight> | |||
==Deserialize== | |||
<syntaxhighlight lang="Java"> | |||
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; | |||
</syntaxhighlight> | |||
===Example » Seed Data=== | |||
<syntaxhighlight lang="Java"> | |||
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"; | |||
</syntaxhighlight> | |||
===Example » Deserialize=== | |||
<syntaxhighlight lang="Java"> | |||
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)); | |||
</syntaxhighlight> | |||
<syntaxhighlight lang="Java"> | |||
// [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()); | |||
</syntaxhighlight> | |||
<syntaxhighlight lang="Java"> | |||
// 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(); | |||
</syntaxhighlight> | |||
<syntaxhighlight lang="Java"> | |||
// 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)); | |||
</syntaxhighlight> | |||
===Example » Predication=== | |||
<syntaxhighlight lang="Java"> | |||
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")); | |||
</syntaxhighlight> | |||
===Example » Filter=== | |||
<syntaxhighlight lang="Java"> | |||
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()); | |||
</syntaxhighlight> | |||
===Example » Sorted=== | |||
<syntaxhighlight lang="Java"> | |||
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); | |||
</syntaxhighlight> | |||
==References== | ==References== | ||
Line 18: | Line 249: | ||
| valign="top" | | | valign="top" | | ||
* [https://stackoverflow.com/questions/30089469/ Sum values in a Map with a stream] | * [https://stackoverflow.com/questions/30089469/ Sum values in a Map with a stream] | ||
* [https://stackoverflow.com/questions/32704551/ Else method for ifPresent Stream] | |||
* [https://stackoverflow.com/questions/23057549/ Convert List of String to Integers] | |||
* [https://github.com/19WAS85/coollection Linq like <code>19WAS85/coollection</code>] | |||
* [https://stackoverflow.com/questions/44101297/ Java stream filter sum of values] | |||
* [https://stackoverflow.com/questions/44101297/ Java Stream Filter for Sum] | |||
* [https://stackoverflow.com/questions/1217228/ Java equivalent for LINQ] | |||
| valign="top" | | | valign="top" | | ||
| valign="top" | | |||
|- | |||
| colspan="3" | | |||
---- | |||
|- | |||
| valign="top" | | |||
* [[Spring Exception Handling]] | |||
* [[Spring Cloud OpenFeign]] | |||
* [[JSON Schema Validation]] | |||
* [[Spring Security]] | |||
* [[Apache Camel]] | |||
* [[Netflix Eureka]] | |||
* [[Camunda]] | |||
* [[Jasypt]] | |||
* [[Redis]] | |||
* [[Java]] | |||
| valign="top" | | |||
* [[Dropwizard]] | |||
| valign="top" | | |||
|} | |} |
Latest revision as of 08:34, 27 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.Set;
import java.util.List;
import java.util.Queue;
import java.util.HashMap;
import java.util.TreeMap;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Collections;
import java.util.stream.Stream;
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
| ||