Java Code Examples for java.util.stream.Collectors

@GetMapping(params = "id")
private String getStudyplanDetailsView(@RequestParam(value = "id") Long id, Model model) {
    StudyPlan studyPlan = studyPlanService.findOne(id);

    List<SubjectForStudyPlan> subjectsForStudyPlan = studyPlanService.getSubjectsForStudyPlan(id);
    List<SubjectForStudyPlan> mandatory = subjectsForStudyPlan
            .stream()
            .filter(SubjectForStudyPlan::getMandatory)
            .collect(Collectors.toList());
    List<SubjectForStudyPlan> optional = subjectsForStudyPlan
            .stream()
            .filter(s -> !s.getMandatory())
            .collect(Collectors.toList());

    model.addAttribute("studyPlan", studyPlan);
    model.addAttribute("mandatory", mandatory);
    model.addAttribute("optional", optional);

    return "student/all-studyplan-details";
}
 

public Map<String, ObjectNode> hostsRuntime ( List<String> hosts ) {

		return hosts.stream()
			.map( host -> {
				ObjectNode hostRuntime = hostResponseMap.get( host );
				if ( hostRuntime == null ) {
					hostRuntime = jsonMapper.createObjectNode();
					hostRuntime.put( "error", "No response found" );
				}
				hostRuntime.put( "collectedHost", host );
				return hostRuntime;
			} )
			.collect( Collectors.toMap(
				hostStatus -> hostStatus.get( "collectedHost" ).asText(),
				hostStatus -> hostStatus ) );
	}
 

/**
 * Generates source which represents the class.
 *
 * @return source which represents the class
 */
@Override
public String generateSource() {
    String sourceForAnnotations = generateSourceForAnnotations();
    String classModifiers = mods.stream().collect(Collectors.joining(" "));
    return sourceForAnnotations
            + String.format("%s%s %s %s %s {%n",
            indention(),
            classModifiers,
            classType.getDescription(),
            name,
            parent == null ? "" : "extends " + parent)
            + classType.collectFields(fields.values())
            + classType.collectMethods(methods.values())
            + classType.collectInnerClasses(innerClasses.values())
            + indention() + "}";
}
 

private void fixUnitChanges() {
    // Unlike roles, we can not trust what is already there, as the changes
    // are deeper.

    if (compareVersion("0.116") > 0) return;

    unitChangeTypeList.clear();
    File uctf = FreeColDirectories.getCompatibilityFile(UNIT_CHANGE_TYPES_COMPAT_FILE_NAME);
    try (
         FileInputStream fis = new FileInputStream(uctf);
         ) {
        load(fis);
    } catch (Exception e) {
        logger.log(Level.WARNING, "Failed to load unit changes.", e);
        return;
    }

    logger.info("Loading unit-changes backward compatibility fragment: "
        + UNIT_CHANGE_TYPES_COMPAT_FILE_NAME + " with changes: "
        + transform(getUnitChangeTypeList(), alwaysTrue(),
            UnitChangeType::getId, Collectors.joining(" ")));
}
 

private void test(List<Integer> values, List<Double> probabilities) {
    final Map<Integer, AtomicInteger> results = new ConcurrentHashMap<>(
            values.stream()
                    .map(integer -> new AbstractMap.SimpleImmutableEntry<>(integer, new AtomicInteger(0)))
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))
    );

    IntStream.range(0, N)
            .parallel()
            .forEach(i -> {
                results.get(GenerateNonuniformRandomNumbers.getRandom(values,probabilities)).incrementAndGet();
            });

    IntStream.range(0, values.size())
            .parallel()
            .forEach(i -> {
                double expectedValue = N * probabilities.get(i);
                assertThat(results.get(values.get(i)), allOf(greaterThan(expectedValue - 50), lessThan(expectedValue + 50)));
            });
}
 

public static String getTable(Character[] borderChars, Column[] rawColumns, String[][] data) {
    if (borderChars.length != NO_BORDERS.length) {
        throw new IllegalArgumentException("Border characters array must be exactly " + NO_BORDERS.length + " elements long");
    }

    final int numColumns = getNumColumns(rawColumns, data);
    final Column[] columns = IntStream.range(0, numColumns)
            .mapToObj(index -> index < rawColumns.length ? rawColumns[index] : new Column())
            .toArray(Column[]::new);
    final int[] colWidths = getColWidths(columns, data);

    final HorizontalAlign[] headerAligns = Arrays.stream(columns).map(Column::getHeaderAlign).toArray(HorizontalAlign[]::new);
    final HorizontalAlign[] dataAligns = Arrays.stream(columns).map(Column::getDataAlign).toArray(HorizontalAlign[]::new);
    final HorizontalAlign[] footerAligns = Arrays.stream(columns).map(Column::getFooterAlign).toArray(HorizontalAlign[]::new);

    final String[] header = Arrays.stream(columns).map(Column::getHeader).toArray(String[]::new);
    final String[] footer = Arrays.stream(columns).map(Column::getFooter).toArray(String[]::new);

    List<String> tableRows = getTableRows(colWidths, headerAligns, dataAligns, footerAligns, borderChars, header, data, footer);

    return tableRows.stream()
            .filter(line -> !line.isEmpty())
            .collect(Collectors.joining(System.lineSeparator()));
}
 

