Filtering, sorting, mapping

Backgrounds

Guest.java

publicclassGuest {
privatefinalintgrade;
privatefinalStringname;
privatefinalStringcompany;
...
}

GuestRepository.java

importjava.util.List;
publicinterfaceGuestRepository {
publicList<Guest> findAllGuest ();
}

ResortService.java

publicinterfaceResortService {
publicList<String> findGuestNamesByCompany (Stringcompany);
}

Implementations by classic Java

JDK Collections framework

ClassicJavaResort.java

publicList<String> findGuestNamesbyCompany(Stringcompany) {
List<Guest> all = repository.findAllGuest();
List<Guest> filtered = filter(guests, company);
sort(filtered);
returnmapNames(filtered);
}
privateList<Guest> filter(List<Guest> guests, Stringcompany) {
List<Guest> filtered = newArrayList<>();
for(Guestguest : guests ) {
if (company.equals(guest.getCompany())) {
filtered.add(guest);
}
}
returnfiltered;
}
privatevoidsort(List<Guest> guests) {
Collections.sort(guests, newComparator<Guest>() {
publicintcompare(Guesto1, Guesto2) {
returnInteger.compare(o1.getGrade(), o2.getGrade());
}
});
}
privateList<String> mapNames(List<Guest> guests) {
List<String> names = newArrayList<>();
for(Guestguest : guests ) {
names.add(guest.getName());
}
returnnames;
}

Guava

GuavaResort.java

publicList<String> findGuestNamesByCompany(finalStringcompany) {
List<Guest> all = repository.findAll();
List<Guest> sorted = FluentIterable.from(all)
.filter(newPredicate<Guest>() {
publicbooleanapply(Guestg) {
returncompany.equals(g.getCompany());
}
})
.toSortedList(Ordering.natural().onResultOf(
newFunction<Guest, Integer>() {
publicIntegerapply(Guestg) {
returng.getGrade();
}
}));
returnFluentIterable.from(sorted)
.transform(newFunction<Guest, String>() {
publicStringapply(Guestg) {
returng.getName();
}
})
.toList();
}

Totally Lazy

TotallyLazyResort.java

publicList<String> findGuestNamesByCompany(finalStringcompany) {
List<Guest> all = repository.findAll();
returnSequences.sequence(all)
.filter(newPredicate<Guest>() {
publicbooleanmatches(Guestg) {
returncompany.equals(g.getCompany());
}
})
.sortBy(newCallable1<Guest, Integer>(){
publicIntegercall(Guestg) {
returng.getGrade();
}
})
.map(newCallable1<Guest, String>(){
publicStringcall(Guestg) {
returng.getName();
}
})
.toList();
}

GS Collections

GsCollectoinsResort.java

publicList<String> findGuestNamesByCompany(finalStringcompany) {
List<Guest> all = repository.findAll();
returnFastList.newList(all)
.select(newPredicate<Guest>() {
publicbooleanaccept(Guestg) {
returncompany.equals(g.getCompany());
}
})
.sortThisBy(newFunction<Guest, Integer>() {
publicIntegervalueOf(Guestg) {
returng.getGrade();
}
})
.collect(newFunction<Guest, String> () {
publicStringvalueOf(Guestg) {
returng.getName();
}
});
}

Bolts

BoltsResort.java

publicList<String> findGuestNamesByCompany(finalStringcompany) {
List<Guest> all = repository.findAllGuest();
returnCf.list(all)
.filter(newFunction1B<Guest>() {
publicbooleanapply(Guestg) {
returncompany.equals(g.getCompany());
}
})
.sortBy(newFunction<Guest, Integer>() {
publicIntegerapply(Guestg) {
returng.getGrade();
}
})
.map(newFunction<Guest, String>() {
publicStringapply(Guestg) {
returng.getName();
}
});
}

Op4j

Op4JResort.java

publicList<String> findGuestNamesByCompany(finalStringcompany) {
List<Guest> all = repository.findAllGuest();
returnOp.on(all)
.removeAllFalse(newIFunction<Guest, Boolean>() {
publicBooleanexecute(Guestg, ExecCtxctx) throwsException {
returncompany.equals(g.getCompany());
}
})
.sortBy(newIFunction<Guest, Integer>() {
publicIntegerexecute(Guestg, ExecCtxctx) throwsException {
returng.getGrade();
}
})
.map(newIFunction<Guest, String>() {
publicStringexecute(Guestg, ExecCtxctx) throwsException {
returng.getName();
}
}).get();
}

Lambdaj

LambdaJResort.java

