initial commit

functional-programming-exercises/src/com/example/exercises/ContinentCityPair.java

@@ -0,0 +1,21 @@
+package com.example.exercises;
+
+import java.util.Optional;
+
+import com.example.domain.City;
+
+/**
+ * @author Binnur Kurt <[email protected]>
+ */
+public record ContinentCityPair(String continent,City city) implements Comparable<ContinentCityPair>{
+
+	@Override
+	public int compareTo(ContinentCityPair other) {
+		return this.city.getPopulation()-other.city.getPopulation();
+	}
+
+	public static void printEntry(String continent,Optional<ContinentCityPair> pair) {
+		System.out.printf("%s: %s\n",continent,pair.get().city());
+	}
+
+}

functional-programming-exercises/src/com/example/exercises/CountryCityCountPair.java

@@ -0,0 +1,8 @@
+package com.example.exercises;
+
+import com.example.domain.Country;
+
+/**
+ * @author Binnur Kurt <[email protected]>
+ */
+public record CountryCityCountPair(Country country,int count) { }

functional-programming-exercises/src/com/example/exercises/DirectorGenrePair.java

@@ -0,0 +1,9 @@
+package com.example.exercises;
+
+import com.example.domain.Director;
+import com.example.domain.Genre;
+
+/**
+ * @author Binnur Kurt <[email protected]>
+ */
+record DirectorGenrePair(Director director,Genre genre) { }

functional-programming-exercises/src/com/example/exercises/DirectorGenresPair.java

@@ -0,0 +1,11 @@
+package com.example.exercises;
+
+import java.util.List;
+
+import com.example.domain.Director;
+import com.example.domain.Genre;
+
+/**
+ * @author Binnur Kurt <[email protected]>
+ */
+record DirectorGenresPair(Director director,List<Genre> genres) { }

functional-programming-exercises/src/com/example/exercises/Exercise1.java

@@ -1,7 +1,10 @@
 package com.example.exercises;
 
 import java.util.Collection;
+import java.util.Map;
+import java.util.stream.Collectors;
 
+import com.example.domain.Director;
 import com.example.domain.Movie;
 import com.example.service.InMemoryMovieService;
 import com.example.service.MovieService;
@@ -17,7 +20,16 @@ public class Exercise1 {
 	public static void main(String[] args) {
 		// Find the number of movies of each director
         final Collection<Movie> movies = movieService.findAllMovies();
-
+        Map<String,Long> dirMovCounts = 
+        movies.stream().map(Movie::getDirectors)
+        			   .flatMap(Collection::stream)
+                       .collect(Collectors.groupingBy(
+                    		       Director::getName,
+                    		       Collectors.counting()
+                    		     )
+                        );
+        dirMovCounts.forEach(
+        		(name,count) -> System.out.printf("%20s: %3d\n",name,count));
 	}
 
 }

functional-programming-exercises/src/com/example/exercises/Exercise10.java

@@ -1,7 +1,15 @@
 package com.example.exercises;
 
+import static java.util.Comparator.comparing;
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.maxBy;
+
+import java.util.Optional;
+import java.util.function.BiConsumer;
+
 import com.example.dao.InMemoryWorldDao;
 import com.example.dao.WorldDao;
+import com.example.domain.Country;
 
 /**
  * 
@@ -10,10 +18,14 @@
  */
 public class Exercise10 {
 	private static final WorldDao worldDao = InMemoryWorldDao.getInstance();
-
+	private static final BiConsumer<String,Optional<Country>> printEntry = (continent,country) -> System.out.printf("%s: %s\n",continent,country.get());		
 	public static void main(String[] args) {
 		// Find the richest country of each continent with respect to their GNP (Gross National Product) values.
-
+        var richestCountryByContinent =
+                worldDao.findAllCountries()
+                      .stream()
+                      .collect(groupingBy(Country::getContinent,maxBy(comparing(Country::getGnp))));
+        richestCountryByContinent.forEach(printEntry);
 	}
 
 }

functional-programming-exercises/src/com/example/exercises/Exercise11.java

@@ -1,7 +1,10 @@
 package com.example.exercises;
 
+import static java.util.stream.Collectors.summarizingLong;
+
 import com.example.dao.InMemoryWorldDao;
 import com.example.dao.WorldDao;
