/** * 返回一个倒转顺序访问的List,仅仅是一个倒序的View,不会实际多生成一个List * * @see com.google.common.collect.Lists#reverse(List) */ public static <T> List<T> reverse(final List<T> list) { return Lists.reverse(list); }
/** * 返回一个倒转顺序访问的List,仅仅是一个倒序的View,不会实际多生成一个List * * @see com.google.common.collect.Lists#reverse(List) */ public static <T> List<T> reverse(final List<T> list) { return Lists.reverse(list); } ///////////////// from guava的函数 ///////////////////
public List<Comment> comments() { // javac stores the comments in reverse declaration order because appending to linked // lists is expensive return token.comments == null ? Collections.<Comment>emptyList() : Lists.reverse(token.comments); }
/** * Merge configurations of releases. * Release in lower index override those in higher index */ Map<String, String> mergeReleaseConfigurations(List<Release> releases) { Map<String, String> result = Maps.newHashMap(); for (Release release : Lists.reverse(releases)) { result.putAll(gson.fromJson(release.getConfigurations(), configurationTypeReference)); } return result; }
@Override protected List<String> create(String[] elements) { String[] reverseElements = new String[elements.length]; for (int i = elements.length - 1, j = 0; i >= 0; i--, j++) { reverseElements[j] = elements[i]; } return Lists.reverse(asList(reverseElements)); } })
@Override protected List<String> create(String[] elements) { List<String> list = Lists.newArrayList(); for (int i = elements.length - 1; i >= 0; i--) { list.add(elements[i]); } return Lists.reverse(list); } })
@Override protected List<String> create(String[] elements) { List<String> list = Lists.newLinkedList(); for (int i = elements.length - 1; i >= 0; i--) { list.add(elements[i]); } return Lists.reverse(list); } })
@Override protected List<String> create(String[] elements) { ImmutableList.Builder<String> builder = ImmutableList.builder(); for (int i = elements.length - 1; i >= 0; i--) { builder.add(elements[i]); } return Lists.reverse(builder.build()); } })
private static <T> List<T> reverse(List<T> iterable) { return Lists.reverse(ImmutableList.copyOf(iterable)); }
public static <T> Iterable<T> revert(Iterable<T> input) { return Lists.reverse(Lists.newArrayList(input)); }
public ImageLayers<T> build() { if (!removeDuplicates) { return new ImageLayers<>(ImmutableList.copyOf(layers), layerDigestsBuilder.build()); } // LinkedHashSet maintains the order but keeps the first occurrence. Keep last occurrence by // adding elements in reverse, and then reversing the result Set<T> dedupedButReversed = new LinkedHashSet<T>(Lists.reverse(this.layers)); ImmutableList<T> deduped = ImmutableList.copyOf(dedupedButReversed).reverse(); return new ImageLayers<>(deduped, layerDigestsBuilder.build()); } }
@Override public List<T> subList(int fromIndex, int toIndex) { checkPositionIndexes(fromIndex, toIndex, size()); return reverse(forwardList.subList(reversePosition(toIndex), reversePosition(fromIndex))); }
@Override public List<T> subList(int fromIndex, int toIndex) { checkPositionIndexes(fromIndex, toIndex, size()); return reverse(forwardList.subList(reversePosition(toIndex), reversePosition(fromIndex))); }
public void testReverseViewSequential() { List<Integer> fromList = Lists.newLinkedList(SOME_SEQUENTIAL_LIST); List<Integer> toList = Lists.reverse(fromList); assertReverseView(fromList, toList); }
public void testReverseViewRandomAccess() { List<Integer> fromList = Lists.newArrayList(SOME_LIST); List<Integer> toList = Lists.reverse(fromList); assertReverseView(fromList, toList); }
public static QualifiedObjectName createQualifiedObjectName(Session session, Node node, QualifiedName name) { requireNonNull(session, "session is null"); requireNonNull(name, "name is null"); if (name.getParts().size() > 3) { throw new PrestoException(SYNTAX_ERROR, format("Too many dots in table name: %s", name)); } List<String> parts = Lists.reverse(name.getParts()); String objectName = parts.get(0); String schemaName = (parts.size() > 1) ? parts.get(1) : session.getSchema().orElseThrow(() -> new SemanticException(SCHEMA_NOT_SPECIFIED, node, "Schema must be specified when session schema is not set")); String catalogName = (parts.size() > 2) ? parts.get(2) : session.getCatalog().orElseThrow(() -> new SemanticException(CATALOG_NOT_SPECIFIED, node, "Catalog must be specified when session catalog is not set")); return new QualifiedObjectName(catalogName, schemaName, objectName); }
private void testCustomAggregation(Long[] values, int n) { PriorityQueue<Long> heap = new PriorityQueue<>(n); Arrays.stream(values).filter(x -> x != null).forEach(heap::add); ImmutableList.Builder<List<Long>> expected = new ImmutableList.Builder<>(); for (int i = heap.size() - 1; i >= 0; i--) { expected.add(ImmutableList.of(heap.remove())); } testAggregation(Lists.reverse(expected.build()), createLongArraysBlock(values), createLongRepeatBlock(n, values.length)); } }
@Override public Node visitPosition(SqlBaseParser.PositionContext context) { List<Expression> arguments = Lists.reverse(visit(context.valueExpression(), Expression.class)); return new FunctionCall(getLocation(context), QualifiedName.of("strpos"), arguments); }
@Override public Sequence<Result<TimeseriesResultValue>> run( QueryPlus<Result<TimeseriesResultValue>> queryPlus, Map<String, Object> responseContext ) { if (queryPlus.getQuery().getDataSource().equals(new TableDataSource("ds1"))) { return Sequences.simple(descending ? Lists.reverse(ds1) : ds1); } else { return Sequences.simple(descending ? Lists.reverse(ds2) : ds2); } } }
@Test(dataProvider = "rowCount") public void testOrcUseColumnNames(int rowCount) throws Exception { TestingConnectorSession session = new TestingConnectorSession(new HiveSessionProperties(new HiveClientConfig(), new OrcFileWriterConfig(), new ParquetFileWriterConfig()).getSessionProperties()); assertThatFileFormat(ORC) .withWriteColumns(TEST_COLUMNS) .withRowsCount(rowCount) .withReadColumns(Lists.reverse(TEST_COLUMNS)) .withSession(session) .isReadableByPageSource(new OrcPageSourceFactory(TYPE_MANAGER, true, HDFS_ENVIRONMENT, STATS)); }