public static void main(String[] args) throws Exception {
    if (args.length == 0) {
        test("p1", "read", "write", "delete", "execute");
        test("p2", "read,write", "delete,execute");
        test("p3", "read,write,delete", "execute");
        test("p4", "read,write,delete,execute");
    } else {
        SecurityManager sm = System.getSecurityManager();
        for (String arg : args) {
            // Use bits to create powerset of ALL_ACTIONS
            IntStream.range(1, 16)
                    .mapToObj(n -> IntStream.range(0, 4)
                            .filter(x -> (n & (1 << x)) != 0)
                            .mapToObj(x -> ALL_ACTIONS[x])
                            .collect(Collectors.joining(",")))
                    .forEach(a -> sm.checkPermission(
                            new FilePermission(arg, a)));
        }
    }
}
 

@SuppressWarnings({ "unchecked", "rawtypes" })
@Test
public void testConst_enum() {
	sqlContextFactory.setEnumConstantPackageNames(Arrays.asList(TestEnum1.class.getPackage().getName()));

	sqlContextFactory.initialize();

	Map<String, Parameter> constParameterMap = sqlContextFactory.getConstParameterMap();
	Set<String> set = constParameterMap.entrySet().stream().map(e -> e.getKey() + "=" + e.getValue().getValue())
			.collect(Collectors.toSet());

	assertThat(
			set,
			is(new HashSet<>(Arrays.asList("CLS_TEST_ENUM1_A=A", "CLS_TEST_ENUM1_B=B", "CLS_TEST_ENUM1_C=C",
					"CLS_PACKTEST_TEST_ENUM2_D=D", "CLS_PACKTEST_TEST_ENUM2_E=E", "CLS_PACKTEST_TEST_ENUM2_F=F",
					"CLS_PACKTEST_TEST_ENUM2_INNER_G=G", "CLS_PACKTEST_TEST_ENUM2_INNER_H=H",
					"CLS_PACKTEST_TEST_ENUM2_INNER_I=I"))));

	for (Parameter parameter : constParameterMap.values()) {
		assertThat(parameter.getValue(), isA((Class) Enum.class));
	}
}
 

/**
 * Retrieves all roles of the current user based on direct roles set to the user, its groups and their parent groups.
 * Then it recursively expands all composite roles, and restricts according to the given predicate {@code restriction}.
 * If the current client sessions is restricted (i.e. no client found in active user session has full scope allowed),
 * the final list of roles is also restricted by the client scope. Finally, the list is mapped to the token into
 * a claim.
 */
protected void setAttribute(Map<String, Object> attributes, ProtocolMapperModel mappingModel, UserSessionModel userSession,
                                   Predicate<RoleModel> restriction, String prefix) {
    String rolePrefix = prefix == null ? "" : prefix;
    UserModel user = userSession.getUser();

    // get a set of all realm roles assigned to the user or its group
    Stream<RoleModel> clientUserRoles = getAllUserRolesStream(user).filter(restriction);

    boolean dontLimitScope = userSession.getAuthenticatedClientSessions().values().stream().anyMatch(cs -> cs.getClient().isFullScopeAllowed());
    if (! dontLimitScope) {
        Set<RoleModel> clientRoles = userSession.getAuthenticatedClientSessions().values().stream()
          .flatMap(cs -> cs.getClient().getScopeMappings().stream())
          .collect(Collectors.toSet());

        clientUserRoles = clientUserRoles.filter(clientRoles::contains);
    }

    Set<String> realmRoleNames = clientUserRoles
      .map(m -> rolePrefix + m.getName())
      .collect(Collectors.toSet());

    setPlainAttribute(attributes, mappingModel, realmRoleNames);
}
 

@GetMapping("/")
  public String listUploadedFiles(Model model) {

      try {
      	logger.info("Fetching all Files from S3");
	model.addAttribute("files", s3OperationService.getAllFiles()
	        .stream()
	        .collect(Collectors.toMap(f-> f, f -> {
	        	List<String> filesNFolders = new ArrayList<>();
	        	String[] folders = f.split("/");
	        	Arrays.asList(folders).forEach(filesNFolders::add);
	        	return filesNFolders;
	        })));
} catch(IOException e) {
	logger.error("Failed to Connect to AWS S3 - Please check your AWS Keys");
	e.printStackTrace();
}

      return "index";
  }
 

