How to use

distinct

method

in

java.util.stream.Stream

public List<Symbol> getOriginalNonDistinctAggregateArgs()
{
  return aggregations.values().stream()
      .filter(aggregation -> !aggregation.getMask().isPresent())
      .map(Aggregation::getCall)
      .flatMap(function -> function.getArguments().stream())
      .distinct()
      .map(Symbol::from)
      .collect(Collectors.toList());
}

private static Stream<Set<Expression>> extractArgumentSets(AggregationNode aggregation)
{
  return aggregation.getAggregations()
      .values().stream()
      .map(Aggregation::getCall)
      .filter(FunctionCall::isDistinct)
      .map(FunctionCall::getArguments)
      .<Set<Expression>>map(HashSet::new)
      .distinct();
}

private static void testDistinct() {
  System.out.println();
  System.out.println("Test distinct start");
  Collection<String> ordered = Arrays.asList("a1", "a2", "a2", "a3", "a1", "a2", "a2");
  Collection<String> nonOrdered = new HashSet<>(ordered);
  // Get collection without duplicate
  List<String> distinct = nonOrdered.stream().distinct().collect(Collectors.toList());
  System.out.println("distinct = " + distinct); // print  distinct = [a1, a2, a3] - порядок не гарантируется
  List<String> distinctOrdered = ordered.stream().distinct().collect(Collectors.toList());
  System.out.println("distinctOrdered = " + distinctOrdered); // print  distinct = [a1, a2, a3] - порядок гарантируется
}

  private <T> Stream<? extends T> streamResources(
    Function<? super Resource, ? extends T> mapper) {
    return getResourceCollections().stream()
      .flatMap(ResourceCollection::stream).map(mapper).distinct();
  }
}

private void distinct() {
  Set<String> ratings = films.stream()
      .map(Film.RATING)
      .distinct()
      .collect(Collectors.toSet());
  System.out.println(ratings);
}

 public String getUniqueExceptionsString() {
  return exceptionTypes != null ? exceptionTypes.stream().distinct().collect(Collectors.joining(":")) : null;
 }
}

@Override
public int[] fetchSegments(String processorName) {
  return tokens.keySet().stream()
         .filter(ps -> ps.processorName.equals(processorName))
         .map(ProcessAndSegment::getSegment)
         .distinct().mapToInt(Number::intValue).toArray();
}

private Optional<Predicate<Throwable>> buildRecordExceptionsPredicate() {
  return Arrays.stream(recordExceptions)
      .distinct()
      .map(Builder::makePredicate)
      .reduce(Predicate::or);
}

@Override
public GameObject[] result(Client client)
{
  return getGameObjects(client).stream()
    .filter(Objects::nonNull)
    .filter(predicate)
    .distinct()
    .toArray(GameObject[]::new);
}

private static Map<Expression, Symbol> symbolsForExpressions(PlanBuilder builder, Iterable<? extends Expression> expressions)
{
  return stream(expressions)
      .distinct()
      .collect(toImmutableMap(expression -> expression, builder::translate));
}

public List<Symbol> getOriginalDistinctAggregateArgs()
{
  return aggregations.values().stream()
      .filter(aggregation -> aggregation.getMask().isPresent())
      .map(Aggregation::getCall)
      .flatMap(function -> function.getArguments().stream())
      .distinct()
      .map(Symbol::from)
      .collect(Collectors.toList());
}

@Test
public void testNonDeterministic()
{
  MaterializedResult materializedResult = computeActual("SELECT rand() FROM orders LIMIT 10");
  long distinctCount = materializedResult.getMaterializedRows().stream()
      .map(row -> row.getField(0))
      .distinct()
      .count();
  assertTrue(distinctCount >= 8, "rand() must produce different rows");
  materializedResult = computeActual("SELECT apply(1, x -> x + rand()) FROM orders LIMIT 10");
  distinctCount = materializedResult.getMaterializedRows().stream()
      .map(row -> row.getField(0))
      .distinct()
      .count();
  assertTrue(distinctCount >= 8, "rand() must produce different rows");
}

@Override
public List<String> listSchemaNames(ConnectorSession session)
{
  return tables.listSystemTables(session).stream()
      .map(table -> table.getTableMetadata().getTable().getSchemaName())
      .distinct()
      .collect(toImmutableList());
}

  default StringColumn tokenizeAndRemoveDuplicates(String separator) {
    StringColumn newColumn = StringColumn.create(name() + "[without duplicates]", this.size());

    for (int r = 0; r < size(); r++) {
      String value = getString(r);

      Splitter splitter = Splitter.on(separator);
      splitter = splitter.trimResults();
      splitter = splitter.omitEmptyStrings();
      List<String> tokens = new ArrayList<>(splitter.splitToList(value));

      String result = tokens.stream().distinct().collect(Collectors.joining(separator));
      newColumn.set(r, result);
    }
    return newColumn;
  }
}

private static boolean hasMultipleDistincts(AggregationNode aggregation)
{
  return aggregation.getAggregations()
      .values().stream()
      .filter(e -> e.getCall().isDistinct())
      .map(Aggregation::getCall)
      .map(FunctionCall::getArguments)
      .map(HashSet::new)
      .distinct()
      .count() > 1;
}

/**
 * Return all dependencies as a flat collection.
 * @return all dependencies
 */
public Collection<Dependency> getAll() {
  return Collections.unmodifiableCollection(this.indexedDependencies.values()
      .stream().distinct().collect(Collectors.toList()));
}

private Optional<Predicate<Throwable>> buildRetryExceptionsPredicate() {
  return Arrays.stream(retryExceptions)
      .distinct()
      .map(Builder::makePredicate)
      .reduce(Predicate::or);
}

@Override
public GroundObject[] result(Client client)
{
  return getGroundObjects(client).stream()
    .filter(Objects::nonNull)
    .filter(predicate)
    .distinct()
    .toArray(GroundObject[]::new);
}

/**
 * Set the allowed HTTP methods.
 *
 * @param methods The methods to specify in the Allowed HTTP header
 * @return This HTTP headers
 */
default MutableHttpHeaders allow(Collection<HttpMethod> methods) {
  String value = methods.stream().distinct().collect(Collectors.joining(","));
  return add(ALLOW, value);
}

@Override
public List<String> getDataSourceNames()
{
 return rels.stream()
       .flatMap(rel -> ((DruidRel<?>) rel).getDataSourceNames().stream())
       .distinct()
       .collect(Collectors.toList());
}