public static void main(String[] args) {

    // stream.collect(collector): values
    // Collectors.groupingBy(classifier)
    Stream<Locale> locales = Stream.of(Locale.getAvailableLocales());
    Map<String, List<Locale>> languageToLocales =
        locales.collect(Collectors.groupingBy(Locale::getDisplayLanguage));
    System.out.println(languageToLocales);

    System.out.println("--------------");

    // stream.collect(collector): values
    // Collectors.groupingBy(classifier, downstream)
    locales = Stream.of(Locale.getAvailableLocales());
    Map<String, Long> languageToLocalesCounting =
        locales.collect(Collectors.groupingBy(Locale::getDisplayLanguage, Collectors.counting()));
    System.out.println(languageToLocalesCounting);

    System.out.println("--------------");

    // stream.collect(collector): values
    // Collectors.partitioningBy(predicate)
    locales = Stream.of(Locale.getAvailableLocales());
    Map<Boolean, List<Locale>> englishAndOtherLocales =
        locales.collect(Collectors.partitioningBy(l -> l.getLanguage().equals("en")));
    List<Locale> englishLocales = englishAndOtherLocales.get(true);
    System.out.println(englishLocales);

    System.out.println("--------------");
  }
  public static void main(String[] args) {
    List<Participante> participantes = ParticipantesTdc.listaTodos();

    // Operações Simples
    participantes.stream().count();
    boolean participantInscrito = participantes.stream().anyMatch(Participante::isInscrito);
    Optional<String> optionalEmail2 = participantes.stream().map(Participante::getEmail).findAny();

    // Collectors
    List<String> emailsList =
        participantes.stream().map(Participante::getEmail).collect(Collectors.toList());
    List<String> emailsLinkedList =
        participantes
            .stream()
            .map(Participante::getEmail)
            .collect(Collectors.toCollection(LinkedList::new));
    Set<String> emailsSet =
        participantes.stream().map(Participante::getEmail).collect(Collectors.toSet());

    Map<TamanhoCamisa, List<Participante>> participantesPorTamanho =
        participantes.stream().collect(Collectors.groupingBy(Participante::getTamanhoCamisa));

    Map<TamanhoCamisa, List<String>> emailsPorTamanho =
        participantes
            .stream()
            .collect(
                Collectors.groupingBy(
                    Participante::getTamanhoCamisa,
                    Collectors.mapping(Participante::getEmail, Collectors.toList())));
  }
 public Map<Championship, Map<Season, List<HockeyMatch>>>
     groupAllMatchesByChampionshipAndSeasons() {
   List<HockeyMatch> all = findAll();
   Map<Championship, Map<Season, List<HockeyMatch>>> collect =
       all.stream()
           .collect(
               Collectors.groupingBy(
                   HockeyMatch::getChampionship, Collectors.groupingBy(HockeyMatch::getSeason)));
   return collect;
 }
示例#4
0
  public static void main(String[] args) {
    final List<Person> people =
        Arrays.asList(
            new Person("Robert", 49),
            new Person("John", 20),
            new Person("Sara", 21),
            new Person("Chloe", 18),
            new Person("Jane", 21),
            new Person("Greg", 35));

    List<Person> olderThan20_a = new ArrayList<>();
    people.stream().filter(person -> person.age > 20).forEach(person -> olderThan20_a.add(person));
    printPeople("don't trust olderThan20_a", olderThan20_a);

    List<Person> olderThan20_b =
        people
            .stream()
            .filter(person -> person.age > 20)
            .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
    printPeople("don't trust olderThan20_b", olderThan20_b);

    List<Person> olderThan20_c =
        people.stream().filter(person -> person.age > 20).collect(Collectors.toList());
    printPeople("don't trust olderThan20_c", olderThan20_c);

    Map<Integer, List<Person>> peopleByAge =
        people.stream().collect(Collectors.groupingBy(person -> person.age));
    System.out.println("Grouped by age: " + peopleByAge);

    Map<Integer, List<String>> nameOfPeopleByAge =
        people
            .stream()
            .collect(
                Collectors.groupingBy(
                    person -> person.age,
                    Collectors.mapping(person -> person.name, Collectors.toList())));
    System.out.println("People grouped by age: " + nameOfPeopleByAge);

    // Group the names by their first char and then get the oldest person in
    // each group
    Comparator<Person> byAge = Comparator.comparing(person -> person.age);
    Map<Character, Optional<Person>> oldestPersonOfEachLetter =
        people
            .stream()
            .collect(
                Collectors.groupingBy(
                    person -> person.name.charAt(0),
                    Collectors.reducing(BinaryOperator.maxBy(byAge))));
    System.out.println("Oldest person of each letter:");
    System.out.println(oldestPersonOfEachLetter);
  }