@Test
public void fictitiousSwitchTest() {
    Set<String> switchIds = Sets.newHashSet("BD", "BL");

    Network network = FictitiousSwitchFactory.create();
    List<Boolean> expectedSwitchStates = getSwitchStates(network, switchIds);

    BranchTripping tripping = new BranchTripping("CJ", "C");

    Set<Switch> switchesToOpen = new HashSet<>();
    Set<Terminal> terminalsToDisconnect = new HashSet<>();
    tripping.traverse(network, null, switchesToOpen, terminalsToDisconnect);
    assertEquals(switchIds, switchesToOpen.stream().map(Switch::getId).collect(Collectors.toSet()));
    assertEquals(Collections.emptySet(), terminalsToDisconnect);

    tripping.modify(network, null);
    assertTrue(network.getSwitch("BD").isOpen());
    assertTrue(network.getSwitch("BL").isOpen());

    List<Boolean> switchStates = getSwitchStates(network, switchIds);
    assertEquals(expectedSwitchStates, switchStates);
}
 

private List<Album> parseReleaseStatusFile(List<Album> albums) {
    Map<String, List<Album>> albumMap = albums.stream()
            .filter(album -> !StringUtils.isEmpty(album.getStatus()))
            .collect(Collectors.groupingBy(Album::getStatus));

    //read file into stream, try-with-resources
    try (Stream<String> stream = Files.lines(Paths.get(albumStatusFilePath))) {
        Stream<String[]> rows = stream.map(strRow -> strRow.split(TAB_SYMBOL));
        rows.forEach(row -> {
            List<Album> albumList = albumMap.get(row[0]);
            if (albumList != null) {
                albumList.forEach(album -> album.setStatus(row[1]));
            }
        });
    } catch (IOException e) {
        e.printStackTrace();
    }

    return albums;
}
 

static void write(ClassWriter classWriter, TypeSpec.Builder builder) {
    Map<Element, List<EgItem<?>>> examplesByElement = classWriter.getItems().stream()
            .collect(Collectors.groupingBy(EgItem::getElement));

    for (Map.Entry<Element, List<EgItem<?>>> entry: examplesByElement.entrySet()) {
        Element el = entry.getKey();
        List<EgItem<?>> examples = entry.getValue();

        new PatternMatchWriter(el, filterAndConvert(PatternMatchExample.class, examples), classWriter, builder)
                .addTests();
        new FunctionMatchWriter(el, filterAndConvert(FunctionMatchExample.class, examples), classWriter, builder)
                .addTests();

        if (el instanceof ExecutableElement) {
            ExecutableElement exEl = (ExecutableElement) el;

            List<ReturnsExample> returnsExamples = filterAndConvert(ReturnsExample.class, examples);
            new EgWriter(exEl, returnsExamples, classWriter, builder)
                    .addTests();

            List<ExceptionExample> exceptionExamples = filterAndConvert(ExceptionExample.class, examples);
            new ExceptionWriter(exEl, exceptionExamples, classWriter, builder)
                    .addTests();
        }
    }
}
 

/**
 * @param input
 *            {@link TextInputControl} where set the default value
 */
public void applyDefault(final TextInputControl input)
{
    try
    {
        settingDefaultOn = input;
        final String defaultText = Stream.of(mask) //
                                         .map(m -> Character.toString(m.getDefault()))
                                         .collect(Collectors.joining());
        input.setText(defaultText);

        final int firstAllowedPosition = IntStream.range(0, mask.length)
                                                  .filter(i -> mask[i].isNavigable())
                                                  .findFirst()
                                                  .orElse(0);
        input.selectRange(firstAllowedPosition, firstAllowedPosition);
    }
    finally
    {
        settingDefaultOn = null;
    }
}
 

@Test
public void pomStandard() throws Exception {
    File pom = new File(resources.getBasedir("valid"), "pom.xml");
    assertNotNull(pom);
    assertTrue(pom.exists());

    JavaClassGeneratorMojo mojo = (JavaClassGeneratorMojo) mojoRule.lookupMojo("generate-sources", pom);
    assertNotNull(mojo);

    mojo.sourceDestination = testFolder.getRoot().getPath();
    mojo.execute();

    Path path = Paths.get(mojo.sourceDestination);

    List<Path> files = Files.find(path, 99, (p, bfa) -> bfa.isRegularFile()).collect(Collectors.toList());
    assertEquals("Greeter and Mortal Class", 2l, files.size());
}
 

public static void main(String[] args) throws IOException {
    LinkedHashMap<String, Integer> arrows = new LinkedHashMap<String, Integer>(){{
        put(">>>----->>", 0); put(">>----->", 0); put(">----->", 0);}};

    for (int i = 0; i < 4; i++) {
        String line = reader.readLine();
        // if(line.length() < 7) continue;
        for (Map.Entry<String, Integer> arr :
                arrows.entrySet()) {
            int index = line.indexOf(arr.getKey());
            while(index > -1){
                arrows.put(arr.getKey(), arr.getValue() + 1);
                index = line.indexOf(arr.getKey(), index + arr.getKey().length());
            }
            // replace with neutral symbol, to ensure that after replacement we will not produce new arrow
            // -> nested arrows
            line = line.replaceAll(arr.getKey(), "*");
        }
    }
    long num = Long.parseLong(arrows.entrySet().stream()
        .sorted(Comparator.comparingInt(arr -> (arr.getKey().length())))
        .map(e -> e.getValue().toString()).collect(Collectors.joining("")));
    StringBuilder strNum = new StringBuilder(Long.toString(num, 2));
    strNum.append(new StringBuilder(strNum).reverse());
    System.out.println(Long.parseLong(strNum.toString(), 2));
}
 

