Ostatnio zaprzyjaźniłem się z wbudowanymi w Jave interfejsami funkcyjnymi i dosyć szybko zacząłem korzystać tam gdzie to możliwe z method reference zamiast klasycznych metod. Zacząłem się jednak zastanawiać:
- czy to dobry nawyk?
- czy robię to dobrze?
Przykład takiej klasy poniżej.
Przy okazji, ostatnio oglądałem tutorial i w konstruktorze ze springowym Autowired za każdym razem używano oprócz standardowej inicjalizacji pól klasy również metody super() pomimo, że nie było tam żadnego dziedziczenia. Czy to ma coś na celu?
@Service
public class MatcherDomesticIndex {
private LoaderDomesticIndex loaderDomesticIndex;
private LoaderPublicCompanyNewConnect loaderPublicCompanyNewConnect;
private LoaderPublicCompanyMainMarket loaderPublicCompanyMainMarket;
private List<PublicCompany> allCompanies;
@Autowired
public MatcherDomesticIndex(LoaderDomesticIndex loaderDomesticIndex, LoaderPublicCompanyNewConnect loaderPublicCompanyNewConnect,
LoaderPublicCompanyMainMarket loaderPublicCompanyMainMarket) {
this.loaderDomesticIndex = loaderDomesticIndex;
this.loaderPublicCompanyNewConnect = loaderPublicCompanyNewConnect;
this.loaderPublicCompanyMainMarket = loaderPublicCompanyMainMarket;
}
private void addAllCompanies() {
allCompanies = new ArrayList<>();
allCompanies.addAll(loaderPublicCompanyNewConnect.getLoadedAssets().stream().map(e -> (PublicCompany) e).collect(Collectors.toList()));
allCompanies.addAll(loaderPublicCompanyMainMarket.getLoadedAssets().stream().map(e -> (PublicCompany) e).collect(Collectors.toList()));
}
private Function<PublicCompany, Pair<PublicCompany, Optional<PublicCompany>>> pairSingleCompany =
a -> new Pair<>(a, Optional.ofNullable(allCompanies.stream().filter(e -> e.getName().equals(a.getName()))
.findFirst().orElse(null)));
private Function<List<PublicCompany>, List<Pair<PublicCompany, Optional<PublicCompany>>>> pairListOfCompanies = e -> e.stream()
.map(pairSingleCompany).collect(Collectors.toList());
private Function<List<Pair<PublicCompany, Optional<PublicCompany>>>, List<PublicCompany>> convertToPublicCompanyListWithoutNulls =
l -> l.stream().filter(e -> e.getR().isPresent()).map(p -> p.getR().get()).collect(Collectors.toList());
private Function<List<PublicCompany>, List<PublicCompany>> pairCompanies = pairListOfCompanies.andThen(convertToPublicCompanyListWithoutNulls);
private Consumer<DomesticStockIndex> matchSingleIndex = i -> i.setCompanies(pairCompanies.apply(i.getCompanies()));
private Consumer<List<DomesticStockIndex>> matchAllIndexes = i -> i.forEach(matchSingleIndex);
private BiConsumer<DomesticStockIndex, PublicCompany> addIndexToCompany = (i, c) -> c.getDomesticStockIndexes().add(i);
private Consumer<DomesticStockIndex> addIndexToAllCompanies = i -> i.getCompanies().forEach(c -> addIndexToCompany.accept(i, c));
public void matchIndexesWithCompanies() {
addAllCompanies();
matchAllIndexes.accept(loaderDomesticIndex.getLoadedAssets().stream()
.map(e -> (DomesticStockIndex) e).peek(addIndexToAllCompanies).collect(Collectors.toList()));
}
}
Java 
Aventus