示例#5
0
  private Availability firstAssignation(AID alumn) {
    if (this.groups.containsKey(alumn)) {
      System.err.println("WARN: Requested first assignation for already registered alumn " + alumn);
      return this.groups.get(alumn);
    }

    // TODO: This could be more optimized, for example, having the
    // availabilityCount map cached

    // Get the count of the current availabilities
    final Map<Availability, Long> availabilityCount =
        this.groups.values().stream().collect(Collectors.groupingBy(a -> a, Collectors.counting()));

    // Get the current available groups
    final List<Availability> availableGroups =
        TeacherBehaviour.AVAILABLE_GROUPS
            .stream()
            .filter(
                a -> availabilityCount.getOrDefault(a, 0l) < TeacherBehaviour.MAX_ALUMNS_PER_GROUP)
            .collect(Collectors.toList());

    // Pick a random one
    final Availability result = availableGroups.get(this.random.nextInt(availableGroups.size()));
    this.groups.put(alumn, result);

    return result;
  }
  @Test
  public void vote() throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    Restaurant restaurantB =
        mapper.readValue(new StringReader(testRestaurantJson1), Restaurant.class);
    restaurantRepository.saveAndFlush(restaurantB);
    Restaurant restaurantA =
        mapper.readValue(new StringReader(testRestaurantJson2), Restaurant.class);
    restaurantRepository.saveAndFlush(restaurantA);

    doVote(restaurantB.getRestaurantName(), "qqq");
    doVote(restaurantB.getRestaurantName(), "www");
    doVote(restaurantB.getRestaurantName(), "ddd");

    doVote(restaurantA.getRestaurantName(), "kkk");
    doVote(restaurantA.getRestaurantName(), "lll");

    List<Vote> votes = votesRepository.findAll();
    // check all votes are here
    assertEquals(MAX_TOTAL_VOTES, votes.size());
    Map<Long, Long> res =
        votes.stream().collect(Collectors.groupingBy(Vote::getRestaurantId, Collectors.counting()));
    // check all votes counter correctly
    assertEquals(3l, res.get(restaurantB.getId()).longValue());
    assertEquals(2l, res.get(restaurantA.getId()).longValue());
  }