@TargetApi(24)
private List<FieldSpec> getIdFieldSpecs(Map<ExecutableElement, String> methodToIdMap) {
    AtomicInteger index = new AtomicInteger(0);
    return methodToIdMap.values()
            .stream()
            .map(value -> FieldSpec
                    .builder(int.class, value)
                    .addModifiers(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL)
                    .initializer("$L", index.getAndIncrement())
                    .build())
            .collect(Collectors.toList());
}
 

/**
 * Create params array for a command
 * @return Params array
 */
public Object[] createCommandParams() {
    String flowExpression = this.transitions.stream()
            .map(t -> YeelightUtils.joinIntArray(",", t.getTuple()))
            .collect(Collectors.joining(","));
    return new Object[] {
            this.count * this.transitions.size(),
            this.action.getValue(),
            flowExpression
    };
}
 

@Bean
public HandlerInterceptorAdapter requiresAuthenticationDynamicRegistrationInterceptor() {
    final String clients = Stream.of(
            Authenticators.CAS_OAUTH_CLIENT_BASIC_AUTHN,
            Authenticators.CAS_OAUTH_CLIENT_DIRECT_FORM,
            Authenticators.CAS_OAUTH_CLIENT_USER_FORM).collect(Collectors.joining(","));
    return new SecurityInterceptor(oauthSecConfig, clients);
}
 

private static List<Method> findHookMethods(Class<? extends Annotation> annotation, Class<?> hookClass, Method interceptedMethod) throws HookException {
    return Stream.of(hookClass.getDeclaredMethods())
            .filter(method -> method.isAnnotationPresent(annotation))
            .filter(method -> getMethodNames(method.getAnnotation(annotation)).contains(interceptedMethod.getName()))
            .filter(method -> parameterTypesMatch(method, interceptedMethod))
            .collect(Collectors.toList());
}
 

@SuppressWarnings("unchecked")
public <C extends ComponentConfiguration> Iterable<C> getConfigurations(Configurable<C> component, boolean onlyEnabled){
    if(component == null){
        return null;
    }
    List<ComponentConfiguration> catConfigs = config.get(component.getComponentCategory());
    if(catConfigs == null){
        return Collections.emptyList();
    }
    return (Iterable<C>)catConfigs.stream()
            .filter(cc -> Objects.equals(component.getComponentName(), cc.getType()))
            .filter(cc -> component.getConfigurationType().isAssignableFrom(cc.getClass()))
            .filter(cc -> !onlyEnabled || cc.isEnabled())
        .collect(Collectors.toList());
}
 

static AuthoritiesEnum getTopAuth() {
    Iterator iterator = SecurityContextHolder.getContext().getAuthentication().getAuthorities().iterator();
    List<AuthoritiesEnum> authorities = new ArrayList<>();
    while (iterator.hasNext()) {
        authorities.add(AuthoritiesEnum.valueOf(iterator.next().toString()));
    }
    authorities = authorities.stream().sorted().collect(Collectors.toList());
    return authorities.get(0);
}
 

public List<Result<RsRoot>> listRsRootResults(Capability capability) {
  return streamRsRootResults()
    .filter(result -> result.getContent()
      .map(RsRoot::getMetadata)
      .flatMap(RsMd::getCapability).orElse("Invalid capability").equals(capability.xmlValue))
    .collect(Collectors.toList());
}
 

/**
 * Get all available fields in class
 *
 * @return List of fields
 */
public List<FieldWrapper<?>> getFields() {
    return FIELD_INDEX.values().stream()
            .map(index -> FIELDWRAPPER_CACHE.computeIfAbsent(index, k ->
                    MethodHandleFieldWrapper.of(this, FIELD_CACHE.get(index))))
            .collect(Collectors.toList());
}
 

/**
 * Dump useful info associated with this task.
 */
public String compilationInfo() {
    return "instance#" + env.info().comboCount + ":[ options = " + options
            + ", diagnostics = " + diagsCollector.diagsByKeys.keySet()
            + ", dimensions = " + env.bindings
            + ", sources = \n" + sources.stream().map(s -> {
        try {
            return s.getCharContent(true);
        } catch (IOException ex) {
            return "";
        }
    }).collect(Collectors.joining(",")) + "]";
}
 

public static List<LogResource> fromOutput(String outputShell) {
    if (outputShell == null) return new ArrayList<>();
    if(outputShell.trim().length()<=3) return new ArrayList<>();
    outputShell = outputShell.trim();
    List<LogResource> logResources = Arrays.stream(outputShell.split("\\n"))
            .map(LogResourceFactory::fromStdout)
            .collect(Collectors.toList());
    Collections.reverse(logResources);
    return logResources;
}
 