+import com.example.domain.Country;
 
 /**
  * 
@@ -13,7 +16,11 @@ public class Exercise11 {
 
 	public static void main(String[] args) {
 		// Find the minimum, the maximum and the average population of world countries
-
+		var populationSummary = 
+		worldDao.findAllCountries()
+		        .stream()
+				.collect(summarizingLong(Country::getPopulation));
+		System.out.println(populationSummary);
 	}
 
 }

functional-programming-exercises/src/com/example/exercises/Exercise12.java

@@ -1,7 +1,14 @@
 package com.example.exercises;
 
+import static java.util.stream.Collectors.groupingBy;
+import static java.util.stream.Collectors.summarizingLong;
+
+import java.util.LongSummaryStatistics;
+import java.util.function.BiConsumer;
+
 import com.example.dao.InMemoryWorldDao;
 import com.example.dao.WorldDao;
+import com.example.domain.Country;
 
 /**
  * 
@@ -11,9 +18,15 @@
 public class Exercise12 {
 	private static final WorldDao worldDao = InMemoryWorldDao.getInstance();
 
+	private static final BiConsumer<String, LongSummaryStatistics> printEntry = (continent, statistics) -> System.out.printf("%s: %s\n", continent, statistics);
+
 	public static void main(String[] args) {
 		// Find the minimum, the maximum and the average population of each continent.
-
+		var populationSummaryByContinent = 
+			worldDao.findAllCountries()
+			        .stream()
+				    .collect(groupingBy(Country::getContinent, summarizingLong(Country::getPopulation)));
+		populationSummaryByContinent.forEach(printEntry);
 	}
 
 }

functional-programming-exercises/src/com/example/exercises/Exercise13.java

@@ -1,7 +1,11 @@
 package com.example.exercises;
 
+import java.util.function.Supplier;
+
 import com.example.dao.InMemoryWorldDao;
 import com.example.dao.WorldDao;
+import com.example.util.CountrySummaryStatistics;
+import static java.lang.Long.compare;
 
 /**
  * 
@@ -11,9 +15,16 @@
 public class Exercise13 {
 	private static final WorldDao worldDao = InMemoryWorldDao.getInstance();
 
+	private static final Supplier<CountrySummaryStatistics> countrySummaryStatisticsSupplier = 
+			() -> new CountrySummaryStatistics((l, r) -> compare(l.getPopulation(), r.getPopulation()));
+
 	public static void main(String[] args) {
 		// Find the countries with the minimum and the maximum population
-
+		var countrySummaryStatistics = 
+				worldDao.findAllCountries()
+				        .stream()
+				        .collect(countrySummaryStatisticsSupplier, CountrySummaryStatistics::accept, CountrySummaryStatistics::combine);
+		System.out.println(countrySummaryStatistics);
 	}
 
 }

functional-programming-exercises/src/com/example/exercises/Exercise14.java

@@ -1,7 +1,16 @@
 package com.example.exercises;
 
+import static java.util.stream.Collector.of;
+import static java.util.stream.Collectors.groupingBy;
+
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Supplier;
+
 import com.example.dao.InMemoryWorldDao;
 import com.example.dao.WorldDao;
+import com.example.domain.Country;
+import com.example.util.CountrySummaryStatistics;
 
 /**
  * 
@@ -11,9 +20,21 @@
 public class Exercise14 {
 	private static final WorldDao worldDao = InMemoryWorldDao.getInstance();
 
+	private static final BiConsumer<String, CountrySummaryStatistics> printEntry =
+			(continent, statistics) -> System.out.printf("%s: %s\n", continent, statistics);
+
+	private static final BiConsumer<CountrySummaryStatistics, Country> accumulator = (a, c) -> a.accept(c);
+	private static final BinaryOperator<CountrySummaryStatistics> combiner = (l, r) -> { l.combine(r);	return l; };
+	private static final Supplier<CountrySummaryStatistics> countrySummaryStatisticsSupplier = 
+			() -> new CountrySummaryStatistics((l, r) -> Long.compare(l.getPopulation(), r.getPopulation()));
+
 	public static void main(String[] args) {
 		// Find the countries of each continent with the minimum and the maximum population
-
+		var continentStatistics = 
+				worldDao.findAllCountries()
+				        .stream()
+				        .collect(groupingBy(Country::getContinent, of(countrySummaryStatisticsSupplier, accumulator, combiner)));
+		continentStatistics.forEach(printEntry);
 	}
 
 }

functional-programming-exercises/src/com/example/exercises/Exercise15.java

@@ -1,7 +1,16 @@
 package com.example.exercises;
 
+import static java.util.Comparator.comparingInt;
+import static java.util.stream.Collectors.groupingBy;
+
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.ToIntFunction;
+
 import com.example.dao.CountryDao;
 import com.example.dao.InMemoryWorldDao;
+import com.example.domain.Country;
 
 /**
  * 
@@ -10,10 +19,23 @@
  */
 public class Exercise15 {
 	private static final CountryDao countryDao = InMemoryWorldDao.getInstance();
+	private static final ToIntFunction<Country> compareByCitiyNumber = country -> country.getCities().size();
+	private static final Consumer<Country> printCountry = country -> System.err.printf("%s: %d\n",country.getName(),country.getCities().size());
+	private static final BiConsumer<String,List<Country>> printEntry = (continent,countries) -> {
+		System.err.println(continent);
+		System.err.println("=".repeat(continent.length()));
+		countries.forEach(printCountry);
+		System.err.println("\n");
+	};
 
 	public static void main(String[] args) {
 		// Group the countries by continent, and then sort the countries in each continent by number of cities in each country.
-
+		var countriesByContinent = 
+		countryDao.findAllCountries()
+                  .stream()
+                  .sorted(comparingInt(compareByCitiyNumber ).reversed())
+                  .collect(groupingBy(Country::getContinent));
+		countriesByContinent.forEach(printEntry);
 	}
 
 }