示例#7
0
  public static void main(String[] args) {

    Map<Integer, HashSet<String>> withSet =
        Stream.of("jon", "andrew", "harvey", "bil")
            .collect(Collectors.groupingBy(String::length, HashSet::new));
    out.println(withSet);
  }
  @Test
  public void testMapping() {
    List<String> input = Arrays.asList("Capital", "lower", "Foo", "bar");
    Collector<String, ?, Map<Boolean, Optional<Integer>>> collector =
        MoreCollectors.partitioningBy(
            str -> Character.isUpperCase(str.charAt(0)),
            MoreCollectors.mapping(String::length, MoreCollectors.first()));
    checkShortCircuitCollector(
        "mapping", new BooleanMap<>(Optional.of(7), Optional.of(5)), 2, input::stream, collector);
    Collector<String, ?, Map<Boolean, Optional<Integer>>> collectorLast =
        MoreCollectors.partitioningBy(
            str -> Character.isUpperCase(str.charAt(0)),
            MoreCollectors.mapping(String::length, MoreCollectors.last()));
    checkCollector(
        "last", new BooleanMap<>(Optional.of(3), Optional.of(3)), input::stream, collectorLast);

    input = Arrays.asList("Abc", "Bac", "Aac", "Abv", "Bbc", "Bgd", "Atc", "Bpv");
    Map<Character, List<String>> expected =
        EntryStream.of('A', Arrays.asList("Abc", "Aac"), 'B', Arrays.asList("Bac", "Bbc")).toMap();
    AtomicInteger cnt = new AtomicInteger();
    Collector<String, ?, Map<Character, List<String>>> groupMap =
        Collectors.groupingBy(
            s -> s.charAt(0),
            MoreCollectors.mapping(
                x -> {
                  cnt.incrementAndGet();
                  return x;
                },
                MoreCollectors.head(2)));
    checkCollector("groupMap", expected, input::stream, groupMap);
    cnt.set(0);
    assertEquals(expected, input.stream().collect(groupMap));
    assertEquals(4, cnt.get());
  }
  /**
   * Process supported manifest headers (Startup-Component and Provide-Capability).
   *
   * <p>Process Startup-Component headers and create StartupComponent instances.
   *
   * <p>Process Provide-Capability headers to calculate the expected number of required
   * capabilities.
   *
   * <p>Process Provide-Capability headers to get a list of CapabilityProviders and
   * RequiredCapabilityListeners.
   *
   * @param bundleList list of bundles to be scanned for Provide-Capability headers.
   * @param supportedManifestHeaders list of manifest headers processed by this method.
   */
  private void processManifestHeaders(
      List<Bundle> bundleList, List<String> supportedManifestHeaders) {
    Map<String, List<ManifestElement>> groupedManifestElements =
        bundleList
            .stream()
            // Filter out all the supported manifest headers.
            .filter(
                bundle ->
                    AccessController.doPrivileged(
                        (PrivilegedAction<Boolean>)
                            () ->
                                isSupportedManifestHeaderExists(bundle, supportedManifestHeaders)))
            // Process filtered manifest headers and get a list of ManifestElements.
            .flatMap(bundle -> extractManifestElements(bundle, supportedManifestHeaders).stream())
            // Partition all the ManifestElements with the manifest header name.
            .collect(Collectors.groupingBy(ManifestElement::getValue));

    if (groupedManifestElements.get(STARTUP_LISTENER_COMPONENT) != null) {
      processStartupComponents(groupedManifestElements.get(STARTUP_LISTENER_COMPONENT));
    }

    if (groupedManifestElements.get(OSGI_SERVICE_COMPONENT) != null) {
      processOSGiServiceCapabilities(groupedManifestElements.get(OSGI_SERVICE_COMPONENT));
    }

    // You can add logic to handle other types of provide capabilities here.
    // e.g. custom manifest headers, config files etc.
  }
示例#10
0
  private List<LDObject> mergeLocations(List<LDObject> ldObjects) {
    Map<String, List<LDObject>> r =
        ldObjects
            .stream()
            .parallel()
            .collect(
                Collectors.groupingBy(
                    ldObject -> {
                      return ldObject.getMap().get("locationId").getValues().get(0);
                    }));

    List<LDObject> finalLocationForJourney = new ArrayList<>();

    final LDObject[] finalObj = {null};
    r.forEach(
        (k, v) -> {
          v.stream()
              .forEach(
                  ldObject -> {
                    if (finalObj[0] == null) {
                      finalObj[0] = ldObject;
                    } else {
                      finalObj[0].merge(ldObject);
                    }
                  });
          finalLocationForJourney.add(finalObj[0]);
          finalObj[0] = null;
        });

    return finalLocationForJourney;
  }