private List<TRexCommand> buildRemoveCaptureCommand(List<Integer> capture_ids) {
    return capture_ids.stream()
                      .map(captureId -> {
                          Map<String, Object> parameters = new HashMap<>();
                          parameters.put("command", "remove");
                          parameters.put("capture_id", captureId);
                          return buildCommand("capture", parameters);
                      })
                      .collect(Collectors.toList());
}
 

public void oneToManyRelatedness(RelatednessPairRequest pairRequest, RelatednessOneToManyRequest otmRequest) {
    RelatednessPairResponse pairRes = driver.getRelatedness(pairRequest);
    Map<String, Double> pairResults = pairRes.getPairs().stream().collect(Collectors.toMap(p -> p.t2, p -> p.score));

    RelatednessOneToManyResponse otmRes = driver.getRelatedness(otmRequest);

    for (String m : otmRes.getMany().keySet()) {
        Assert.assertEquals(otmRes.getMany().get(m), pairResults.get(m));
    }
}
 

private List<Diagnostic> validatePositiveIntegerAttributes(final EClass eClass, final EObject eObject, final DiagnosticChain diagnostics) {
    final List<Diagnostic> missingRequiredAttributes = eClass.getEAllAttributes().stream()
            .filter(eAttribute -> !eAttribute.isMany()
                    && eAttribute.getEAttributeType() == FacetsPackage.Literals.POSITIVE_INTEGER
                    && eObject.eIsSet(eAttribute) && ((Integer) eObject.eGet(eAttribute)) <= 0)
            .map(eAttribute -> error("Facet '" + eAttribute.getName() + "' must > 0.", eObject)).collect(Collectors.toList());

    return missingRequiredAttributes;
}
 

private List<SipSession> extract(Map<String, SipSessionContainer> accumulator, SipSearchRequest request) {
    return accumulator.values().stream()
            .map(container -> container.session)
            .filter(session -> checkMillis(session.getMillis(), request.getMillis()))
            .sorted(Comparator.comparing(SipSession::getMillis))
            .collect(Collectors.toList());
}
 

@Override
public <T> Set<T> getAvailableResourceValues(DiscreteResourceId parent, Class<T> cls) {
    checkPermission(RESOURCE_READ);
    checkNotNull(parent);
    checkNotNull(cls);

    // naive implementation
    return getAvailableResources(parent).stream()
            .flatMap(resource -> Tools.stream(resource.valueAs(cls)))
            .collect(Collectors.toSet());
}
 

public static final EmbedBuilder generateHelpMessage(Invoker invoker, MessageEvent event, Command command) {
    final EmbedBuilder builder = command.getHelp(invoker, new EmbedBuilder().setTitle(String.format("Help for \"%s\"", invoker)));
    final ArrayList<Invoker> invokers = command.getInvokers();
    if (invokers.size() > 1) {
        builder.setDescription(String.format("Associated Command Invokers: %s", getInvokersAsString(invokers.stream().filter((invoker_) -> !invoker.equals(invoker_)).collect(Collectors.toList()))));
    }
    return builder;
}
 

private void checkResults() throws Exception {
    // test map
    Path map = outDir.resolve("jksmap.txt");
    assertThat(map).isRegularFile();
    List<String> mapLines = Files.lines(map).collect(Collectors.toList());

    assertThat(mapLines.size()).isEqualTo(6);

    checkLine(mapLines, "multi-1.not-secure.r2.io");
    checkLine(mapLines, "multi-2.not-secure.r2.io");
    checkLine(mapLines, "multi-3.not-secure.r2.io");
    checkLine(mapLines, "not-secure.r2.io");
    checkLine(mapLines, "www.not-secure.r2.io");
    checkLine(mapLines, "single.not-secure.r2.io");
}
 

public static Collection<String> getGivenParameters(CallStatementElement statement) {
  return statement
      .getParamListElementList()
      .stream()
      .map(param -> param.getBeginParamTag().getParamSpecificationIdentifier())
      .filter(param -> param != null)
      .map(PsiElement::getText)
      .collect(Collectors.toList());
}
 

private List<Integer> reversePermutation(List<Integer> psy) {
    Preconditions.checkArgument(psy.containsAll(
            IntStream.range(0, psy.size()).boxed().collect(Collectors.toList())),
            "The permutation should contain all number from 0 (inclusive) to length (exclusive)");

    return IntStream.range(0, psy.size()).mapToObj(psy::indexOf).collect(Collectors.toList());
}
 

private Set<Node<T>> unvisitedNodes(Map<Node<T>, Set<Node<T>>> nodeParents) {
  return nodeParents.entrySet()
      .parallelStream()
      .filter(parents -> !parents.getValue().isEmpty())
      .map(Entry::getKey)
      .collect(Collectors.toSet());
}
 

