package com.richard.lambdaexpressions;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
public class RosterTest {
interface CheckPerson{
boolean test(Person p);
}
//approach 1:Create Methods that search for members that match one characteristic
public static void printPersonsOlderThan(List<Person> roster,int age){
for(Person p:roster){
if(p.getAge()>=age){
p.printPerson();
}
}
}
//approach 2:Create more generalized search methods
public static void printPersonsWithAgeRange(List<Person> roster,int low,int high){
for(Person p:roster){
if(low<=p.getAge()&& p.getAge()<=high){
p.printPerson();
}
}
}
//Approach 3:specify search criteria code in a local class
public static void printPersons(List<Person> roster,CheckPerson tester){
for(Person p:roster){
if(tester.test(p)){
p.printPerson();
}
}
}
//approach 6:use standard functional interfaces with lambda expressions
public static void printPersonsWithPredicate(List<Person>roster,Predicate<Person> tester){
for(Person p:roster){
if(tester.test(p)){
p.printPerson();
}
}
}
//approach 7: Use Lambda Expressions throughout your application.
public static void processPersons(List<Person>roster,
Predicate<Person>tester,Consumer<Person>block){
for(Person p:roster){
if(tester.test(p)){
block.accept(p);
}
}
}
public static void processPersonWithFunction(
List<Person> roster,
Predicate<Person> tester,
Function<Person,String> mapper,
Consumer<String> block){
for(Person p:roster){
if(tester.test(p)){
String data=mapper.apply(p);
block.accept(data);
}
}
}
//Approach 8:use generics more extensively
public static <X,Y> void processElements(
Iterable<X> source,
Predicate<X> tester,
Function<X,Y> mapper,
Consumer<Y> block){
for(X p:source){
if(tester.test(p)){
Y data=mapper.apply(p);
block.accept(data);
}
}
}
public static void main(String... args){
List<Person> roster=Person.createRoster();
for(Person p:roster){
p.printPerson();
}
System.out.println("********approach 1***************");
//approach 1:Create Methods that search for members that match one characteristic
printPersonsOlderThan(roster,30);
System.out.println("********approach 2***************");
//approach 2:Create more generalized search methods
printPersonsWithAgeRange(roster,20,30);
System.out.println("********approach 3***************");
//approach 3: specify search criteria code in a local class
class CheckPersonEligibleForSelectiveService implements CheckPerson{
public boolean test(Person p){
return p.getGender()==Person.Sex.MALE &&
p.getAge()>=20 &&
p.getAge()<=30;
}
}
printPersons(roster,new CheckPersonEligibleForSelectiveService());
System.out.println("********approach 4***************");
//approach 4:specify search criteria code in an anonymous class
printPersons(roster,new CheckPerson(){
public boolean test(Person p){
return p.getGender()==Person.Sex.MALE &&
p.getAge()>=18 &&
p.getAge()<=30;
}
});
System.out.println("********approach 5***************");
//approach 5:Specify search criteria code with a lambda expression
printPersons(roster,(Person p)->p.getGender()==Person.Sex.MALE &&
p.getAge()>=18 &&
p.getAge()<=30);
System.out.println("********approach 6***************");
//approach 6:Use standard functional interfaces with lambda expressions
printPersonsWithPredicate(roster,(Person p)->p.getGender()==Person.Sex.MALE &&
p.getAge()>=18 &&
p.getAge()<=30);
System.out.println("********approach 7***************");
//approach 7:Use Lambda Expressions throughout your application.
processPersons(roster,
p->p.getGender()==Person.Sex.MALE &&
p.getAge()>=20 &&
p.getAge()<=30,
p->p.printPerson());
processPersonWithFunction(roster,
p->p.getGender()==Person.Sex.MALE &&
p.getAge()>=20 &&
p.getAge()<=30,
p->p.getEmailAddress(),
email->System.out.println(email));
System.out.println("********approach 8***************");
//Approach 8:Use Generics More Extensively
processPersons(roster,
p->p.getGender()==Person.Sex.MALE &&
p.getAge()>=20 &&
p.getAge()<=30,
p->p.printPerson());
processElements(
roster,
p->p.getGender()==Person.Sex.MALE &&
p.getAge()>=20 &&
p.getAge()<=30,
p->p.getEmailAddress(),
email->System.out.println(email));
System.out.println("********approach 9***************");
//Aproach 9: use aggregate operations that accept Lambda Expressions as parameters
roster
.stream()
.filter(
p->p.getGender()==Person.Sex.MALE &&
p.getAge()>=20 &&
p.getAge()<=30)
.map(p->p.getEmailAddress())
.forEach(email->System.out.println(email));
}
}