示例#11
0
  public static void main(String[] args) {
    final Collection<Task> tasks =
        Arrays.asList(
            new Task(Status.OPEN, 5), new Task(Status.OPEN, 13), new Task(Status.CLOSED, 8));

    // 在这个task集合中一共有多少个OPEN状态的点?在Java 8之前,要解决这个问题,则需要使用foreach循环遍历task集合;但是在Java
    // 8中可以利用steams解决:包括一系列元素的列表,并且支持顺序和并行处理。
    final long totalPointsOfOpenTasks =
        tasks
            .stream()
            .filter(task -> task.getStatus() == Status.OPEN)
            .mapToInt(Task::getPoints)
            .sum();

    System.out.println("Total points: " + totalPointsOfOpenTasks);

    /**
     * Steam之上的操作可分为中间操作和晚期操作。
     *
     * <p>中间操作会返回一个新的steam——执行一个中间操作(例如filter)并不会执行实际的过滤操作,而是创建一个新的steam,
     * 并将原steam中符合条件的元素放入新创建的steam。
     *
     * <p>晚期操作(例如forEach或者sum),会遍历steam并得出结果或者附带结果;在执行晚期操作之后,steam处理线已经处理完毕,
     * 就不能使用了。在几乎所有情况下,晚期操作都是立刻对steam进行遍历。
     */

    // steam的另一个价值是创造性地支持并行处理(parallel processing)。对于上述的tasks集合,我们可以用下面的代码计算所有任务的点数之和:
    // Calculate total points of all tasks
    final double totalPoints =
        tasks
            .stream()
            .parallel()
            .map(task -> task.getPoints()) // or map( Task::getPoints )
            .reduce(0, Integer::sum);

    System.out.println("Total points (all tasks): " + totalPoints);

    // 对于一个集合,经常需要根据某些条件对其中的元素分组。利用steam提供的API可以很快完成这类任务,代码如下:
    // Group tasks by their status
    final Map<Status, List<Task>> map =
        tasks.stream().collect(Collectors.groupingBy(Task::getStatus));
    System.out.println(map);

    // 最后一个关于tasks集合的例子问题是:如何计算集合中每个任务的点数在集合中所占的比重,具体处理的代码如下:
    // Calculate the weight of each tasks (as percent of total points)
    final Collection<String> result =
        tasks
            .stream() // Stream< String >
            .mapToInt(Task::getPoints) // IntStream
            .asLongStream() // LongStream
            .mapToDouble(points -> points / totalPoints) // DoubleStream
            .boxed() // Stream< Double >
            .mapToLong(weigth -> (long) (weigth * 100)) // LongStream
            .mapToObj(percentage -> percentage + "%") // Stream< String>
            .collect(Collectors.toList()); // List< String >

    System.out.println(result); // [19%, 50%, 30%]
  }
示例#12
0
 @Test
 public void _11_그룹핑() {
   final Stream<Locale> stream = Stream.of(Locale.getAvailableLocales());
   Map<String, List<Locale>> countryToLocales =
       stream.collect(
           Collectors.groupingBy(Locale::getCountry) // 묶을 기준값
           );
   System.out.println(countryToLocales.get("CH"));
 }
示例#13
0
  @Test
  public void gruppiereNachNachnamen() {
    Map<String, List<Person>> gruppiertNachNachnamen =
        newPersonenStream() //
            .collect(Collectors.groupingBy(Person::getNachname));

    assertThat(gruppiertNachNachnamen.keySet(), hasSize(100));
    assertThat(gruppiertNachNachnamen.get("Müller"), hasSize(1000));
    assertThat(gruppiertNachNachnamen.get("Schuster"), hasSize(1000));
  }
 private void checkResults(Restaurant restA, Restaurant restB) {
   List<Vote> votes = votesRepository.findAll();
   // check changing vote doesn't create new entries
   assertEquals(MAX_TOTAL_VOTES, votes.size());
   Map<Long, Long> res =
       votes.stream().collect(Collectors.groupingBy(Vote::getRestaurantId, Collectors.counting()));
   // check that vote actually changed
   assertEquals(2l, res.get(restB.getId()).longValue());
   assertEquals(3l, res.get(restA.getId()).longValue());
 }
  /**
   * Run time: O(n) can use bit vector also
   *
   * @param input
   * @return
   */
  static boolean hasUnique(String input) {
    if (input == null || input.isEmpty()) return true;

    Map<Character, Long> map =
        input
            .chars()
            .mapToObj(c -> (char) c)
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

    return !map.entrySet().stream().anyMatch(x -> x.getValue() > 1);
  }
