Refine search
private List<URIStatus> sortByFieldAndOrder( List<URIStatus> statuses, String sortField, boolean reverse) throws IOException { Optional<Comparator<URIStatus>> sortToUse = Optional.ofNullable( SORT_FIELD_COMPARATORS.get(sortField)); if (!sortToUse.isPresent()) { throw new InvalidArgumentException(ExceptionMessage.INVALID_ARGS_SORT_FIELD .getMessage(sortField)); } Comparator<URIStatus> sortBy = sortToUse.get(); if (reverse) { sortBy = sortBy.reversed(); } return statuses.stream().sorted(sortBy).collect(Collectors.toList()); }
@Benchmark public void serial_lazy_jdk() { Map<Alphagram, Set<String>> groupBy = this.jdkWords.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())); }
@Benchmark public void serial_lazy_jdk() { Map<Alphagram, List<String>> groupBy = this.jdkWords.stream().collect(Collectors.groupingBy(Alphagram::new)); groupBy.entrySet() .stream() .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())); }
public static List<Locale.LanguageRange> range(final String value) { // remove trailing ';' well-formed vs ill-formed String wellformed = value; if (wellformed.charAt(wellformed.length() - 1) == ';') { wellformed = wellformed.substring(0, wellformed.length() - 1); } List<Locale.LanguageRange> range = Locale.LanguageRange.parse(wellformed); return range.stream() .sorted(Comparator.comparing(Locale.LanguageRange::getWeight).reversed()) .collect(Collectors.toList()); }
@Benchmark public void parallel_lazy_jdk() { Map<Alphagram, Set<String>> groupBy = this.jdkWords.parallelStream().collect(Collectors.groupingBy(Alphagram::new, Collectors.<String>toSet())); groupBy.entrySet() .parallelStream() .map(Map.Entry::getValue) .filter(list -> list.size() >= SIZE_THRESHOLD) .sorted(Comparator.<Set<String>>comparingInt(Set::size).reversed()) .parallel() .map(list -> list.size() + ": " + list) .forEach(e -> Assert.assertFalse(e.isEmpty())); }
private static List<Map.Entry<String, MetricStatsInt>> fiveBiggest(DistributedMetricStatsInt distributedMetricStatsInt, ToIntFunction<MetricStatsInt> biggerCriteria) { Comparator<Map.Entry<String, MetricStatsInt>> comparator = Comparator.comparingInt(a -> biggerCriteria.applyAsInt(a.getValue())); return distributedMetricStatsInt.getForLabels() .entrySet() .stream() .sorted(comparator.reversed()) .limit(5) .collect(MoreCollectors.toList(5)); }
@Benchmark public void serial_lazy_streams_gsc() { Map<Alphagram, List<String>> groupBy = this.gscWords.stream().collect(Collectors.groupingBy(Alphagram::new)); groupBy.entrySet() .stream() .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())); }
@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())); }
@Benchmark public void parallel_lazy_streams_gsc() { Map<Alphagram, List<String>> groupBy = this.gscWords.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())); }
@Benchmark public void serial_lazy_jdk() { Map<Alphagram, List<String>> groupBy = this.guavaWords.stream().collect(Collectors.groupingBy(Alphagram::new)); groupBy.entrySet() .stream() .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())); }
@Benchmark public void parallel_lazy_streams_gsc() { Map<Alphagram, List<String>> groupBy = this.gscWords.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())); }
@Benchmark public void serial_lazy_streams_gsc() { Map<Alphagram, Set<String>> groupBy = this.gscWords.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())); }
@Benchmark public void parallel_lazy_jdk() { Map<Alphagram, List<String>> groupBy = this.jdkWords.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())); }
@Benchmark public void serial_lazy_streams_gsc() { Map<Alphagram, List<String>> groupBy = this.gscWords.stream().collect(Collectors.groupingBy(Alphagram::new)); groupBy.entrySet() .stream() .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())); }
@Benchmark public void parallel_lazy_streams_gsc() { Map<Alphagram, Set<String>> groupBy = this.gscWords.parallelStream().collect(Collectors.groupingBy(Alphagram::new, Collectors.<String>toSet())); groupBy.entrySet() .parallelStream() .map(Map.Entry::getValue) .filter(list -> list.size() >= SIZE_THRESHOLD) .sorted(Comparator.<Set<String>>comparingInt(Set::size).reversed()) .parallel() .map(list -> list.size() + ": " + list) .forEach(e -> Assert.assertFalse(e.isEmpty())); }
@Override public boolean matches(Issue issue) { DefaultIssue defaultIssue = (DefaultIssue) issue; Optional<String> lastPreviousStatus = defaultIssue.changes().stream() // exclude current change (if any) .filter(change -> change != defaultIssue.currentChange()) .filter(change -> change.creationDate() != null) .sorted(Comparator.comparing(FieldDiffs::creationDate).reversed()) .map(change -> change.get("status")) .filter(Objects::nonNull) .findFirst() .map(t -> (String) t.oldValue()); return lastPreviousStatus.filter(this.expectedPreviousStatus::equals).isPresent(); } }
protected void match(Tracking<RAW, BASE> tracking, Function<Trackable, SearchKey> searchKeyFactory) { if (tracking.isComplete()) { return; } Multimap<SearchKey, BASE> baseSearch = ArrayListMultimap.create(); tracking.getUnmatchedBases() .forEach(base -> baseSearch.put(searchKeyFactory.apply(base), base)); tracking.getUnmatchedRaws().forEach(raw -> { SearchKey rawKey = searchKeyFactory.apply(raw); Collection<BASE> bases = baseSearch.get(rawKey); bases.stream() .sorted(comparing(this::statusRank).reversed() .thenComparing(comparing(Trackable::getCreationDate))) .findFirst() .ifPresent(match -> { tracking.match(raw, match); baseSearch.remove(rawKey, match); }); }); }
@Override public void execute(Context context) { DefaultIssue defaultIssue = (DefaultIssue) context.issue(); String previousResolution = defaultIssue.changes().stream() // exclude current change (if any) .filter(change -> change != defaultIssue.currentChange()) .filter(change -> change.creationDate() != null) .sorted(Comparator.comparing(FieldDiffs::creationDate).reversed()) .map(this::parse) .filter(Objects::nonNull) .filter(StatusAndResolutionDiffs::hasResolution) .findFirst() .map(t -> t.newStatusClosed ? t.oldResolution : t.newResolution) .orElse(null); context.setResolution(previousResolution); }