Java ImmutableMultimap类代码示例

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
default void use() {
  ImmutableExtraCollection.of(
      ImmutableList.<String>of(),
      ImmutableMultimap.<Integer, String>of(),
      ImmutableMultimap.<Integer, String>of(),
      ImmutableMultimap.<Integer, String>of(),
      ImmutableBiMap.<Integer, String>of());
  ImmutableExtraCollection.of();
  ImmutableExtraCollection collection = ImmutableExtraCollection.builder()
      .addBag("2", "2")
      .putIndex(1, "2", "3", "4")
      .putAllIndex(1, Arrays.asList("2", "3", "4"))
      .putIndex(2, "5")
      .putIndexList(1, "")
      .putIndexSet(2, "2")
      .putAllIndexSet(2, Arrays.asList("3", "4"))
      .putBiMap(1, "a")
      .putBiMap(2, "b")
      .putAllBiMap(Collections.singletonMap(3, "c"))
      .build();

  collection.bag().count("2");
  collection.index().get(1);
  collection.indexList().get(1);
  collection.indexSet().get(2);
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
public static <K,V> ImmutableList<ImmutableMap<K, V>> flatten(ImmutableMultimap<K, V> src) {
	ImmutableList.Builder<ImmutableMap<K, V>> listBuilder=ImmutableList.builder();
	
	if (!src.isEmpty()) {
		ImmutableMap<K, Collection<V>> map = src.asMap();
		int entries=map.values().stream().reduce(1, (s,l) -> s*l.size(), (a,b) -> a*b);
		
		ImmutableList<Line<K,V>> lines = map.entrySet().stream()
				.map(e -> new Line<>(e.getKey(), e.getValue()))
				.collect(ImmutableList.toImmutableList());
		
		for (int i=0;i<entries;i++) {
			ImmutableMap.Builder<K, V> mapBuilder = ImmutableMap.builder();
			
			int fact=1;
			for (Line<K,V> line: lines) {
				mapBuilder.put(line.key, line.get((i/fact) % line.values.length));
				fact=fact*line.values.length;
			}
			
			listBuilder.add(mapBuilder.build());
		}
	}
	return listBuilder.build();
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
@Override
public Multimap<Character, Map.Entry<String, ValueAttribute>> apply(Iterable<ValueAttribute> attributes) {
  ImmutableMultimap.Builder<Character, Map.Entry<String, ValueAttribute>> builder = ImmutableMultimap.builder();

  for (ValueAttribute attribute : attributes) {
    String serializedName = attribute.getMarshaledName();
    builder.put(serializedName.charAt(0), Maps.immutableEntry(serializedName, attribute));

    for (String alternateName : attribute.getAlternateSerializedNames()) {
      if (!alternateName.isEmpty()) {
        builder.put(alternateName.charAt(0), Maps.immutableEntry(alternateName, attribute));
      }
    }
  }

  return builder.build();
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
@Test public void testOf() {
  assertKeyValues(BiStream.of("one", 1))
      .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1))
      .inOrder();
  assertKeyValues(BiStream.of("one", 1, "two", 2))
      .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "two", 2))
      .inOrder();
  assertKeyValues(BiStream.of("one", 1, "two", 2, "three", 3))
      .containsExactlyEntriesIn(ImmutableMultimap.of("one", 1, "two", 2, "three", 3))
      .inOrder();
  assertKeyValues(BiStream.of("one", 1, "two", 2, "three", 3, "four", 4))
      .containsExactlyEntriesIn(ImmutableMultimap.of(
          "one", 1, "two", 2, "three", 3, "four", 4))
      .inOrder();
  assertKeyValues(BiStream.of("one", 1, "two", 2, "three", 3, "four", 4, "five", 5))
      .containsExactlyEntriesIn(ImmutableMultimap.of(
          "one", 1, "two", 2, "three", 3, "four", 4, "five", 5))
      .inOrder();
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
public static ImmutableMultimap<String, Object> pathPropertiesOfAsMultimap(Blob blob, Function<String, Collection<String>> pathPropertyMapping, Path path, PropertyCollectionResolver propertyResolver) {
	ImmutableList<String> pathProperties = path.propertyNamesWithoutPage();
	
	ImmutableMap<String, ImmutableSet<?>> blopPathPropertyMap = pathProperties.stream()
		.map(p -> Pair.<String, ImmutableSet<?>>of(p, propertyOf(blob, pathPropertyMapping, propertyResolver, p)))
		.filter(pair -> !pair.b().isEmpty())
		.collect(ImmutableMap.toImmutableMap(Pair::a, Pair::b));
	
	if (blopPathPropertyMap.keySet().size()<pathProperties.size()) {
		return ImmutableMultimap.of();
	}
	
	Builder<String, Object> multiMapBuilder = ImmutableMultimap.builder();
	
	blopPathPropertyMap.forEach((key, values) -> {
		multiMapBuilder.putAll(key, values);
	});
	
	return multiMapBuilder.build();
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
public ImmutableGroupedPropertyMap build() {
	ImmutableMap.Builder<Key, ImmutableMap<String, Object>> mapOfMapsBuilder=ImmutableMap.builder();
	ImmutableMultimap.Builder<Key, String> groupOfKeyBuilder=ImmutableMultimap.builder();
	
	maps.forEach((key, map) -> {
		mapOfMapsBuilder.put(key, ImmutableMap.copyOf(map));
	});
	
	maps.keySet().forEach(key -> {
		Key current=key;
		while (!current.isRoot()) {
			Key parent = current.parent();
			groupOfKeyBuilder.put(parent, current.last());
			current=parent;
		}
	});
	
	return new ImmutableGroupedPropertyMap(mapOfMapsBuilder.build(), groupOfKeyBuilder.build());
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
private ImmutableMultimap<String, FMeasureCounts> toFMeasures(
    Collection<BrokenDownSummaryConfusionMatrix<Symbol>> data,
    Map.Entry<String, Collection<Symbol>> FMeasureSymbol) {
  final ImmutableMultimap.Builder<String, FMeasureCounts> ret = ImmutableMultimap.builder();

    /*
     MapUtils.copyWithTransformedEntries(data.asMap(),
                        Functions.toStringFunction(), FmeasureVs(FMeasureSymbol.getValue()));
     */
  final Function<SummaryConfusionMatrix, FMeasureCounts> scoringFunction =
      FmeasureVs(ImmutableSet.copyOf(FMeasureSymbol.getValue()));
  for (final BrokenDownSummaryConfusionMatrix<Symbol> dataPoint : data) {
    for (final Map.Entry<Symbol, SummaryConfusionMatrix> entry : dataPoint.asMap().entrySet()) {
      ret.put(entry.getKey().toString(), scoringFunction.apply(entry.getValue()));
    }
  }

  return ret.build();
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
@Override
public void execute(final ImmutableMultimap<String, String> parameters, final PrintWriter output) throws Exception {

    LOGGER.info("{} endpoint called", TASK_NAME);

    @SuppressWarnings("FutureReturnValueIgnored")
    Future<Void> future = CompletableFuture
            .runAsync(statisticsIngestService::stop)
            .handle((aVoid, ex) -> {
                if (ex != null) {
                    LOGGER.error("Task {} failed with error {}", TASK_NAME, ex.getMessage(), ex);
                } else {
                    LOGGER.info("Task {} completed successfully", TASK_NAME);
                }
                return aVoid;
            });
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
public static ImmutableList<Menu> of(ImmutableMultimap<ImmutableMap<String, Object>, Blob> groupedBlobs) {
	ImmutableList<BlobAndMenu> sortedBlobs = groupedBlobs.inverse().asMap()
			.entrySet()
			.stream()
			.filter(e -> !e.getValue().isEmpty())
			.map(e -> BlobAndMenu.of(e.getKey(), e.getValue().iterator().next()))
			.sorted((a,b) -> Long.compare(a.menu().weight(), b.menu().weight()))
			.collect(ImmutableList.toImmutableList());
	
	ImmutableList<BlobAndMenu> parents = sortedBlobs.stream()
			.filter(blobmenu -> !blobmenu.menu().parent().isPresent())
			.collect(ImmutableList.toImmutableList());
	
	return parents.stream()
		.map(parent -> asMenu(parent,sortedBlobs))
		.collect(ImmutableList.toImmutableList());
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
public static <K, V> Multimap<K, V> combine(Iterable<Multimap<K, V>> maps) {
    Multimap<K, V> singleton = null;
    ImmutableMultimap.Builder<K, V> builder = null;
    for(Multimap<K, V> map : maps) {
        if(!map.isEmpty()) {
            if(singleton == null) {
                singleton = map;
            } else {
                if(builder == null) {
                    builder = ImmutableMultimap.builder();
                }
                builder.putAll(singleton);
                builder.putAll(map);
            }
        }
    }

    if(builder != null) {
        return builder.build();
    } else if(singleton != null) {
        return singleton;
    } else {
        return ImmutableMultimap.of();
    }
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
public static <T, L, K> Collector<T, ?, ImmutableMultimap<K, T>> groupingByValues(Function<? super T, ? extends Iterable<? extends K>> classifier) {
	return ImmutableGenericCollector.<T, LinkedListMultimap<K, T>, ImmutableMultimap<K, T>>builder()
		.supplier(LinkedListMultimap::create)
		.accumulator((map, t) -> {
			classifier.apply(t).forEach(k -> {
				map.put(k, t);
			});
		})
		.combiner((a,b) -> {
			LinkedListMultimap<K, T> ret = LinkedListMultimap.create(a);
			ret.putAll(b);
			return ret;
		})
		.finisher(map -> ImmutableMultimap.copyOf(map))
		.build();
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
@Override
@Transactional(propagation = Propagation.MANDATORY)
public Multimap<Long, String> getCollaboratorsForItemIds(Collection<Long> itemIds)
{
	if( itemIds.isEmpty() )
	{
		return ImmutableMultimap.of();
	}
	List<Object[]> attachments = getHibernateTemplate().findByNamedParam(
		"select c, i.id from Item i join i.collaborators c where i.id in (:items)", "items", itemIds);
	ListMultimap<Long, String> multiMap = ArrayListMultimap.create();
	for( Object[] attachmentRow : attachments )
	{
		multiMap.put((Long) attachmentRow[1], (String) attachmentRow[0]);
	}
	return multiMap;
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
public ImmutableMultimap<Integer, Record> getResultingSourceMapping(XmlDocument xmlDocument)
        throws ParserConfigurationException, SAXException, IOException {

    XmlLoader.SourceLocation inMemory = XmlLoader.UNKNOWN;

    XmlDocument loadedWithLineNumbers = XmlLoader.load(
            xmlDocument.getSelectors(),
            xmlDocument.getSystemPropertyResolver(),
            inMemory,
            xmlDocument.prettyPrint(),
            XmlDocument.Type.MAIN,
            Optional.<String>absent() /* mainManifestPackageName */);

    ImmutableMultimap.Builder<Integer, Record> mappingBuilder = ImmutableMultimap.builder();
    for (XmlElement xmlElement : loadedWithLineNumbers.getRootNode().getMergeableElements()) {
        parse(xmlElement, mappingBuilder);
    }
    return mappingBuilder.build();
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
private void parse(XmlElement element,
        ImmutableMultimap.Builder<Integer, Record> mappings) {
    DecisionTreeRecord decisionTreeRecord = mRecords.get(element.getId());
    if (decisionTreeRecord != null) {
        NodeRecord nodeRecord = findNodeRecord(decisionTreeRecord);
        if (nodeRecord != null) {
            mappings.put(element.getPosition().getLine(), nodeRecord);
        }
        for (XmlAttribute xmlAttribute : element.getAttributes()) {
            AttributeRecord attributeRecord = findAttributeRecord(decisionTreeRecord,
                    xmlAttribute);
            if (attributeRecord != null) {
                mappings.put(xmlAttribute.getPosition().getLine(), attributeRecord);
            }
        }
    }
    for (XmlElement xmlElement : element.getMergeableElements()) {
        parse(xmlElement, mappings);
    }
}
 

import com.google.common.collect.ImmutableMultimap; //导入依赖的package包/类
public String blame(XmlDocument xmlDocument)
        throws IOException, SAXException, ParserConfigurationException {

    ImmutableMultimap<Integer, Record> resultingSourceMapping =
            getResultingSourceMapping(xmlDocument);
    LineReader lineReader = new LineReader(
            new StringReader(xmlDocument.prettyPrint()));

    StringBuilder actualMappings = new StringBuilder();
    String line;
    int count = 1;
    while ((line = lineReader.readLine()) != null) {
        actualMappings.append(count).append(line).append("\n");
        if (resultingSourceMapping.containsKey(count)) {
            for (Record record : resultingSourceMapping.get(count)) {
                actualMappings.append(count).append("-->")
                        .append(record.getActionLocation().toString())
                        .append("\n");
            }
        }
        count++;
    }
    return actualMappings.toString();
}