示例#16
0
 void buildInMem() {
   Collection<EntityType> data = dataSrcFun.apply(dataSrc);
   java.util.Map<String, Set<String>> setMap =
       data.stream()
           .collect(
               Collectors.groupingBy(
                   e -> keyToStringFun.apply(keyGetFun.apply(e)),
                   Collectors.mapping(
                       e -> memberToStringFun.apply(memberGetFun.apply(e)), Collectors.toSet())));
   setMapAdapter.putInMem(mapName, setMap);
 }
示例#17
0
  public static void main(String[] args) {
    final List<Person> people =
        Arrays.asList(
            new Person("John", 20),
            new Person("Sara", 21),
            new Person("Jane", 21),
            new Person("Greg", 35));

    List<Person> olderThan20 =
        people
            .stream()
            .filter(person -> person.getAge() > 20)
            .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
    System.out.println("People older than 20: " + olderThan20);

    List<Person> olderThan20_1 =
        people.stream().filter(person -> person.getAge() > 20).collect(Collectors.toList());
    System.out.println("People older than 20: " + olderThan20_1);

    Map<Integer, List<Person>> peopleByAge =
        people.stream().collect(Collectors.groupingBy(Person::getAge));
    System.out.println("Grouped by age: " + peopleByAge);

    Map<Integer, List<String>> nameOfPeopleByAge =
        people
            .stream()
            .collect(
                Collectors.groupingBy(
                    Person::getAge, Collectors.mapping(Person::getName, Collectors.toList())));
    System.out.println("People name grouped by age: " + nameOfPeopleByAge);

    Comparator<Person> byAge = Comparator.comparing(Person::getAge);
    Map<Character, Optional<Person>> oldestPersonOfEachCharacter =
        people
            .stream()
            .collect(
                Collectors.groupingBy(
                    person -> person.getName().charAt(0),
                    Collectors.reducing(BinaryOperator.maxBy(byAge))));
    System.out.println("Oldest person of each letter: " + oldestPersonOfEachCharacter);
  }
示例#18
0
  public static void main(String[] args) {
    Map<Long, Long> collect =
        IntStream.range(0, 10)
            .mapToObj(Long::valueOf)
            .collect(Collectors.groupingBy(i -> i, reducing((a, b) -> a)));

    System.out.println(collect);

    Map<Long, Long> collect2 =
        IntStream.range(0, 10).mapToObj(Long::valueOf).collect(Collectors.toMap(i -> i, i -> i));
    System.out.println(collect2);
  }
示例#19
0
 public Graph(String line) {
   map =
       Arrays.stream(
               (line.trim() + " " + new StringBuilder(line.trim()).reverse().toString())
                   .split(" "))
           .collect(
               Collectors.groupingBy(
                   x -> ((String) x).charAt(0),
                   Collectors.mapping(
                       x -> ((String) x).charAt(1),
                       Collectors.toCollection(LinkedHashSet<Character>::new))));
 }
