List<Integer> list = Arrays.asList(1, 10, 3, 7, 5); int a = list.stream() .peek(num -> System.out.println("will filter " + num)) .filter(x -> x > 5) .findFirst() .get(); System.out.println(a);
private void updateFilters() { if (this.filters.isEmpty()) { return; } List<WebFilter> filtersToUse = this.filters.stream() .peek(filter -> { if (filter instanceof ForwardedHeaderTransformer && this.forwardedHeaderTransformer == null) { this.forwardedHeaderTransformer = (ForwardedHeaderTransformer) filter; } }) .filter(filter -> !(filter instanceof ForwardedHeaderTransformer)) .collect(Collectors.toList()); this.filters.clear(); this.filters.addAll(filtersToUse); }
private static Function<Page, Page> enforceLayoutProcessor(List<Symbol> expectedLayout, Map<Symbol, Integer> inputLayout) { int[] channels = expectedLayout.stream() .peek(symbol -> checkArgument(inputLayout.containsKey(symbol), "channel not found for symbol: %s", symbol)) .mapToInt(inputLayout::get) .toArray(); if (Arrays.equals(channels, range(0, inputLayout.size()).toArray())) { // this is an identity mapping return Function.identity(); } return new PageChannelSelector(channels); }
private static Map<String, ClientRegistration> createClientRegistrationIdToClientRegistration(Collection<ClientRegistration> registrations) { Assert.notNull(registrations, "registrations cannot be null"); return Collections.unmodifiableMap(registrations.stream() .peek(registration -> Assert.notNull(registration, "registrations cannot contain null values")) .collect(Collectors.toMap(ClientRegistration::getRegistrationId, Function.identity()))); }
@VisibleForTesting static Estimate calculateDistinctValuesCount(List<HiveColumnStatistics> columnStatistics) { return columnStatistics.stream() .map(MetastoreHiveStatisticsProvider::getDistinctValuesCount) .filter(OptionalLong::isPresent) .map(OptionalLong::getAsLong) .peek(distinctValuesCount -> verify(distinctValuesCount >= 0, "distinctValuesCount must be greater than or equal to zero")) .max(Long::compare) .map(Estimate::of) .orElse(Estimate.unknown()); }
private static void testPeek() { System.out.println(); System.out.println("Test peek start"); Collection<String> collection = Arrays.asList("a1", "a2", "a3", "a1"); // Print debug information for every element System.out.print("peak1 = "); List<String> peek = collection.stream().map(String::toUpperCase).peek((e) -> System.out.print(e + ",")). collect(Collectors.toList()); System.out.println(); // print peak1 = A1,A2,A3,A1, System.out.println("peek2 = " + peek); // print peek2 = [A1, A2, A3, A1] Collection<StringBuilder> list = Arrays.asList(new StringBuilder("a1"), new StringBuilder("a2"), new StringBuilder("a3")); List<StringBuilder> newList = list.stream().peek((p) -> p.append("_new")).collect(Collectors.toList()); System.out.println("newList = " + newList); // print newList = [a1_new, a2_new, a3_new] }
@Override public Strategy createStrategyIfMatch(Class target, Method method) { if (switcher.isEmpty()) { return null; } String text = target.getName().concat(".").concat(method.getName()); return switcher.entrySet().stream() .filter(entry -> antPathMatcher.match(entry.getValue().getExpression(), text)) .peek(entry -> entry.getValue().setId(entry.getKey())) .map(Map.Entry::getValue) .findFirst() .orElse(null); }
@Override @CacheEvict(allEntries = true) public List<String> saveOrUpdateColumn(List<DynamicFormColumnEntity> columnEntities) { Set<String> formId = new HashSet<>(); List<String> columnIds = columnEntities.stream() .peek(columnEntity -> formId.add(columnEntity.getFormId())) .map(this::saveOrUpdateColumn) .collect(Collectors.toList()); formId.forEach(getDao()::incrementVersion); return columnIds; }
public List<DefaultIssue> loadChanges(DbSession dbSession, Collection<DefaultIssue> issues) { Map<String, List<IssueChangeDto>> changeDtoByIssueKey = dbClient.issueChangeDao() .selectByIssueKeys(dbSession, issues.stream().map(DefaultIssue::key).collect(toList())) .stream() .collect(groupingBy(IssueChangeDto::getIssueKey)); return issues .stream() .peek(i -> setChanges(changeDtoByIssueKey, i)) .collect(toList()); }
private static Optional<QueryBuilder> createQuery(ComponentTextSearchQuery query, ComponentTextSearchFeature[] features, UseCase useCase) { BoolQueryBuilder generateResults = boolQuery(); AtomicBoolean anyFeatures = new AtomicBoolean(); Arrays.stream(features) .filter(f -> f.getUseCase() == useCase) .peek(f -> anyFeatures.set(true)) .flatMap(f -> f.getQueries(query)) .forEach(generateResults::should); if (anyFeatures.get()) { return Optional.of(generateResults); } return Optional.empty(); }
public ComposableStatsCalculator(List<Rule<?>> rules) { this.rulesByRootType = rules.stream() .peek(rule -> { checkArgument(rule.getPattern() instanceof TypeOfPattern, "Rule pattern must be TypeOfPattern"); Class<?> expectedClass = ((TypeOfPattern<?>) rule.getPattern()).expectedClass(); checkArgument(!expectedClass.isInterface() && !Modifier.isAbstract(expectedClass.getModifiers()), "Rule must be registered on a concrete class"); }) .collect(toMultimap( rule -> ((TypeOfPattern<?>) rule.getPattern()).expectedClass(), rule -> rule, ArrayListMultimap::create)); }
private Function<ChangeLogResults, ChangelogWsResponse> buildResponse() { return result -> Stream.of(ChangelogWsResponse.newBuilder()) .peek(addChanges(result)) .map(ChangelogWsResponse.Builder::build) .collect(MoreCollectors.toOneElement()); }
@Override public void init(InjectionManager injectionManager, BootstrapBag bootstrapBag) { ServerBootstrapBag serverBag = (ServerBootstrapBag) bootstrapBag; // There are situation in which ComponentProviders are not needed therefore their entire initialization is wrapped // into a lazy block. LazyValue<Collection<ComponentProvider>> componentProviders = Values.lazy((Value<Collection<ComponentProvider>>) () -> getRankedComponentProviders().stream() .map(RankedProvider::getProvider) .peek(provider -> provider.initialize(injectionManager)) .collect(Collectors.toList())); serverBag.setComponentProviders(componentProviders); }
@Override public void init(InjectionManager injectionManager, BootstrapBag bootstrapBag) { ServerBootstrapBag serverBag = (ServerBootstrapBag) bootstrapBag; // There are situation in which ComponentProviders are not needed therefore their entire initialization is wrapped // into a lazy block. LazyValue<Collection<ComponentProvider>> componentProviders = Values.lazy((Value<Collection<ComponentProvider>>) () -> getRankedComponentProviders().stream() .map(RankedProvider::getProvider) .peek(provider -> provider.initialize(injectionManager)) .collect(Collectors.toList())); serverBag.setComponentProviders(componentProviders); }
@Override public void handle(Request request, Response response) throws Exception { String eventP = request.mandatoryParam(PARAM_EVENT); try (DbSession dbSession = dbClient.openSession(false)) { Stream.of(getEvent(dbSession, eventP)) .peek(checkPermissions()) .peek(checkModifiable()) .forEach(event -> deleteEvent(dbSession, event)); } response.noContent(); }
@Override public void init(InjectionManager injectionManager, BootstrapBag bootstrapBag) { Configuration configuration = bootstrapBag.getConfiguration(); List<AutoDiscoverable> autoDiscoverables = loadImplementations(configuration.getProperties()).stream() .peek(implClass -> injectionManager.register(Bindings.service(implClass).to(AutoDiscoverable.class))) .map(injectionManager::createAndInitialize) .collect(Collectors.toList()); bootstrapBag.setAutoDiscoverables(autoDiscoverables); } }
@Override public void init(InjectionManager injectionManager, BootstrapBag bootstrapBag) { Configuration configuration = bootstrapBag.getConfiguration(); List<AutoDiscoverable> autoDiscoverables = loadImplementations(configuration.getProperties()).stream() .peek(implClass -> injectionManager.register(Bindings.service(implClass).to(AutoDiscoverable.class))) .map(injectionManager::createAndInitialize) .collect(Collectors.toList()); bootstrapBag.setAutoDiscoverables(autoDiscoverables); } }
@Override public void handle(Request request, Response response) { userSession.checkLoggedIn(); try (DbSession dbSession = dbClient.openSession(false)) { IssueDto issueDto = Stream.of(request) .map(toWsRequest()) .map(loadCommentData(dbSession)) .peek(updateComment(dbSession)) .collect(MoreCollectors.toOneElement()) .getIssueDto(); responseWriter.write(issueDto.getKey(), new SearchResponseData(issueDto), request, response); } }
@Override public void handle(Request request, Response response) { userSession.checkLoggedIn(); try (DbSession dbSession = dbClient.openSession(false)) { IssueDto issueDto = Stream.of(request) .map(loadCommentData(dbSession)) .peek(deleteComment(dbSession)) .collect(MoreCollectors.toOneElement()) .getIssueDto(); responseWriter.write(issueDto.getKey(), new SearchResponseData(issueDto), request, response); } }
protected void assertResultOrder(String query, String... resultsInOrder) { ComponentDto project = indexProject("key-1", "Quality Product"); List<ComponentDto> files = Arrays.stream(resultsInOrder) .map(r -> ComponentTesting.newFileDto(project).setName(r)) .peek(f -> f.setUuid(f.uuid() + "_" + f.name().replaceAll("[^a-zA-Z0-9]", ""))) .collect(Collectors.toList()); // index them, but not in the expected order files.stream() .sorted(Comparator.comparing(ComponentDto::uuid).reversed()) .forEach(this::index); assertExactResults(query, files.toArray(new ComponentDto[0])); }