importstaticch.lambdaj.Lambda.*;
importstaticorg.hamcrest.Matchers.*;
...
publicList<String> findGuestNamesByCompany(finalStringcompany) {
List<Guest> all = repository.findAll();
returnLambdaCollections.with(all)
.retain(having(on(Guest.class).getCompany(), equalTo(company)))
.sort(on(Guest.class).getGrade())
.extract(on(Guest.class).getName());
}

Functional Java

FunctionalJavaResort.java

publicList<String> findGuestNamesByCompany(Stringcompany) {
List<Guest> all = repository.findAll();
Collection<String> mapped = Stream.iterableStream(all)
.filter(newF<Guest, Boolean>() {
publicBooleanf(Guestg){
returncompany.equals(g.getCompany());
}
})
.sort(Ord.ord(
newF<Guest, F<Guest, Ordering>>() {
publicF<Guest, Ordering> f(finalGuesta1) {
returnnewF<Guest, Ordering>() {
publicOrderingf(finalGuesta2) {
intx = Integer.compare(a1.getGrade(), a2.getGrade());
returnx < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
}
};
}
}))
.map(newF<Guest, String>() {
publicStringf(Guestg) {
returng.getName();
}
})
.toCollection();
returnnewArrayList<String>(mapped);
}

Apache Commons Collections

CommonsCollectionsResort.java

publicList<String> findGuestNamesByCompany(finalStringcompany) {
List<Guest> all = repository.findAll();
List<Guest> filtered = ListUtils.select(all, newPredicate<Guest>() {
publicbooleanevaluate(Guestg) {
returncompany.equals(g.getCompany());
}
});
Collections.sort(filtered, newComparator<Guest>() {
publicintcompare(Guesto1, Guesto2) {
returnInteger.compare(o1.getGrade(), o2.getGrade());
}
});
Collection<String> names = CollectionUtils.collect(filtered, newTransformer<Guest, String>(){
publicStringtransform(Guestg) {
returng.getName();
}
});
returnnewArrayList<>(names);
}

Jedi

JediResort.java

publicList<String> findGuestNamesByCompany(finalStringcompany) {
List<Guest> all = repository.findAll();
List<Guest> filtered = FunctionalPrimitives.select(all, newFilter<Guest>() {
publicBooleanexecute(Guestg) {
returncompany.equals(g.getCompany());
}
});
List<Guest> sorted = Comparables.sort(filtered, newFunctor<Guest, Integer>() {
publicIntegerexecute(Guestg) {
returng.getGrade();
}
});
returnFunctionalPrimitives.map(sorted, newFunctor<Guest, String>() {
publicStringexecute(Guestg) {
returng.getName();
}
});
}

Implementations by other JVM languages

• Groovy : 2.3.9
• Scala : 2.11.4
• Kotlin : 0.10.195
• Xtend : 2.7
• Ceylon : 1.1.0

Groovy

GroovyAdvancedResort.groovy

List<String>findGuestNamesByCompany(Stringcompany) {
List<Guest> all = repository.findAll()
all.findAll { it.company == company }
.sort { it.grade }
.collect { it.name }
}

Scala

ScalaAdvancedResort.scala

importscala.collection.JavaConversions._
...
deffindGuestNamesByCompany(company: String): java.util.List[String] = {
valall= repository.findAll
all.filter ( _.getCompany == company)
.sortBy ( _.getGrade )
.map ( _.getName )
}

Kotlin

KotlinAdvancedResort.kt

overridefunfindGuestNamesByCompany(company:String): List<String> {
val all = repository.findAll()
return all.filter { it.getCompany() == company }
.sortBy { it.getGrade() }
.map { it.getName() }
}

Xtend

XtendAdvancedResort.xtend

override findGuestNamesByCompany(String aCompany) {
val all = repository.findAll()
all.filter [company == aCompany]
.sortBy[grade]
.map[name]
}

Ceylon

resort.ceylon

importceylon.interop.java { CeylonIterable }
importjava.util {JList = List, JArrayList = ArrayList }
importjava.lang {JString = String}
...
sharedactualJList<JString> findGuestNamesByCompany(Stringcompany) {
valueall = repository.findAll() ;
valuenames = CeylonIterable(all)
.filter((Guestg) => g.company == company)
.sort(byIncreasing((Guestg) => g.grade.intValue()))
.map((Guestg) => g.name);
valuejnames = JArrayList<JString>();
for (nameinnames) {jnames.add(JString(name));}
returnjnames;
}

Implementations by modern Java

ModernJavaAdvancedResort.java

publicList<String> findGuestNamesByCompany(Stringcompany) {
List<Guest> guests = repository.findAll();
returnguests.stream()
.filter(g -> company.equals(g.getCompany()))
.sorted(Comparator.comparing(Guest::getGrade))
.map(Guest::getName)
.collect(Collectors.toList());
}