示例#20
0
 public void restore(boolean writeMode, Long manifestIdDefault) {
   List<CmsCIRelation> watchedBys;
   long counter = 0;
   long restoredMonitors = 0;
   if (manifestIdDefault == null) {
     watchedBys =
         cmProcessor.getCIRelationsNsLikeNakedNoAttrs("/", "manifest.WatchedBy", null, null, null);
   } else {
     watchedBys = cmManager.getFromCIRelations(manifestIdDefault, "manifest.WatchedBy", null);
   }
   long startTime = System.currentTimeMillis();
   Map<Long, List<CmsCIRelation>> monitors =
       watchedBys.stream().collect(Collectors.groupingBy(CmsCIRelation::getFromCiId));
   for (Long manifestId : monitors.keySet()) {
     counter++;
     List<CmsCIRelation> realizedAsRels =
         cmManager.getFromCIRelations(manifestId, "base.RealizedAs", null);
     if (realizedAsRels.isEmpty()) continue;
     Set<Long> cmsBomCiIds =
         realizedAsRels.stream().map(CmsCIRelation::getToCiId).collect(Collectors.toSet());
     restoreRealizedAsMapping(manifestId, cmsBomCiIds, writeMode);
     boolean isFirstBom = true;
     for (CmsCIRelation relation : realizedAsRels) {
       restoreManifestMapping(manifestId, relation.getToCiId(), writeMode);
       if (isFirstBom) {
         for (CmsCIRelation rel : monitors.get(manifestId)) {
           if (rel.getToCi() == null) {
             rel.setToCi(cmProcessor.getCiById(rel.getToCiId()));
           }
           if (restoreMonitor(manifestId, relation.getToCiId(), rel.getToCi(), writeMode)) {
             restoredMonitors++;
           }
         }
       }
       isFirstBom = false;
     }
     if (counter % 100 == 0) {
       logger.info(
           "Time to process "
               + counter
               + " - "
               + (System.currentTimeMillis() - startTime)
               + " ms!");
     }
   }
   logger.info(">>>>>>>>>>> Monitor restored " + restoredMonitors + ";");
   logger.info(
       ">>>>>>>>>>> Monitor restoration is done!!!"
           + counter
           + " - "
           + (System.currentTimeMillis() - startTime)
           + " ms!");
 }
