Add implementation for UserServiceImpl

vitalibutnar · vitalibutnar · commit 0542e186db30 · 2021-09-30T10:08:44.000+03:00
diff --git a/src/main/java/com/endava/internship/service/UserServiceImpl.java b/src/main/java/com/endava/internship/service/UserServiceImpl.java
@@ -2,68 +2,99 @@
 
 import com.endava.internship.domain.Privilege;
 import com.endava.internship.domain.User;
-import com.endava.internship.service.UserService;
 
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.stream.Collectors;
 
 public class UserServiceImpl implements UserService {
 
     @Override
     public List<String> getFirstNamesReverseSorted(List<User> users) {
-        throw new UnsupportedOperationException("Not implemented");
+        return users.stream().
+                map(User::getFirstName).
+                sorted((name1, name2) -> -name1.compareTo(name2)).
+                collect(Collectors.toList());
     }
 
     @Override
     public List<User> sortByAgeDescAndNameAsc(final List<User> users) {
-        throw new UnsupportedOperationException("Not implemented");
+        return users.stream().
+                sorted(Comparator.
+                        comparing(User::getAge, (age1, age2) -> -age1.compareTo(age2)).
+                        thenComparing(User::getFirstName)
+                ).
+                collect(Collectors.toList());
     }
 
     @Override
     public List<Privilege> getAllDistinctPrivileges(final List<User> users) {
-        throw new UnsupportedOperationException("Not implemented");
+        return users.stream().
+                map(User::getPrivileges).
+                flatMap(Collection::stream).
+                distinct().
+                collect(Collectors.toList());
     }
 
     @Override
     public Optional<User> getUpdateUserWithAgeHigherThan(final List<User> users, final int age) {
-        throw new UnsupportedOperationException("Not implemented");
+        return users.stream().
+                filter(user -> user.getAge() > age).
+                findFirst();
     }
 
     @Override
     public Map<Integer, List<User>> groupByCountOfPrivileges(final List<User> users) {
-        throw new UnsupportedOperationException("Not implemented");
+        return users.stream().collect(Collectors.groupingBy(user -> user.getPrivileges().size()));
     }
 
     @Override
     public double getAverageAgeForUsers(final List<User> users) {
-        throw new UnsupportedOperationException("Not implemented");
+        return users.stream().mapToDouble(User::getAge).average().orElse(-1d);
     }
 
     @Override
     public Optional<String> getMostFrequentLastName(final List<User> users) {
-        throw new UnsupportedOperationException("Not implemented");
+        Map<String, Long> map = users.stream().map(User::getLastName).
+                collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
+        Long max = map.values().stream().max(Long::compareTo).orElse(0L);
+        return map.values().stream().filter(val -> val.equals(max)).count() != 1 ? Optional.empty() :
+                map.entrySet().stream().max(Map.Entry.comparingByValue()).map(Map.Entry::getKey);
     }
 
     @Override
     public List<User> filterBy(final List<User> users, final Predicate<User>... predicates) {
-        throw new UnsupportedOperationException("Not implemented");
+        return users.stream().
+                filter(
+                        Arrays.stream(predicates).reduce(Predicate::and).orElse(x -> true)
+                ).
+                collect(Collectors.toList());
     }
 
     @Override
     public String convertTo(final List<User> users, final String delimiter, final Function<User, String> mapFun) {
-        throw new UnsupportedOperationException("Not implemented");
+        return users.stream().map(mapFun).reduce((res, str) -> res += delimiter + str).orElse("");
     }
 
     @Override
     public Map<Privilege, List<User>> groupByPrivileges(List<User> users) {
-        throw new UnsupportedOperationException("Not implemented");
+        return users.stream().map(User::getPrivileges).flatMap(Collection::stream).
+                distinct().
+                collect(Collectors.toMap(
+                                privilege -> privilege,
+                                privilege -> users.stream().filter(user -> user.getPrivileges().contains(privilege)).collect(Collectors.toList())
+                        )
+                );
     }
 
     @Override
     public Map<String, Long> getNumberOfLastNames(final List<User> users) {
-        throw new UnsupportedOperationException("Not implemented");
+        return users.stream().collect(Collectors.groupingBy(User::getLastName, Collectors.counting()));
     }
 }