public ResultSet<Object> handle(SearchObjectRequest request)
        throws AccessDeniedException, AuthenticationFailedException, InvalidArgumentException {
  TiSecurityContext.get().checkPermission(TiFunctionConstants.viewFactObjects);

  List<ObjectEntity> filteredObjects = filterObjects(request);

  return ResultSet.builder()
          .setCount(filteredObjects.size())
          .setLimit(ObjectUtils.ifNull(request.getLimit(), DEFAULT_LIMIT))
          .setValues(filteredObjects.stream().map(TiRequestContext.get().getObjectConverter()).collect(Collectors.toList()))
          .build();
}
 

private Map<Tag, Double> mergeTagFrequency(Map<Tag, Double> map1, Map<Tag, Double> map2) {
    return Stream
            .concat(map1.entrySet().stream(), map2.entrySet().stream())
            .collect(Collectors.toMap(
                    Map.Entry::getKey,
                    Map.Entry::getValue,
                    Double::sum
                    )
            );
}
 

/**
 * Normalize a list of unique secret names.
 *
 * @param uniqSecretNames collection of unique secret names.
 * @return list of normalized secret names.
 */
public List<String> normalize(Collection<String> uniqSecretNames) {
    return uniqSecretNames.stream().map(uniqName -> {
        AppSecret appSecret = new AppSecret(uniqName);
        return appSecret.getSecretName();
    }).collect(Collectors.toList());
}
 

@Test
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void groupingTest() throws IOException {
    VcfFilterForm vcfFilterForm = new VcfFilterForm();

    IndexSearchResult<VcfIndexEntry> entryList = featureIndexManager.filterVariations(vcfFilterForm,
                                                                                      testProject.getId());
    Assert.assertFalse(entryList.getEntries().isEmpty());

    List<Group> counts = featureIndexManager.groupVariations(new VcfFilterForm(), testProject.getId(),
                                                             IndexSortField.CHROMOSOME_NAME.name());
    Assert.assertFalse(counts.isEmpty());

    // test load additional info and group by it
    VcfFilterInfo info = vcfManager.getFiltersInfo(Collections.singletonList(testVcf.getId()));

    vcfFilterForm = new VcfFilterForm();
    vcfFilterForm.setInfoFields(info.getInfoItems().stream().map(i -> i.getName()).collect(Collectors.toList()));

    entryList = featureIndexManager.filterVariations(vcfFilterForm, testProject.getId());
    Assert.assertFalse(entryList.getEntries().isEmpty());

    for (InfoItem infoItem : info.getInfoItems()) {
        String groupByField = infoItem.getName();
        List<Group> c = featureIndexManager.groupVariations(new VcfFilterForm(), testProject.getId(),
                                                                            groupByField);
        List<VcfIndexEntry> entriesWithField = entryList.getEntries().stream()
            .filter(e -> e.getInfo().get(groupByField) != null).collect(Collectors.toList());
        if (!entriesWithField.isEmpty()) {
            Assert.assertFalse("Empty grouping for field: " + groupByField, c.isEmpty());
        }
    }
}
 

@Test
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void testLoadAllFields() throws IOException {
    VcfFilterForm filterForm = new VcfFilterForm();
    VcfFilterInfo info = vcfManager.getFiltersInfo(Collections.singletonList(testVcf.getId()));
    filterForm.setInfoFields(info.getInfoItems().stream().map(InfoItem::getName).collect(Collectors.toList()));

    IndexSearchResult<VcfIndexEntry> entries = featureIndexManager.filterVariations(filterForm,
                                                                                    testProject.getId());
    Assert.assertFalse(entries.getEntries().isEmpty());
}
 

private static List<ExamScore> getScores(String startDate) {
    DateTime start = ISODateTimeFormat.dateTimeParser().parseDateTime(startDate);
    List<ExamRecord> examRecords = Ebean.find(ExamRecord.class)
            .fetch("examScore")
            .where()
            .gt("timeStamp", start.toDate())
            .findList();
    return examRecords.stream().map(ExamRecord::getExamScore).collect(Collectors.toList());
}
 

@Before
public void loadExpectedJars() throws IOException {
  String expectedJarFile =
      TestUtil.getResourcePath(BundledJarsJUnitTest.class, "/expected_jars.txt");

  expectedJars = Files.lines(Paths.get(expectedJarFile)).collect(Collectors.toSet());
}
 

@Override
public List<Diagnosis> executeDiagnosers(List<Symptom> symptoms) {
  List<Diagnosis> diagnosis = new ArrayList<>();
  if (diagnosers == null) {
    return diagnosis;
  }

  diagnosis = diagnosers.stream().map(diagnoser -> diagnoser.diagnose(symptoms))
      .filter(diagnoses -> diagnoses != null).flatMap(x -> x.stream())
      .collect(Collectors.toList());

  return diagnosis;
}
 

