下面列出了java.util.stream.Stream#sorted ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@Override
public Stream<HUEditorRow> streamPage(
final int firstRow,
final int pageLength,
@NonNull final HUEditorRowFilter filter,
@NonNull final ViewRowsOrderBy orderBys)
{
final ViewRowsOrderBy orderBysEffective = !orderBys.isEmpty()
? orderBys
: orderBys.withOrderBys(defaultOrderBys);
Stream<HUEditorRow> stream = getRows().stream()
.skip(firstRow)
.limit(pageLength)
.filter(HUEditorRowFilters.toPredicate(filter));
final Comparator<HUEditorRow> comparator = orderBysEffective.toComparatorOrNull();
if (comparator != null)
{
stream = stream.sorted(comparator);
}
return stream;
}
public static final JSONLookupValuesList ofLookupValuesList(
@Nullable final LookupValuesList lookupValues,
@NonNull final String adLanguage)
{
if (lookupValues == null || lookupValues.isEmpty())
{
return EMPTY;
}
Stream<JSONLookupValue> jsonValues = lookupValues.getValues()
.stream()
.map(lookupValue -> JSONLookupValue.ofLookupValue(lookupValue, adLanguage));
if (!lookupValues.isOrdered())
{
jsonValues = jsonValues.sorted(Comparator.comparing(JSONLookupValue::getCaption));
}
final ImmutableList<JSONLookupValue> jsonValuesList = jsonValues.collect(ImmutableList.toImmutableList());
final DebugProperties otherProperties = lookupValues.getDebugProperties();
return new JSONLookupValuesList(jsonValuesList, otherProperties);
}
@Override
public Stream<T> fetchChildren(
HierarchicalQuery<T, SerializablePredicate<T>> query) {
if (!treeData.contains(query.getParent())) {
throw new IllegalArgumentException("The queried item "
+ query.getParent()
+ " could not be found in the backing TreeData. "
+ "Did you forget to refresh this data provider after item removal?");
}
Stream<T> childStream = getFilteredStream(
treeData.getChildren(query.getParent()).stream(),
query.getFilter());
Optional<Comparator<T>> comparing = Stream
.of(query.getInMemorySorting(), sortOrder)
.filter(Objects::nonNull)
.reduce((c1, c2) -> c1.thenComparing(c2));
if (comparing.isPresent()) {
childStream = childStream.sorted(comparing.get());
}
return childStream.skip(query.getOffset()).limit(query.getLimit());
}
/**
* Computes the term->count counts for the specified term values relative to the
*
* @param field the name of the field to compute term counts against
* @param parsed contains the docset to compute term counts relative to
* @param terms a list of term values (in the specified field) to compute the counts for
*/
protected NamedList<Integer> getListedTermCounts(String field, final ParsedParams parsed, List<String> terms)
throws IOException {
final String sort = parsed.params.getFieldParam(field, FacetParams.FACET_SORT, "empty");
final SchemaField sf = searcher.getSchema().getField(field);
final FieldType ft = sf.getType();
final DocSet baseDocset = parsed.docs;
final NamedList<Integer> res = new NamedList<>();
Stream<String> inputStream = terms.stream();
if (sort.equals(FacetParams.FACET_SORT_INDEX)) { // it might always make sense
inputStream = inputStream.sorted();
}
Stream<SimpleImmutableEntry<String,Integer>> termCountEntries = inputStream
.map((term) -> new SimpleImmutableEntry<>(term, numDocs(term, sf, ft, baseDocset)));
if (sort.equals(FacetParams.FACET_SORT_COUNT)) {
termCountEntries = termCountEntries.sorted(Collections.reverseOrder(Map.Entry.comparingByValue()));
}
termCountEntries.forEach(e -> res.add(e.getKey(), e.getValue()));
return res;
}
/**
* {@inheritDoc}
*/
@Override public BinaryClassificationEvaluationContext<L> mergeWith(
BinaryClassificationEvaluationContext<L> other) {
checkNewLabel(other.firstClsLbl);
checkNewLabel(other.secondClsLbl);
List<L> uniqLabels = new ArrayList<>(4);
uniqLabels.add(this.firstClsLbl);
uniqLabels.add(this.secondClsLbl);
uniqLabels.add(other.firstClsLbl);
uniqLabels.add(other.secondClsLbl);
Stream<L> s = uniqLabels.stream().filter(Objects::nonNull).distinct();
if (firstClsLbl instanceof Comparable || secondClsLbl instanceof Comparable ||
other.firstClsLbl instanceof Comparable || other.secondClsLbl instanceof Comparable)
s = s.sorted();
uniqLabels = s.collect(Collectors.toList());
A.ensure(uniqLabels.size() < 3, "labels.length < 3");
return new BinaryClassificationEvaluationContext<>(
uniqLabels.isEmpty() ? null : uniqLabels.get(0),
uniqLabels.size() < 2 ? null : uniqLabels.get(1)
);
}
@Override
public Consumer createConsumer(Processor processor) throws Exception {
// load goals from resource
InputStream is = getResourceAsInputStream();
String text = IOHelper.loadText(is);
// split each line
Stream<String> stream = Arrays.stream(text.split("\n"));
// sort goals scored on minutes
stream = stream.sorted((a, b) -> goalTime(a).compareTo(goalTime(b)));
// store goals in a list
List<String> goals = stream.collect(Collectors.toList());
// create consumer with the goals
return new GoalConsumer(this, processor, goals);
}
public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map, boolean descending) {
Stream<Entry<K, V>> stream = map.entrySet().stream();
if (descending) {
stream = stream.sorted(Entry.comparingByValue(Collections.reverseOrder()));
} else {
stream = stream.sorted(Entry.comparingByValue());
}
return stream.collect(Collectors.toMap(Entry::getKey, Entry::getValue, (firstEntry, secondEntry) -> firstEntry, LinkedHashMap::new));
}
protected void rebuildView() {
Stream<M> stream = StreamSupport.stream(delegate.spliterator(), false);
if(filter != null) {
stream = stream.filter(filter);
}
if(comparator != null) {
stream = stream.sorted(comparator);
}
this.view = stream.collect(Collectors.toList());
this.listeners.fireEvent(ViewModelEvent.changed());
}
@VisibleForTesting
@Nonnull
TableAnswerElement processAnswerTable(TableAnswerElement rawTable, AnswerRowsOptions options) {
Map<String, ColumnMetadata> rawColumnMap = rawTable.getMetadata().toColumnMap();
List<Row> filteredRows =
rawTable.getRowsList().stream()
.filter(row -> options.getFilters().stream().allMatch(filter -> filter.matches(row)))
.collect(ImmutableList.toImmutableList());
Stream<Row> rowStream = filteredRows.stream();
if (!options.getSortOrder().isEmpty()) {
// sort using specified sort order
rowStream = rowStream.sorted(buildComparator(rawColumnMap, options.getSortOrder()));
}
TableAnswerElement table;
if (options.getColumns().isEmpty()) {
table = new TableAnswerElement(rawTable.getMetadata());
} else {
// project to desired columns
rowStream =
rowStream.map(rawRow -> Row.builder().putAll(rawRow, options.getColumns()).build());
Map<String, ColumnMetadata> columnMap = new LinkedHashMap<>(rawColumnMap);
columnMap.keySet().retainAll(options.getColumns());
List<ColumnMetadata> columnMetadata =
columnMap.values().stream().collect(ImmutableList.toImmutableList());
table =
new TableAnswerElement(
new TableMetadata(columnMetadata, rawTable.getMetadata().getTextDesc()));
}
if (options.getUniqueRows()) {
// uniquify if desired
rowStream = rowStream.distinct();
}
// offset, truncate, and add to table
rowStream.skip(options.getRowOffset()).limit(options.getMaxRows()).forEach(table::addRow);
table.setSummary(rawTable.getSummary() != null ? rawTable.getSummary() : new AnswerSummary());
table.getSummary().setNumResults(filteredRows.size());
return table;
}
@Override
@SuppressWarnings("unchecked")
public <T> Collection<T> execute(@Nullable VaultQuery vaultQuery, @Nullable Comparator<?> comparator, long offset,
int rows, String keyspace, Class<T> type) {
Stream<String> stream = getRequiredAdapter().doList(keyspace).stream();
if (vaultQuery != null) {
stream = stream.filter(vaultQuery::test);
}
if (comparator == null) {
if (offset > 0) {
stream = stream.skip(offset);
}
if (rows > 0) {
stream = stream.limit(rows);
}
}
Stream<T> typed = stream.map(it -> getRequiredAdapter().get(it, keyspace, type));
if (comparator != null) {
typed = typed.sorted((Comparator) comparator);
if (offset > 0) {
typed = typed.skip(offset);
}
if (rows > 0) {
typed = typed.limit(rows);
}
}
return typed.collect(Collectors.toCollection(ArrayList::new));
}
void filter()
{
if (refreshing.isVisible())
{
return;
}
mainPanel.removeAll();
Stream<PluginItem> stream = plugins.stream();
String search = searchBar.getText();
boolean isSearching = search != null && !search.trim().isEmpty();
if (isSearching)
{
String[] searchArray = SPACES.split(search.toLowerCase());
stream = stream
.filter(p -> Text.matchesSearchTerms(searchArray, p.keywords))
.sorted(Comparator.comparing(p -> p.manifest.getDisplayName()));
}
else
{
stream = stream
.sorted(Comparator.comparing(PluginItem::isInstalled).thenComparing(p -> p.manifest.getDisplayName()));
}
stream.forEach(mainPanel::add);
mainPanel.revalidate();
}
public static <K extends Comparable<? super K>, V> Map<K, V> sortByKey(Map<K, V> map, boolean descending) {
Stream<Entry<K, V>> stream = map.entrySet().stream();
if (descending) {
stream = stream.sorted(Entry.comparingByKey(Collections.reverseOrder()));
} else {
stream = stream.sorted(Entry.comparingByKey());
}
return stream.collect(Collectors.toMap(Entry::getKey, Entry::getValue, (firstEntry, secondEntry) -> secondEntry, LinkedHashMap::new));
}
/**
* Creates a Response which contains the proper paged details.
*
* @param uriInfo The URI information of the request.
* @param items The total list of items that need to be sorted, limited, and offset.
* @param comparator The Comparator which will be used to sort the items.
* @param asc Whether the sorting should be ascending or descending.
* @param limit The size of the page of items to return.
* @param offset The number of items to skip.
* @param <T> A class that extends Object.
* @return A Response with a page of items that has been filtered, sorted, and limited and headers for the total
* size and links to the next and previous pages if present.
*/
private <T> Response createPagedResponse(UriInfo uriInfo, List<T> items, Comparator<T> comparator, boolean asc,
int limit, int offset) {
validatePaginationParams(limit, offset, items.size());
Stream<T> stream = items.stream();
if (!asc) {
stream = stream.sorted(comparator.reversed());
} else {
stream = stream.sorted(comparator);
}
if (offset > 0) {
stream = stream.skip(offset);
}
if (limit > 0) {
stream = stream.limit(limit);
}
List<T> pagedItems = stream.collect(Collectors.toList());
Response.ResponseBuilder builder = Response.ok(pagedItems).header("X-Total-Count", items.size());
Links links = LinksUtils.buildLinks(uriInfo, pagedItems.size(), items.size(), limit, offset);
if (links.getNext() != null) {
builder = builder.link(links.getBase() + links.getNext(), "next");
}
if (links.getPrev() != null) {
builder = builder.link(links.getBase() + links.getPrev(), "prev");
}
return builder.build();
}
@Override
public Stream<T> fetch(Query<T, SerializablePredicate<T>> query) {
Stream<T> stream = getFilteredStream(query);
Optional<Comparator<T>> comparing = Stream
.of(query.getInMemorySorting(), sortOrder)
.filter(Objects::nonNull)
.reduce((c1, c2) -> c1.thenComparing(c2));
if (comparing.isPresent()) {
stream = stream.sorted(comparing.get());
}
return stream.skip(query.getOffset()).limit(query.getLimit());
}
private Stream<IN> sort(Collection<IN> elements) {
Stream<IN> stream = elements.stream();
return (comparator == null) ? stream : stream.sorted(comparator);
}
@Override
public Stream<T> apply(Stream<T> input) {
return comparator != null ? input.sorted(comparator) : input.sorted();
}
private Stream<IteratorHistoricalEvent> applyToResults(
Stream<IteratorHistoricalEvent> events,
IteratorHistoricalEventsFetchHints fetchHints,
HistoricalEventId after
) {
switch (fetchHints.getSortDirection()) {
case ASCENDING:
events = events.sorted();
break;
case DESCENDING:
events = events.sorted((o1, o2) -> -o1.compareTo(o2));
break;
default:
throw new VertexiumAccumuloIteratorException("Unhandled sort direction: " + fetchHints.getSortDirection());
}
if (fetchHints.getStartTime() != null || fetchHints.getEndTime() != null) {
long startTimeMillis = fetchHints.getStartTime() == null ? 0 : fetchHints.getStartTime();
long endTimeMillis = fetchHints.getEndTime() == null ? Long.MAX_VALUE : fetchHints.getEndTime();
events = events.filter(event -> {
long ts = event.getTimestamp();
if (ts < startTimeMillis) {
return false;
}
if (ts > endTimeMillis) {
return false;
}
return true;
});
}
if (after != null) {
events = events.filter(event -> {
int i = event.getHistoricalEventId().compareTo(after);
switch (fetchHints.getSortDirection()) {
case ASCENDING:
return i > 0;
case DESCENDING:
return i < 0;
default:
throw new VertexiumAccumuloIteratorException("Unhandled sort direction: " + fetchHints.getSortDirection());
}
});
}
if (fetchHints.getLimit() != null) {
events = events.limit(fetchHints.getLimit());
}
return events;
}
public Stream<HistoricalEvent> applyToResults(Stream<HistoricalEvent> events, HistoricalEventId after) {
switch (getSortDirection()) {
case ASCENDING:
events = events.sorted();
break;
case DESCENDING:
events = events.sorted((o1, o2) -> -o1.compareTo(o2));
break;
default:
throw new VertexiumException("Unhandled sort direction: " + getSortDirection());
}
if (startTime != null || endTime != null) {
long startTimeMillis = startTime == null ? 0 : startTime.toInstant().toEpochMilli();
long endTimeMillis = endTime == null ? Long.MAX_VALUE : endTime.toInstant().toEpochMilli();
events = events.filter(event -> {
long ts = event.getTimestamp().toInstant().toEpochMilli();
if (ts < startTimeMillis) {
return false;
}
if (ts > endTimeMillis) {
return false;
}
return true;
});
}
if (after != null) {
events = events.filter(event -> {
int i = event.getHistoricalEventId().compareTo(after);
switch (getSortDirection()) {
case ASCENDING:
return i > 0;
case DESCENDING:
return i < 0;
default:
throw new VertexiumException("Unhandled sort direction: " + getSortDirection());
}
});
}
if (limit != null) {
events = events.limit(limit);
}
return events;
}
/**
* Return the list of DataSetMetadata corresponding to the search
*
* @param sort sort filter
* @param order order filter
* @param name name filter
* @param nameStrict is it a strict search
* @param certified certified filter
* @param favorite favorite filter
* @param limit limit number of result
* @param favoritesIds list of favorties ids of the user
* @return the list of DataSetMetadata corresponding to the search
*/
private Stream<DataSetMetadata> findDataset(Sort sort, Order order, String name, boolean nameStrict,
boolean certified, boolean favorite, boolean limit, Set<String> favoritesIds) {
// Build filter for data sets
final List<String> predicates = new ArrayList<>();
predicates.add("lifecycle.importing = false");
if (favorite) {
if (favoritesIds != null && !favoritesIds.isEmpty()) {
predicates.add("id in ["
+ favoritesIds.stream().map(ds -> '\'' + ds + '\'').collect(Collectors.joining(",")) + "]");
} else {
// Wants favorites but user has no favorite
return Stream.empty();
}
}
if (certified) {
predicates.add("governance.certificationStep = '" + Certification.CERTIFIED + "'");
}
if (StringUtils.isNotEmpty(name)) {
final String regex = "(?i)" + Pattern.quote(name);
final String filter;
if (nameStrict) {
filter = "name ~ '^" + regex + "$'";
} else {
filter = "name ~ '.*" + regex + ".*'";
}
predicates.add(filter);
}
final String tqlFilter = String.join(" and ", predicates);
LOG.debug("TQL Filter in use: {}", tqlFilter);
// Get all data sets according to filter
Stream<DataSetMetadata> datasetList = dataSetMetadataRepository.list(tqlFilter, sort, order);
if (sort == Sort.AUTHOR || sort == Sort.NAME) { // As theses are not well handled by mongo repository
datasetList = datasetList.sorted(getDataSetMetadataComparator(sort, order));
}
return datasetList.limit(limit ? datasetListLimit : Long.MAX_VALUE);
}
/**
* Performs pagination on the {@code list}, returning from the specified {@code offset} to the specified
* {@code limit}. The list can also be sorted by the {@code sortBy} (optional).
*
* @param list the list to paginate
* @param offset the offset from where to start
* @param limit the max number of elements that the paginated list should include
* @param sortBy the property used for sorting
*
* @return the paginated list
*/
public static <T> List<T> paginate(List<T> list, int offset, int limit, String sortBy) {
Stream<T> stream = list.stream();
if (StringUtils.isNotEmpty(sortBy)) {
stream = stream.sorted(new BeanComparator<>(sortBy));
}
return stream.skip(offset).limit(limit).collect(Collectors.toList());
}