示例#21
0
  /**
   * Build TrendContent with external services top by average response time.
   *
   * @param period
   * @param limit
   * @param timeRange
   * @param transactions
   * @param transactionsStatistic
   * @return
   */
  public static TrendContext<String> topByAvgResponseTime(
      Long period,
      Integer limit,
      TimeRange timeRange,
      Iterable<ExternalService> transactions,
      Iterable<ExternalServiceStatistic> transactionsStatistic) {

    TrendContext<String> trendContext = new TrendContext<>(period * 1000, timeRange);

    Map<Long, ExternalService> externalServiceMap =
        StreamSupport.stream(transactions.spliterator(), false)
            .collect(Collectors.toMap(ExternalService::getId, (t) -> t));
    Map<String, List<ExternalServiceStatistic>> transactionStatisticMap =
        StreamSupport.stream(transactionsStatistic.spliterator(), false)
            .collect(
                Collectors.groupingBy(
                    statistic -> {
                      Long serviceId = statistic.getExternalServiceId();
                      ExternalService transaction = externalServiceMap.get(serviceId);
                      return transaction.getUrl();
                    }));

    transactionStatisticMap
        .entrySet()
        .stream()
        .sorted(
            Comparator.comparing(
                new Function<Map.Entry<String, List<ExternalServiceStatistic>>, Double>() {
                  @Override
                  public Double apply(Map.Entry<String, List<ExternalServiceStatistic>> entry) {
                    DoubleSummaryStatistics responseSummaryStatistics =
                        entry
                            .getValue()
                            .stream()
                            .filter(statistic -> statistic.getSumResponseTime() != null)
                            .mapToDouble(ExternalServiceStatistic::getSumResponseTime)
                            .summaryStatistics();
                    LongSummaryStatistics pvSummaryStatistics =
                        entry
                            .getValue()
                            .stream()
                            .filter(statistic -> statistic.getPv() != null)
                            .mapToLong(ExternalServiceStatistic::getPv)
                            .summaryStatistics();
                    return calculateRate(
                        responseSummaryStatistics.getSum(), pvSummaryStatistics.getSum());
                  }
                }))
        .limit(limit)
        .forEach(entry -> trendContext.addStatistics(entry.getKey(), timeRange, entry.getValue()));
    return trendContext;
  }
 @Benchmark
 public void parallel_lazy_jdk() {
   Map<Alphagram, List<String>> groupBy =
       this.guavaWords.parallelStream().collect(Collectors.groupingBy(Alphagram::new));
   groupBy
       .entrySet()
       .parallelStream()
       .map(Map.Entry::getValue)
       .filter(list -> list.size() >= SIZE_THRESHOLD)
       .sorted(Comparator.<List<String>>comparingInt(List::size).reversed())
       .map(list -> list.size() + ": " + list)
       .forEach(e -> Assert.assertFalse(e.isEmpty()));
 }
  @RequestMapping("/gameStatus")
  public ResponseEntity<GameStatus> broadcastGameStatus() {
    GameStatus gameStatus = new GameStatus();

    Iterable<GameStep> gameSteps = gameStepRepository.findAll();

    List<GameStep> collect = StreamSupport.stream(gameSteps.spliterator(), false).collect(toList());

    Map<String, List<GameStep>> gameStepByUser =
        StreamSupport.stream(gameSteps.spliterator(), false)
            .collect(Collectors.groupingBy(GameStep::getUserPseudo));

    for (Map.Entry<String, List<GameStep>> gameStepByUserEntry : gameStepByUser.entrySet()) {
      UserGameStatus userGameStatus = new UserGameStatus();

      userGameStatus.setPseudo(gameStepByUserEntry.getKey());

      Map<Step, List<GameStep>> gameStepByStep =
          gameStepByUserEntry.getValue().stream().collect(Collectors.groupingBy(GameStep::getStep));

      for (Map.Entry<Step, List<GameStep>> gameStepByStepEntry : gameStepByStep.entrySet()) {
        gameStepByStepEntry
            .getValue()
            .stream()
            .min(Comparator.comparing(GameStep::getInstant))
            .ifPresent(
                gameStep -> {
                  userGameStatus
                      .getStepInfos()
                      .add(new StepInfo(gameStep.getStep(), gameStep.getInstant()));
                });
      }

      gameStatus.getUserGameStatus().add(userGameStatus);
    }

    webSocketTemplate.convertAndSend("/topic/gameStatus", gameStatus);
    return new ResponseEntity<GameStatus>(gameStatus, HttpStatus.OK);
  }
  @Test
  public void testCollectors() {

    ArrayList<Person> people = new ArrayList<>();
    ArrayList<Integer> things = new ArrayList<>();
    ArrayList<Employee> employees = new ArrayList<>();
    ArrayList<Student> students = new ArrayList<>();

    // Accumulate names into a List
    List<String> list = people.stream().map(Person::getName).collect(Collectors.toList());

    // Accumulate names into a TreeSet
    Set<String> list2 =
        people.stream().map(Person::getName).collect(Collectors.toCollection(TreeSet::new));

    // Convert elements to strings and concatenate them, separated by commas
    String joined = things.stream().map(Object::toString).collect(Collectors.joining(", "));

    // Find highest-paid employee
    Optional<Employee> highestPaid =
        employees.stream().collect(Collectors.maxBy(Comparator.comparingInt(Employee::getSalary)));

    // Group employees by department
    Map<Department, List<Employee>> byDept =
        employees.stream().collect(Collectors.groupingBy(Employee::getDepartment));

    // Find highest-paid employee by department
    Map<Department, Optional<Employee>> highestPaidByDept =
        employees
            .stream()
            .collect(
                Collectors.groupingBy(
                    Employee::getDepartment,
                    Collectors.maxBy(Comparator.comparingInt(Employee::getSalary))));

    // Partition students into passing and failing
    Map<Boolean, List<Student>> passingFailing =
        students.stream().collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));
  }
    /**
     * Returns a partitioned collection of lane number to Tile objects from the provided basecall
     * directory.
     */
    public static Map<Integer, ? extends Collection<Tile>> readLaneTiles(
        final File illuminaRunDirectory, final ReadStructure readStructure) {
      final Collection<Tile> tiles;
      try {
        tiles =
            TileMetricsUtil.parseTileMetrics(
                TileMetricsUtil.renderTileMetricsFileFromBasecallingDirectory(illuminaRunDirectory),
                readStructure);
      } catch (final FileNotFoundException e) {
        throw new PicardException("Unable to open laneMetrics file.", e);
      }

      return tiles.stream().collect(Collectors.groupingBy(Tile::getLaneNumber));
    }