@Test
public void buildTest() {
    final Set<KeyPair> keyPairs5 = generateKeyPairs(5);
    final Set<KeyPair> keyPairs3 = generateKeyPairs(3);
    final KeyShardSet.KeyShardingSetBuilder builder = KeyShardSet.newBuilder(AsymmetricEncryptionAlgorithm.RSA);
    final Set<PublicKey> publicKeys5 = keyPairs5.stream().map(KeyPair::getPublic).collect(Collectors.toSet());
    final Set<PublicKey> publicKeys3 = keyPairs3.stream().map(KeyPair::getPublic).collect(Collectors.toSet());
    final KeyShardSet keyShardSet = builder.addKeyGroup(2,  publicKeys5)
            .addKeyGroup(3,  publicKeys3)
            .build(key4800);
    assertNotNull(keyShardSet.getUuid());
    assertEquals(8, keyShardSet.getShardCount());
    final Collection<KeyShardSet.KeyShardGroup> groups = keyShardSet.getGroups();
    assertEquals(2, groups.size());
    final Iterator<KeyShardSet.KeyShardGroup> groupIterator = groups.iterator();
    final KeyShardSet.KeyShardGroup thisGroup = groupIterator.next();
    final KeyShardSet.KeyShardGroup group5, group3;
    switch (thisGroup.getKeys().size()) {
        case 5:
            group5 = thisGroup;
            group3 = groupIterator.next();
            break;
        case 3:
            group3 = thisGroup;
            group5 = groupIterator.next();
            break;
        default:
            fail("Group has a size other than 5 or 3!");
            throw new RuntimeException("Group has a size other than 5 or 3!");
    }
    assertEquals(publicKeys5, group5.getKeys());
    assertEquals(publicKeys3, group3.getKeys());
    assertEquals(2, group5.getQuorumSize());
    assertEquals(3, group3.getQuorumSize());
    checkGroupShardsPerKey(group5, 4);
    checkGroupShardsPerKey(group3, 1);
    checkGroupCoverage(keyShardSet);
}
 

public static List<String> getFeaturedProjects() {
	Featured[] array = null;
	try {
		array = JsonUtil.read(new URL(FEATURED_URL), Featured[].class);
	} catch (MalformedURLException e) {
		OneClientLogging.error(e);
	}
	if (array != null) {
		return Arrays.stream(array).map(f -> f.projectId).collect(Collectors.toList());
	}
	return null;
}
 

/**
 * Get all unique triples of (predicate URI, source type index, target type index) of related entities.
 *
 * @param relations DataFrame of relations (predicateIndex, fromTypeIndex, instanceID, toTypeIndex, relatedID)
 * @return all unique triples of (predicate URI, source type index, target type index) of related entities
 */
private Set<Tuple3<String, Integer, Integer>> getUniquePredicateTypeTriples(DataFrame relations) {
    return relations
            .select("predicateIndex", "fromTypeIndex", "toTypeIndex")
            .distinct()
            .collectAsList().stream()
            .map(row -> new Tuple3<>(rdfSchema.getPredicateIndex().getValue(row.getInt(0)), row.getInt(1), row.getInt(2)))
            .collect(Collectors.toSet());
}
 

protected void loadFromFile() throws IOException {
    Collection<? extends NotifierBuilder> collection = objectMapper.readValue(
            new FileReader(notifierFile),
            new TypeReference<Set<NotifierBuilder>>() {
            }
    );
    this.notifierSet.addAll(collection.stream().map(builder -> builder.build()).collect(Collectors.toSet()));
}
 

public List<MaterialDefinition> findFromOreDict(World world, ItemStack stack) {
    List<String> names = new ArrayList<>();
    for(int index : OreDictionary.getOreIDs(stack)) {
        names.add(OreDictionary.getOreName(index));
    }

    return RandoresWorldData.getAll(RandoresWorldData.getId(world)).stream().filter(def -> !names.contains(def.getMaterial().getType().getDictName() + def.getName())).collect(Collectors.toList());
}
 

private List<CloudServiceExtended> getRemainingServicesToPoll(Map<CloudServiceExtended, ServiceOperation> servicesWithLastOperation) {
    return servicesWithLastOperation.entrySet()
        .stream()
        .filter(serviceWithLastOperation -> serviceWithLastOperation.getValue().getState() == ServiceOperationState.IN_PROGRESS)
        .map(serviceWithLastOperation -> serviceWithLastOperation.getKey())
        .collect(Collectors.toList());
}
 

