public class Guest {
private final int grade;
private final String name;
private final String company;
...
}import java.util.List;
public interface GuestRepository {
public List<Guest> findAllGuest ();
}public interface ResortService {
public List<String> findGuestNamesByCompany (String company);
}public List<String> findGuestNamesbyCompany(String company) {
List<Guest> all = repository.findAllGuest();
List<Guest> filtered = filter(guests, company);
sort(filtered);
return mapNames(filtered);
}
private List<Guest> filter(List<Guest> guests, String company) {
List<Guest> filtered = new ArrayList<>();
for(Guest guest : guests ) {
if (company.equals(guest.getCompany())) {
filtered.add(guest);
}
}
return filtered;
}
private void sort(List<Guest> guests) {
Collections.sort(guests, new Comparator<Guest>() {
public int compare(Guest o1, Guest o2) {
return Integer.compare(o1.getGrade(), o2.getGrade());
}
});
}
private List<String> mapNames(List<Guest> guests) {
List<String> names = new ArrayList<>();
for(Guest guest : guests ) {
names.add(guest.getName());
}
return names;
}public List<String> findGuestNamesByCompany(final String company) {
List<Guest> all = repository.findAll();
List<Guest> sorted = FluentIterable.from(all)
.filter(new Predicate<Guest>() {
public boolean apply(Guest g) {
return company.equals(g.getCompany());
}
})
.toSortedList(Ordering.natural().onResultOf(
new Function<Guest, Integer>() {
public Integer apply(Guest g) {
return g.getGrade();
}
}));
return FluentIterable.from(sorted)
.transform(new Function<Guest, String>() {
public String apply(Guest g) {
return g.getName();
}
})
.toList();
}public List<String> findGuestNamesByCompany(final String company) {
List<Guest> all = repository.findAll();
return Sequences.sequence(all)
.filter(new Predicate<Guest>() {
public boolean matches(Guest g) {
return company.equals(g.getCompany());
}
})
.sortBy(new Callable1<Guest, Integer>(){
public Integer call(Guest g) {
return g.getGrade();
}
})
.map(new Callable1<Guest, String>(){
public String call(Guest g) {
return g.getName();
}
})
.toList();
}public List<String> findGuestNamesByCompany(final String company) {
List<Guest> all = repository.findAll();
return FastList.newList(all)
.select(new Predicate<Guest>() {
public boolean accept(Guest g) {
return company.equals(g.getCompany());
}
})
.sortThisBy(new Function<Guest, Integer>() {
public Integer valueOf(Guest g) {
return g.getGrade();
}
})
.collect(new Function<Guest, String> () {
public String valueOf(Guest g) {
return g.getName();
}
});
} public List<String> findGuestNamesByCompany(final String company) {
List<Guest> all = repository.findAllGuest();
return Cf.list(all)
.filter(new Function1B<Guest>() {
public boolean apply(Guest g) {
return company.equals(g.getCompany());
}
})
.sortBy(new Function<Guest, Integer>() {
public Integer apply(Guest g) {
return g.getGrade();
}
})
.map(new Function<Guest, String>() {
public String apply(Guest g) {
return g.getName();
}
});
}public List<String> findGuestNamesByCompany(final String company) {
List<Guest> all = repository.findAllGuest();
return Op.on(all)
.removeAllFalse(new IFunction<Guest, Boolean>() {
public Boolean execute(Guest g, ExecCtx ctx) throws Exception {
return company.equals(g.getCompany());
}
})
.sortBy(new IFunction<Guest, Integer>() {
public Integer execute(Guest g, ExecCtx ctx) throws Exception {
return g.getGrade();
}
})
.map(new IFunction<Guest, String>() {
public String execute(Guest g, ExecCtx ctx) throws Exception {
return g.getName();
}
}).get();
}import static ch.lambdaj.Lambda.*;
import static org.hamcrest.Matchers.*;
...
public List<String> findGuestNamesByCompany(final String company) {
List<Guest> all = repository.findAll();
return LambdaCollections.with(all)
.retain(having(on(Guest.class).getCompany(), equalTo(company)))
.sort(on(Guest.class).getGrade())
.extract(on(Guest.class).getName());
}public List<String> findGuestNamesByCompany(String company) {
List<Guest> all = repository.findAll();
Collection<String> mapped = Stream.iterableStream(all)
.filter(new F<Guest, Boolean>() {
public Boolean f(Guest g){
return company.equals(g.getCompany());
}
})
.sort(Ord.ord(
new F<Guest, F<Guest, Ordering>>() {
public F<Guest, Ordering> f(final Guest a1) {
return new F<Guest, Ordering>() {
public Ordering f(final Guest a2) {
int x = Integer.compare(a1.getGrade(), a2.getGrade());
return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
}
};
}
}))
.map(new F<Guest, String>() {
public String f(Guest g) {
return g.getName();
}
})
.toCollection();
return new ArrayList<String>(mapped);
}public List<String> findGuestNamesByCompany(final String company) {
List<Guest> all = repository.findAll();
List<Guest> filtered = ListUtils.select(all, new Predicate<Guest>() {
public boolean evaluate(Guest g) {
return company.equals(g.getCompany());
}
});
Collections.sort(filtered, new Comparator<Guest>() {
public int compare(Guest o1, Guest o2) {
return Integer.compare(o1.getGrade(), o2.getGrade());
}
});
Collection<String> names = CollectionUtils.collect(filtered, new Transformer<Guest, String>(){
public String transform(Guest g) {
return g.getName();
}
});
return new ArrayList<>(names);
}public List<String> findGuestNamesByCompany(final String company) {
List<Guest> all = repository.findAll();
List<Guest> filtered = FunctionalPrimitives.select(all, new Filter<Guest>() {
public Boolean execute(Guest g) {
return company.equals(g.getCompany());
}
});
List<Guest> sorted = Comparables.sort(filtered, new Functor<Guest, Integer>() {
public Integer execute(Guest g) {
return g.getGrade();
}
});
return FunctionalPrimitives.map(sorted, new Functor<Guest, String>() {
public String execute(Guest g) {
return g.getName();
}
});
}- Groovy : 2.3.9
- Scala : 2.11.4
- Kotlin : 0.10.195
- Xtend : 2.7
- Ceylon : 1.1.0
List<String> findGuestNamesByCompany(String company) {
List<Guest> all = repository.findAll()
all.findAll { it.company == company }
.sort { it.grade }
.collect { it.name }
}import scala.collection.JavaConversions._
...
def findGuestNamesByCompany(company: String): java.util.List[String] = {
val all = repository.findAll
all.filter ( _.getCompany == company)
.sortBy ( _.getGrade )
.map ( _.getName )
} override fun findGuestNamesByCompany(company: String): List<String> {
val all = repository.findAll()
return all.filter { it.getCompany() == company }
.sortBy { it.getGrade() }
.map { it.getName() }
}override findGuestNamesByCompany(String aCompany) {
val all = repository.findAll()
all.filter [company == aCompany]
.sortBy[grade]
.map[name]
}import ceylon.interop.java { CeylonIterable }
import java.util {JList = List, JArrayList = ArrayList }
import java.lang {JString = String}
...
shared actual JList<JString> findGuestNamesByCompany(String company) {
value all = repository.findAll() ;
value names = CeylonIterable(all)
.filter((Guest g) => g.company == company)
.sort(byIncreasing((Guest g) => g.grade.intValue()))
.map((Guest g) => g.name);
value jnames = JArrayList<JString>();
for (name in names) {jnames.add(JString(name));}
return jnames;
}public List<String> findGuestNamesByCompany(String company) {
List<Guest> guests = repository.findAll();
return guests.stream()
.filter(g -> company.equals(g.getCompany()))
.sorted(Comparator.comparing(Guest::getGrade))
.map(Guest::getName)
.collect(Collectors.toList());
}public void doGet(final HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
final AsyncContext asyncContext = request.startAsync();
asyncContext.start(new Runnable() {
public void run() {
// long running job
asyncContext.dispatch("/status.jsp");
}
});
}public void doGet(final HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
AsyncContext asyncContext = request.startAsync();
asyncContext.start(() -> {
// long running job
asyncContext.dispatch("/status.jsp");
});
}public List<Guest> findAll() {
return jdbcTemplate.query(SELECT_ALL, new RowMapper<Guest>(){
public Guest mapRow(ResultSet rs, int rowNum) throws SQLException {
return new Guest (
rs.getInt("id"),
rs.getString("name"),
rs.getString("company"),
rs.getInt("grade")
);
}
});
}public List<Guest> findAll() {
return jdbcTemplate.query(SELECT_ALL,
(rs, rowNum) ->new Guest (
rs.getInt("id"),
rs.getString("name"),
rs.getString("company"),
rs.getInt("grade")
)
);
}Button calcButton = (Button) view.findViewById(R.id.calcBtn);
Button sendButton = (Button) view.findViewById(R.id.sendBtn);
calcButton.setOnClickListener(new OnClickListener() {
public void onClick(View view) {
calculate();
}
});
sendButton.setOnClickListener(new OnClickListener() {
public void onClick(View view) {
send();
}
});Button calcButton = (Button) view.findViewById(R.id.calcBtn);
Button sendButton = (Button) view.findViewById(R.id.sendBtn);
calcButton.setOnClickListener(v -> calculate());
sendButton.setOnClickListener(v -> send());@RunWith(JunitSuiteRunner.class)
public class ResortServiceSpec {{
GuestRepository repository = new MemoryRepository();
ResortService service = new ModernJavaResort(repository);
describe("ResortService with modern Java", it -> {
it.isSetupWith(() -> {
repository.save(
new Guest(1, "jsh", "Naver", 15),
new Guest(2, "hny", "Line", 10),
new Guest(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"));
});
});
}}private EntityManager em;
@Autowired
public JinqResort(EntityManager em) {
this.em = em;
}
private <T> JinqStream<T> stream(Class<T> clazz) {
return new JinqJPAStreamProvider(em.getEntityManagerFactory()).streamAll(em, clazz);
}
public List<String> findGuestNamesByCompany(String company) {
return stream(Guest.class)
.where(g -> g.getCompany().equals(company))
.sortedBy(Guest::getGrade)
.select(Guest::getName)
.toList();
}A query generated by JinqResort
Hibernate: select guest0_.id as id1_0_, guest0_.company as company2_0_, guest0_.grade as grade3_0_, guest0_.name as name4_0_ from guest guest0_ where guest0_.company=? order by guest0_.grade ASC limit ?import static spark.Spark.*;
import com.naver.helloworld.resort.service.ResortService;
public class SparkServer {
public static void main(String[] args) {
get("/guests/:company", (request, response) -> {
String company = request.params(":company");
return "No guests from " + company;
});
}
}ResortServer.java (Spark + Spring)
@SpringBootApplication
public class ResortServer {
@Autowired
private ResortService service;
public void start() {
get("/guests/:company", (request, response) -> {
String company = request.params(":company");
List<String> names = service.findGuestNamesByCompany(company);
return "Guests from " + company + " : " + names;
});
}
public static void main(String[] args) {
ApplicationContext context = SpringApplication.run(ResortServer.class);
context.getBean(ResortServer.class).start();
}
}