Java Code Examples for java.util.stream.Stream#distinct()

private void transform(final String normalisedName, String[] values, final ValueArrayConsumer consumer) throws
		IOException {
	Stream<String> stream = Arrays.stream(values);

	// Remove empty values.
	stream = stream.filter(value -> null != value && !value.isEmpty());

	// Remove duplicates.
	// Normalised to lowercase so that "GENERATOR" matches "Generator" (these inconsistent names can come from
	// HTML documents).
	if (values.length > 1 && deduplicateProperties.contains(fieldMap.get(normalisedName)
			.toLowerCase(Locale.ENGLISH))) {
		stream = stream.distinct();
	}

	values = stream.toArray(String[]::new);
	if (values.length > 0) {
		consumer.accept(normalisedName, values);
	}
}
 

@Override
public Stream<String> list() throws IOException {
    Stream<String> s = delegate().list();
    for (ResourceFinder finder : finders) {
        s = Stream.concat(s, finder.list());
    }
    return s.distinct();
}
 

@Override
public Stream<String> list() throws IOException {
    Stream<String> s = delegate().list();
    for (ResourceFinder finder : finders) {
        s = Stream.concat(s, finder.list());
    }
    return s.distinct();
}
 

/**
 * Creates map entries with the given keys. Uses values
 * from {@linkplain TestStorageItems#values} in a round-robin fashion.
 */
List<MapEntry<HashCode, String>> createMapEntries(Stream<HashCode> proofKeys) {
  Stream<HashCode> keys = proofKeys.distinct();
  Stream<String> roundRobinValues = IntStream.range(0, Integer.MAX_VALUE)
      .mapToObj(i -> values.get(i % values.size()));
  return Streams.zip(keys, roundRobinValues, MapEntry::valueOf)
      .collect(toList());
}
 

private Stream<BindingSet> sort(Collection<BindingSet> collection) {
	BindingSet[] array = collection.toArray(new BindingSet[collection.size()]);
	Arrays.parallelSort(array, comparator);
	Stream<BindingSet> stream = Stream.of(array);
	if (distinct) {
		stream = stream.distinct();
	}
	if (limit < Integer.MAX_VALUE) {
		stream = stream.limit(limit);
	}
	return stream;
}
 

private static Stream<String> modifyStream(String arg, Stream<String> input) {
	switch (arg){
		case "--sort": return input.sorted();
		case "--unique": return input.distinct();
		case "--reverse": return reverse(input);
		default: {
			System.out.println("Unknown argument '" + arg + "'.");
			return input;
		}
	}
}
 

@Override
public VertexiumCypherResult execute(VertexiumCypherQueryContext ctx, VertexiumCypherResult source) {
    LinkedHashSet<String> columnNames = new LinkedHashSet<>();
    Stream<CypherResultRow> rows = Stream.of();
    for (ExecutionStep step : getChildSteps().collect(Collectors.toList())) {
        VertexiumCypherResult result = step.execute(ctx, null);
        columnNames.addAll(result.getColumnNames());
        rows = Stream.concat(rows, result);
    }
    if (!all) {
        rows = rows.distinct();
    }
    return new VertexiumCypherResult(rows, columnNames);
}
 

@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
public Stream<T> apply(Stream<T> input) {
    return input.distinct();
}
 

public static <T> Stream<T> distinct( Stream<T> stream ) {
    return stream.distinct();
}