@Override
public InternalAggregation reduce(InternalAggregation aggregation, ReduceContext reduceContext) {
    InternalMultiBucketAggregation<InternalMultiBucketAggregation, InternalMultiBucketAggregation.InternalBucket> originalAgg = (InternalMultiBucketAggregation<InternalMultiBucketAggregation, InternalMultiBucketAggregation.InternalBucket>) aggregation;
    List<? extends Bucket> buckets = originalAgg.getBuckets();

    CompiledScript compiledScript = reduceContext.scriptService().compile(script, ScriptContext.Standard.AGGS);
    List newBuckets = new ArrayList<>();
    for (Bucket bucket : buckets) {
        Map<String, Object> vars = new HashMap<>();
        if (script.getParams() != null) {
            vars.putAll(script.getParams());
        }
        boolean skipBucket = false;
        for (Map.Entry<String, String> entry : bucketsPathsMap.entrySet()) {
            String varName = entry.getKey();
            String bucketsPath = entry.getValue();
            Double value = resolveBucketValue(originalAgg, bucket, bucketsPath, gapPolicy);
            if (GapPolicy.SKIP == gapPolicy && (value == null || Double.isNaN(value))) {
                skipBucket = true;
                break;
            }
            vars.put(varName, value);
        }
        if (skipBucket) {
            newBuckets.add(bucket);
        } else {
            ExecutableScript executableScript = reduceContext.scriptService().executable(compiledScript, vars);
            Object returned = executableScript.run();
            if (returned == null) {
                newBuckets.add(bucket);
            } else {
                if (!(returned instanceof Number)) {
                    throw new AggregationExecutionException("series_arithmetic script for reducer [" + name()
                            + "] must return a Number");
                }
                final List<InternalAggregation> aggs = StreamSupport.stream(bucket.getAggregations().spliterator(), false).map((p) -> {
                    return (InternalAggregation) p;
                }).collect(Collectors.toList());
                aggs.add(new InternalSimpleValue(name(), ((Number) returned).doubleValue(), formatter,
                        new ArrayList<>(), metaData()));
                InternalMultiBucketAggregation.InternalBucket newBucket = originalAgg.createBucket(new InternalAggregations(aggs),
                        (InternalMultiBucketAggregation.InternalBucket) bucket);
                newBuckets.add(newBucket);
            }
        }
    }
    return originalAgg.create(newBuckets);
}
 

@Override
public String getJavaClassName(String shapeName) {
    return Arrays.stream(shapeName.split("[._-]|\\W")).map(Utils::capitialize).collect(Collectors.joining());
}
 

public List<Integer> getFromParentDependencyList(int nodeId)
{
	return IntStream.range(0, this.dependencyMatrixSize).filter(i -> i != nodeId && this.dependencyMatrix[i][nodeId] != 0)
														.boxed().collect(Collectors.toList());
}
 

private static List<String> concatList(List<String> listOne, List<String> listTwo) {
    return Stream.concat(listOne.stream(), listTwo.stream())
        .distinct()
        .collect(Collectors.toList());
}
 

static Coffee orderOther(final Coffee coffee) {
    Random rnd = new Random();
    List<Coffee> filtered = COFFEES.stream().filter(c -> !c.equals(coffee)).collect(Collectors.toList());
    return filtered.get(rnd.nextInt(filtered.size()));
}
 

public List<Unit> getAvailableUnits(final Category UNIT_DEFINITION) {
    return getAllUnitDefinitions().get(UNIT_DEFINITION).stream().map(unitDefinition -> unitDefinition.UNIT).collect(Collectors.toList());
}
 

public static List<Entry> getSetOfEntries(int startIndex, int endIndex) {
    return IntStream.range(startIndex, endIndex).mapToObj(index -> getKeyValueEntryWitIndex(index))
        .collect(Collectors.toList());
}
 

@Override
public List<IRelationship> getRelationships(IRelationship.Type type) {
    return relationships.stream().filter(r -> r.getType().equals(type)).collect(Collectors.toList());
}
 

public static String read(HttpServletRequest input) throws IOException {
    try (BufferedReader reader = input.getReader()) {
        return reader.lines().collect(Collectors.joining("\n"));
    }
}
 

@Override
public GraphQLSchema get() {
  Map<String, ? extends Function<String, Object>> nodeDataFetchers =
      this.nodeDataFetchers
          .stream()
          .collect(Collectors.toMap(e -> e.getClassName(), Function.identity()));

  GraphQLObjectType.Builder queryType =
      newObject().name("QueryType").fields(Lists.newArrayList(queryFields));

  ProtoRegistry protoRegistry =
      ProtoRegistry.newBuilder().addAll(fileDescriptors).add(modifications).build();

  if (protoRegistry.hasRelayNode()) {
    queryType.field(
        new Relay()
            .nodeField(
                protoRegistry.getRelayNode(),
                environment -> {
                  String id = environment.getArgument("id");
                  Relay.ResolvedGlobalId resolvedGlobalId = new Relay().fromGlobalId(id);
                  Function<String, ?> stringFunction =
                      nodeDataFetchers.get(resolvedGlobalId.getType());
                  if (stringFunction == null) {
                    throw new RuntimeException(
                        String.format(
                            "Relay Node fetcher not implemented for type=%s",
                            resolvedGlobalId.getType()));
                  }
                  return stringFunction.apply(resolvedGlobalId.getId());
                }));
  }

  if (mutationFields.isEmpty()) {
    return GraphQLSchema.newSchema().query(queryType).build(protoRegistry.listTypes());
  }
  GraphQLObjectType mutationType =
      newObject().name("MutationType").fields(Lists.newArrayList(mutationFields)).build();
  return GraphQLSchema.newSchema()
      .query(queryType)
      .mutation(mutationType)
      .build(protoRegistry.listTypes());
}