functional-programming-exercises/src/com/example/exercises/Exercise16.java

@@ -1,7 +1,15 @@
 package com.example.exercises;
 
+import static java.util.stream.Collector.of;
+import static java.util.stream.Collectors.groupingBy;
+
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+
 import com.example.dao.InMemoryWorldDao;
 import com.example.dao.WorldDao;
+import com.example.domain.Country;
+import com.example.util.CountryCitySummaryStatistics;
 
 /**
  * 
@@ -11,9 +19,17 @@
 public class Exercise16 {
 	private static final WorldDao worldDao = InMemoryWorldDao.getInstance();
 
+	private static final BiConsumer<CountryCitySummaryStatistics, Country> accumulator = (s, c) -> s.accept(c);
+	private static final BinaryOperator<CountryCitySummaryStatistics> combiner = (l, r) -> { l.combine(r); return l; };
+	private static final BiConsumer<String, CountryCitySummaryStatistics> printEntry = 
+			(country,statistics) -> System.out.printf("%s: %s\n", country, statistics);
+
 	public static void main(String[] args) {
 		// Find the cities with the minimum and the maximum population in countries.
-
+		var countryCityStatistics = 
+		worldDao.findAllCountries()
+				.stream()
+				.collect(groupingBy(Country::getCode, of(CountryCitySummaryStatistics::new, accumulator, combiner)));
+		countryCityStatistics.forEach(printEntry);
 	}
-
 }

functional-programming-exercises/src/com/example/exercises/Exercise17.java

@@ -2,6 +2,8 @@
 
 import com.example.dao.InMemoryWorldDao;
 import com.example.dao.WorldDao;
+import com.example.domain.Country;
+import com.example.util.DoubleSummaryGaussianStatistics;
 
 /**
  * 
@@ -12,9 +14,17 @@ public class Exercise17 {
 	private static final WorldDao worldDao = InMemoryWorldDao.getInstance();
 
 	public static void main(String[] args) {
-		// Find the minimum, the maximum, the average, and the standard deviation of GNP
-		// values.
-
+		// Find the minimum, the maximum, the average, and the standard deviation of GNP values.
+        var gnpStatistics =
+           worldDao.findAllCountries()
+                   .stream()
+                   .mapToDouble(Country::getGnp)
+                   .collect(
+                           DoubleSummaryGaussianStatistics::new,
+                           DoubleSummaryGaussianStatistics::accept,
+                           DoubleSummaryGaussianStatistics::combine
+                   );
+        System.out.println(gnpStatistics);
 	}
 
 }

functional-programming-exercises/src/com/example/exercises/Exercise18.java

@@ -1,5 +1,10 @@
 package com.example.exercises;
 
+import static java.util.Map.Entry.comparingByValue;
+import static java.util.stream.Collectors.counting;
+import static java.util.stream.Collectors.groupingBy;
+
+import com.example.domain.Movie;
 import com.example.service.InMemoryMovieService;
 import com.example.service.MovieService;
 
@@ -9,11 +14,18 @@
  *
  */
 public class Exercise18 {
-	private static final MovieService movieService = InMemoryMovieService.getInstance();
+	private static final  MovieService movieService = InMemoryMovieService.getInstance();
 
 	public static void main(String[] args) {
 		// Find the year where the maximum number of movie is available
-
+        var movies = movieService.findAllMovies();
+        var maxMovieCountByYear = 
+          movies.stream()
+                .collect(groupingBy(Movie::getYear,counting()))
+        		.entrySet()
+        		.stream()
+        		.max(comparingByValue());
+        maxMovieCountByYear.ifPresent(System.out::println);
 	}
 
 }