Refactoring by lambda expressions

Async Servlet

Classic Java

ClassicAsyncServlet.java

publicvoiddoGet(finalHttpServletRequestrequest, HttpServletResponseresponse) throwsServletException, IOException {
finalAsyncContextasyncContext = request.startAsync();
asyncContext.start(newRunnable() {
publicvoidrun() {
// long running jobasyncContext.dispatch("/status.jsp");
}
});
}

Modern Java

ModernAsyncServlet.java

publicvoiddoGet(finalHttpServletRequestrequest,	HttpServletResponseresponse) throwsServletException, IOException {
AsyncContextasyncContext = request.startAsync();
asyncContext.start(() -> {
// long running jobasyncContext.dispatch("/status.jsp");
});
}

Spring JDBC

Classic Java

ClassicJdbcRepository.java

publicList<Guest> findAll() {
returnjdbcTemplate.query(SELECT_ALL, newRowMapper<Guest>(){
publicGuestmapRow(ResultSetrs, introwNum) throwsSQLException {
returnnewGuest (
rs.getInt("id"),
rs.getString("name"),
rs.getString("company"),
rs.getInt("grade")
);
}
});
}

Modern Java

ModernJdbcRepository.java

publicList<Guest> findAll() {
returnjdbcTemplate.query(SELECT_ALL,
(rs, rowNum) ->newGuest (
rs.getInt("id"),
rs.getString("name"),
rs.getString("company"),
rs.getInt("grade")
)
);
}

Event bindings in Android

Classic Java

ClassicFragment.java

ButtoncalcButton = (Button) view.findViewById(R.id.calcBtn);
ButtonsendButton = (Button) view.findViewById(R.id.sendBtn);
calcButton.setOnClickListener(newOnClickListener() {
publicvoidonClick(Viewview) {
calculate();
}
});
sendButton.setOnClickListener(newOnClickListener() {
publicvoidonClick(Viewview) {
send();
}
});

Modern Java

ModernFragment.java

ButtoncalcButton = (Button) view.findViewById(R.id.calcBtn);
ButtonsendButton = (Button) view.findViewById(R.id.sendBtn);
calcButton.setOnClickListener(v -> calculate());
sendButton.setOnClickListener(v -> send());

Frameworks using lambda expressions

Lambda Behave

ResortServiceSpec.java

@RunWith(JunitSuiteRunner.class)
publicclassResortServiceSpec {{
GuestRepositoryrepository = newMemoryRepository();
ResortServiceservice = newModernJavaResort(repository);
describe("ResortService with modern Java", it -> {
it.isSetupWith(() -> {
repository.save(
newGuest(1, "jsh", "Naver", 15),
newGuest(2, "hny", "Line", 10),
newGuest(3, "chy", "Naver", 5)
);
});
it.isConcludedWith(repository::deleteAll);
it.should("find names of guests by company ", expect -> {
List<String> names = service.findGuestNamesByCompany("Naver");
expect.that(names).isEqualTo(Arrays.asList("chy","jsh"));
});
});
}}

Jinq

JinqResort.java

privateEntityManagerem;
@AutowiredpublicJinqResort(EntityManagerem) {
this.em = em;
}
private <T> JinqStream<T> stream(Class<T> clazz) {
returnnewJinqJPAStreamProvider(em.getEntityManagerFactory()).streamAll(em, clazz);
}
publicList<String> findGuestNamesByCompany(Stringcompany) {
returnstream(Guest.class)
.where(g -> g.getCompany().equals(company))
.sortedBy(Guest::getGrade)
.select(Guest::getName)
.toList();
}

A query generated by JinqResort

	Hibernate: selectguest0_.idas id1_0_, guest0_.companyas company2_0_, guest0_.gradeas grade3_0_, guest0_.nameas name4_0_ from guest guest0_ whereguest0_.company=? order byguest0_.gradeASClimit ?

Spark

SparkServer.java

importstaticspark.Spark.*;
importcom.naver.helloworld.resort.service.ResortService;
publicclassSparkServer {
publicstaticvoidmain(String[] args) {
get("/guests/:company", (request, response) -> {
Stringcompany = request.params(":company");
return"No guests from " + company;
});
}
}

ResortServer.java (Spark + Spring)

@SpringBootApplicationpublicclassResortServer {
@AutowiredprivateResortServiceservice;
publicvoidstart() {
get("/guests/:company", (request, response) -> {
Stringcompany = request.params(":company");
List<String> names = service.findGuestNamesByCompany(company);
return"Guests from " + company + " : " + names;
});
}
publicstaticvoidmain(String[] args) {
ApplicationContextcontext = SpringApplication.run(ResortServer.class);
context.getBean(ResortServer.class).start();
}
}