示例#26
0
 // Good reading: https://en.wikipedia.org/wiki/Permutation
 private static double numOfPerms(int[] seq) {
   // Note that the sequence may potentially have repeating elements
   Map<Integer, Long> freq =
       Arrays.stream(seq)
           .boxed()
           .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
   // https://en.wikipedia.org/wiki/Permutation#Permutations_of_multisets
   double numOfPerms = factorial(seq.length);
   for (long uniqElemFreq : freq.values()) {
     // according to the problem description, max size of permutation is in [2..18] range
     numOfPerms /= factorial((int) uniqElemFreq);
   }
   return numOfPerms;
 }
 @Benchmark
 public void serial_lazy_streams_ec() {
   Map<Alphagram, Set<String>> groupBy =
       this.ecWords
           .stream()
           .collect(Collectors.groupingBy(Alphagram::new, Collectors.<String>toSet()));
   groupBy
       .entrySet()
       .stream()
       .map(Map.Entry::getValue)
       .filter(list -> list.size() >= SIZE_THRESHOLD)
       .sorted(Comparator.<Set<String>>comparingInt(Set::size).reversed())
       .map(list -> list.size() + ": " + list)
       .forEach(e -> Assert.assertFalse(e.isEmpty()));
 }
示例#28
0
 @RequestMapping("/events/{eventName}/additional-field")
 public List<TicketFieldConfigurationAndAllDescriptions> getAllAdditionalField(
     @PathVariable("eventName") String eventName) {
   final Map<Integer, List<TicketFieldDescription>> descById =
       ticketFieldRepository
           .findDescriptions(eventName)
           .stream()
           .collect(Collectors.groupingBy(TicketFieldDescription::getTicketFieldConfigurationId));
   return ticketFieldRepository
       .findAdditionalFieldsForEvent(eventName)
       .stream()
       .map(
           field ->
               new TicketFieldConfigurationAndAllDescriptions(
                   field, descById.getOrDefault(field.getId(), Collections.emptyList())))
       .collect(Collectors.toList());
 }
示例#29
0
 @Cacheable(value = "KLineBuss.queryAllGroup")
 public List<KLineGroup> queryAllGroup() {
   Map<Date, Map<String, KLine>> kLineMap =
       kLineRepos
           .findAll()
           .stream()
           .collect(
               Collectors.groupingBy(
                   KLine::getDt, Collectors.toMap(KLine::getCode, kLine -> kLine)));
   List<KLineGroup> list =
       kLineMap
           .entrySet()
           .stream()
           .map(entry -> new KLineGroup(entry.getKey(), entry.getValue()))
           .sorted()
           .collect(Collectors.toList());
   return Collections.unmodifiableList(list);
 }
  static Map<String, MatchedDataPair> matchData(
      DataSource xSource,
      MergeType xMergeType,
      DataSource ySource,
      MergeType yMergeType,
      Resolution resolution) {
    List<String> commonKeys =
        xSource
            .getData()
            .keySet()
            .stream()
            .filter((key) -> ySource.getData().containsKey(key))
            .map(resolution::toKey)
            .distinct()
            .collect(Collectors.toList());

    Function<DataSource, Map<String, List<Double>>> dataOrganizer =
        (source) ->
            source
                .getData()
                .entrySet()
                .stream()
                .filter((entry) -> commonKeys.contains(resolution.toKey(entry)))
                .collect(
                    Collectors.groupingBy(
                        (entry) -> resolution.toKey(entry),
                        Collectors.mapping((entry) -> entry.getValue(), Collectors.toList())));

    Map<String, List<Double>> xData = dataOrganizer.apply(xSource);
    Map<String, List<Double>> yData = dataOrganizer.apply(ySource);

    Map<String, MatchedDataPair> matches =
        commonKeys
            .stream()
            .collect(
                Collectors.<String, String, MatchedDataPair>toMap(
                    key -> key,
                    key ->
                        new MatchedDataPair(
                            xMergeType.merge(xData.get(key)), yMergeType.merge(yData.get(key)))));

    return matches;
  }