Java MutableMultimap類代碼示例

import org.eclipse.collections.api.multimap.MutableMultimap; //導入依賴的package包/類
private Predicate<? super ChecksumEntry> getPlatformInclusionPredicate(DbEnvironment env) {
    // 1) exclude those tables that are excluded by default from source code, e.g. explain tables or others that users configure
    ImmutableSet<Predicate<? super ChecksumEntry>> schemaObjectNamePredicates = env.getSchemas().collect(new Function<Schema, Predicate<? super ChecksumEntry>>() {
        @Override
        public Predicate<? super ChecksumEntry> valueOf(Schema schema) {
            return schema.getObjectExclusionPredicateBuilder().build(ChecksumEntry.TO_OBJECT_TYPE, ChecksumEntry.TO_NAME1);
        }
    });

    // 2) exclude the audit tables
    MutableMultimap<String, String> tablesToExclude = Multimaps.mutable.set.empty();

    tablesToExclude.putAll(ChangeType.TABLE_STR, Sets.immutable.with(
            env.getPlatform().convertDbObjectName().valueOf(getArtifactDeployerDao().getAuditContainerName()),
            env.getPlatform().convertDbObjectName().valueOf(dbChecksumManager.getChecksumContainerName()),
            env.getPlatform().convertDbObjectName().valueOf(getDeployExecutionDao().getExecutionContainerName()),
            env.getPlatform().convertDbObjectName().valueOf(getDeployExecutionDao().getExecutionAttributeContainerName())
    ));
    ObjectTypeAndNamePredicateBuilder auditTablePredicateBuilder = new ObjectTypeAndNamePredicateBuilder(tablesToExclude.toImmutable(), ObjectTypeAndNamePredicateBuilder.FilterType.EXCLUDE);
    Predicates<? super ChecksumEntry> auditTablePredicate = auditTablePredicateBuilder.build(ChecksumEntry.TO_OBJECT_TYPE, ChecksumEntry.TO_NAME1);

    return Predicates.and(auditTablePredicate, Predicates.and(schemaObjectNamePredicates));
}
 

import org.eclipse.collections.api.multimap.MutableMultimap; //導入依賴的package包/類
@Benchmark
public MutableMultimap<Integer, Person> filterAndGroupByAgeECEager_parallel()
{
    Collection<Person> select =
            ParallelIterate.select(Person.getECPeople(), person -> person.getHeightInInches() < 150);
    MutableMultimap<Integer, Person> grouped =
            ParallelIterate.groupBy(select, Person::getAge);
    return grouped;
}
 

import org.eclipse.collections.api.multimap.MutableMultimap; //導入依賴的package包/類
/**
 * Create a Multimap where the keys are the names of items and the values are the Suppliers that supply them.
 * A Supplier is associated to many item names.
 */
@Test
public void itemsBySuppliers()
{
    MutableMultimap<String, Supplier> itemsToSuppliers = null;

    Verify.assertIterableSize("should be 2 suppliers for sofa", 2, itemsToSuppliers.get("sofa"));
}
 

import org.eclipse.collections.api.multimap.MutableMultimap; //導入依賴的package包/類
@Override
public ImmutableList<Change> readChanges(boolean useBaseline) {

    MutableList<Change> allChanges = Lists.mutable.empty();

    ImmutableSet<String> envSchemas = env.getSchemaNames().collect(this.convertDbObjectName);

    for (FileObject sourceDir : env.getSourceDirs()) {
        for (FileObject schemaDir : sourceDir.findFiles(new BasicFileSelector(and(vcsAware(), directory()), false))) {
            String schema = schemaDir.getName().getBaseName();

            if (envSchemas.contains(this.convertDbObjectName.valueOf(schema))) {
                MutableList<Change> schemaChanges = Lists.mutable.empty();

                for (ChangeType changeType : env.getPlatform().getChangeTypes()) {
                    FileObject changeTypeDir = this.findDirectoryForChangeType(schemaDir, changeType);

                    if (changeTypeDir != null) {
                        ImmutableList<Change> changes;
                        if (changeType.isRerunnable()) {
                            changes = findChanges(changeType, changeTypeDir, this.rerunnableChangeParser, TrueFileFilter.INSTANCE, schema);
                        } else {
                            changes = findTableChanges(changeType, changeTypeDir, schema, useBaseline);
                        }
                        schemaChanges.withAll(changes);
                    }
                }

                MutableCollection<Change> tableChanges = schemaChanges.select(
                        Predicates.attributeIn(Change.TO_CHANGE_TYPE_NAME, Sets.immutable.of(ChangeType.TABLE_STR, ChangeType.FOREIGN_KEY_STR)));
                MutableMultimap<String, Change> tableChangeMap = tableChanges.groupBy(Change.TO_DB_OBJECT_KEY);

                MutableCollection<Change> staticDataChanges = schemaChanges.select(Predicates.attributeEqual(Change.TO_CHANGE_TYPE_NAME, ChangeType.STATICDATA_STR));

                // now enrich the staticData objects w/ the information from the tables to facilitate the
                // deployment order calculation.
                for (Change staticDataChange : staticDataChanges) {
                    MutableCollection<Change> relatedTableChanges = tableChangeMap.get(staticDataChange.getDbObjectKey());
                    MutableCollection<Change> foreignKeys = relatedTableChanges.select(
                            Predicates.attributeEqual(Change.TO_CHANGE_TYPE_NAME, ChangeType.FOREIGN_KEY_STR));

                    String fkContent = foreignKeys.collect(Change.TO_CONTENT).makeString("\n\n");

                    staticDataChange.setContentForDependencyCalculation(fkContent);
                }


                allChanges.addAll(schemaChanges);
            } else {
                LOG.info("Skipping schema directory [{}] as it was not defined among the schemas in your system-config.xml file: {}", schema, envSchemas);
                continue;
            }
        }
    }

    return allChanges.selectWith(ArtifactRestrictions.apply(), env).toImmutable();
}