Java Collections.newSetFromMap方法代码示例

import java.util.Collections; //导入方法依赖的package包/类
ConnectionManager() {
  this.idleScanTimer = new Timer(
      "IPC Server idle connection scanner for port " + getPort(), true);
  this.idleScanThreshold = conf.getInt(
      CommonConfigurationKeysPublic.IPC_CLIENT_IDLETHRESHOLD_KEY,
      CommonConfigurationKeysPublic.IPC_CLIENT_IDLETHRESHOLD_DEFAULT);
  this.idleScanInterval = conf.getInt(
      CommonConfigurationKeys.IPC_CLIENT_CONNECTION_IDLESCANINTERVAL_KEY,
      CommonConfigurationKeys.IPC_CLIENT_CONNECTION_IDLESCANINTERVAL_DEFAULT);
  this.maxIdleTime = 2 * conf.getInt(
      CommonConfigurationKeysPublic.IPC_CLIENT_CONNECTION_MAXIDLETIME_KEY,
      CommonConfigurationKeysPublic.IPC_CLIENT_CONNECTION_MAXIDLETIME_DEFAULT);
  this.maxIdleToClose = conf.getInt(
      CommonConfigurationKeysPublic.IPC_CLIENT_KILL_MAX_KEY,
      CommonConfigurationKeysPublic.IPC_CLIENT_KILL_MAX_DEFAULT);
  this.maxConnections = conf.getInt(
      CommonConfigurationKeysPublic.IPC_SERVER_MAX_CONNECTIONS_KEY,
      CommonConfigurationKeysPublic.IPC_SERVER_MAX_CONNECTIONS_DEFAULT);
  // create a set with concurrency -and- a thread-safe iterator, add 2
  // for listener and idle closer threads
  this.connections = Collections.newSetFromMap(
      new ConcurrentHashMap<Connection,Boolean>(
          maxQueueSize, 0.75f, readThreads+2));
}
 

import java.util.Collections; //导入方法依赖的package包/类
/**
 * Adds the abnormal visual and sends packet for updating them in client.
 * @param aves the abnormal visual effects
 */
public final void startAbnormalVisualEffect(AbnormalVisualEffect... aves)
{
	for (AbnormalVisualEffect ave : aves)
	{
		if (_abnormalVisualEffects == null)
		{
			synchronized (this)
			{
				if (_abnormalVisualEffects == null)
				{
					_abnormalVisualEffects = Collections.newSetFromMap(new ConcurrentHashMap<>());
				}
			}
		}
		_abnormalVisualEffects.add(ave);
	}
	resetCurrentAbnormalVisualEffects();
}
 

import java.util.Collections; //导入方法依赖的package包/类
@Override
public long getNumberOfAssociations(SessionFactory sessionFactory, AssociationStorageType type) {
	int asscociationCount = 0;
	Set<IgniteCache<Object, BinaryObject>> processedCaches = Collections.newSetFromMap( new IdentityHashMap<IgniteCache<Object, BinaryObject>, Boolean>() );

	for ( CollectionPersister collectionPersister : ( (SessionFactoryImplementor) sessionFactory ).getCollectionPersisters().values() ) {
		AssociationKeyMetadata associationKeyMetadata = ( (OgmCollectionPersister) collectionPersister ).getAssociationKeyMetadata();
		IgniteCache<Object, BinaryObject> associationCache = getAssociationCache( sessionFactory, associationKeyMetadata );
		if ( !processedCaches.contains( associationCache ) ) {
			asscociationCount += associationCache.size();
			processedCaches.add( associationCache );
		}
	}

	return asscociationCount;
}
 

import java.util.Collections; //导入方法依赖的package包/类
@Override
public boolean updateIndex(Entity entity, Long deviceKey) {
    Collection<Long> devices = null;

    IndexedEntity ie = new IndexedEntity(keyFields, entity);
    if (!ie.hasNonNullKeys()) return false;

    devices = index.get(ie);
    if (devices == null) {
        Map<Long,Boolean> chm = new ConcurrentHashMap<Long,Boolean>();
        devices = Collections.newSetFromMap(chm);
        Collection<Long> r = index.putIfAbsent(ie, devices);
        if (r != null)
            devices = r;
    }
    
    devices.add(deviceKey);
    return true;
}
 

import java.util.Collections; //导入方法依赖的package包/类
public void beforeDeleteNodePerson(NodeRef personNodeRef)
{
    String userId = (String)nodeService.getProperty(personNodeRef, ContentModel.PROP_USERNAME);
    //MNT-9104 If username contains uppercase letters the action of joining a site will not be displayed in "My activities" 
    if (! userNamesAreCaseSensitive)
    {
        userId = userId.toLowerCase();
    }
    Set<String> deletedUserIds = (Set<String>)AlfrescoTransactionSupport.getResource(KEY_DELETED_USER_IDS);
    if (deletedUserIds == null)
    {
        deletedUserIds = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>()); // Java 6
        AlfrescoTransactionSupport.bindResource(KEY_DELETED_USER_IDS, deletedUserIds);
    }
    
    deletedUserIds.add(userId);
    
    AlfrescoTransactionSupport.bindListener(deletePersonTransactionListener);
}
 

import java.util.Collections; //导入方法依赖的package包/类
private void registerAuthenticatedSession(WsSession wsSession,
        String httpSessionId) {
    Set<WsSession> wsSessions = authenticatedSessions.get(httpSessionId);
    if (wsSessions == null) {
        wsSessions = Collections.newSetFromMap(
                 new ConcurrentHashMap<WsSession,Boolean>());
         authenticatedSessions.putIfAbsent(httpSessionId, wsSessions);
         wsSessions = authenticatedSessions.get(httpSessionId);
    }
    wsSessions.add(wsSession);
}
 

import java.util.Collections; //导入方法依赖的package包/类
BlockPoolSliceStorage(int namespaceID, String bpID, long cTime,
    String clusterId) {
  super(NodeType.DATA_NODE);
  this.namespaceID = namespaceID;
  this.blockpoolID = bpID;
  this.cTime = cTime;
  this.clusterID = clusterId;
  storagesWithRollingUpgradeMarker = Collections.newSetFromMap(
      new ConcurrentHashMap<String, Boolean>());
  storagesWithoutRollingUpgradeMarker = Collections.newSetFromMap(
      new ConcurrentHashMap<String, Boolean>());
}
 

import java.util.Collections; //导入方法依赖的package包/类
/**
 * Construct a new instance of CustomObjectInputStream with filtering of
 * deserialized classes.
 *
 * @param stream The input stream we will read from
 * @param classLoader The class loader used to instantiate objects
 * @param log The logger to use to report any issues. It may only be null if
 *            the filterMode does not require logging
 * @param allowedClassNamePattern The regular expression to use to filter
 *                                deserialized classes. The fully qualified
 *                                class name must match this pattern for
 *                                deserialization to be allowed if filtering
 *                                is enabled.
 * @param warnOnFailure Should any failures be logged?
 *
 * @exception IOException if an input/output error occurs
 */
public CustomObjectInputStream(InputStream stream, ClassLoader classLoader,
        Log log, Pattern allowedClassNamePattern, boolean warnOnFailure)
        throws IOException {
    super(stream);
    if (log == null && allowedClassNamePattern != null && warnOnFailure) {
        throw new IllegalArgumentException(
                sm.getString("customObjectInputStream.logRequired"));
    }
    this.classLoader = classLoader;
    this.log = log;
    this.allowedClassNamePattern = allowedClassNamePattern;
    if (allowedClassNamePattern == null) {
        this.allowedClassNameFilter = null;
    } else {
        this.allowedClassNameFilter = allowedClassNamePattern.toString();
    }
    this.warnOnFailure = warnOnFailure;

    Set<String> reportedClasses;
    synchronized (reportedClassCache) {
        reportedClasses = reportedClassCache.get(classLoader);
        if (reportedClasses == null) {
            reportedClasses = Collections.newSetFromMap(new ConcurrentHashMap<String,Boolean>());
            reportedClassCache.put(classLoader, reportedClasses);
        }
    }
    this.reportedClasses = reportedClasses;
}
 

import java.util.Collections; //导入方法依赖的package包/类
private static <T> void sanitizeMatches(Map<T, T> matches) {
	Set<T> matched = Collections.newSetFromMap(new IdentityHashMap<>(matches.size()));
	Set<T> conflictingMatches = Collections.newSetFromMap(new IdentityHashMap<>());

	for (T cls : matches.values()) {
		if (!matched.add(cls)) {
			conflictingMatches.add(cls);
		}
	}

	if (!conflictingMatches.isEmpty()) {
		matches.values().removeAll(conflictingMatches);
	}
}
 

import java.util.Collections; //导入方法依赖的package包/类
@Override
public void classPathsChange(AbstractClassPathProvider.ClassPathsChangeEvent event) {
    final Map<String,Set<ClassPath>> snapshot = new HashMap<>();
    for (String cpType : event.getChangedClassPathTypes()) {
        if (classPathTypes.contains(cpType)) {
            final ClassPath[] cps = cpProvider.getProjectClassPaths(cpType);
            final Set<ClassPath> newCps = Collections.newSetFromMap(new IdentityHashMap<>());
            Collections.addAll(newCps, cps);
            snapshot.put(cpType, newCps);
        }
    }
    if (!snapshot.isEmpty()) {
        updateClassPathCache(snapshot);
    }
}
 

import java.util.Collections; //导入方法依赖的package包/类
@Override
public long getNumberOfEntities(SessionFactory sessionFactory) {
	int entityCount = 0;
	Set<IgniteCache<?, ?>> processedCaches = Collections.newSetFromMap( new IdentityHashMap<IgniteCache<?, ?>, Boolean>() );
	for ( EntityPersister entityPersister : ( (SessionFactoryImplementor) sessionFactory ).getEntityPersisters().values() ) {
		IgniteCache<?, ?> entityCache = getEntityCache( sessionFactory, ( (OgmEntityPersister) entityPersister ).getEntityKeyMetadata() );
		if ( !processedCaches.contains( entityCache ) ) {
			entityCount += entityCache.size( CachePeekMode.ALL );
			processedCaches.add( entityCache );
		}
	}
	return entityCount;
}
 

import java.util.Collections; //导入方法依赖的package包/类
@Override
public Set<? extends Document> getActiveDocuments() {
    final Set<Document> res = Collections.newSetFromMap(new IdentityHashMap<Document, Boolean>());
    for (JTextComponent jtc : EditorRegistry.componentList()) {
        final Document doc = jtc.getDocument();
        if (doc != null) {
            res.add(doc);
        }
    }
    return res;
}
 

import java.util.Collections; //导入方法依赖的package包/类
/**
 * Get the set of parameters marked final.
 *
 * @return final parameter set.
 */
public Set<String> getFinalParameters() {
  Set<String> setFinalParams = Collections.newSetFromMap(
      new ConcurrentHashMap<String, Boolean>());
  setFinalParams.addAll(finalParameters);
  return setFinalParams;
}
 

import java.util.Collections; //导入方法依赖的package包/类
public Groups(Configuration conf, final Timer timer) {
  impl = 
    ReflectionUtils.newInstance(
        conf.getClass(CommonConfigurationKeys.HADOOP_SECURITY_GROUP_MAPPING, 
                      ShellBasedUnixGroupsMapping.class, 
                      GroupMappingServiceProvider.class), 
        conf);

  cacheTimeout = 
    conf.getLong(CommonConfigurationKeys.HADOOP_SECURITY_GROUPS_CACHE_SECS, 
        CommonConfigurationKeys.HADOOP_SECURITY_GROUPS_CACHE_SECS_DEFAULT) * 1000;
  negativeCacheTimeout =
    conf.getLong(CommonConfigurationKeys.HADOOP_SECURITY_GROUPS_NEGATIVE_CACHE_SECS,
        CommonConfigurationKeys.HADOOP_SECURITY_GROUPS_NEGATIVE_CACHE_SECS_DEFAULT) * 1000;
  warningDeltaMs =
    conf.getLong(CommonConfigurationKeys.HADOOP_SECURITY_GROUPS_CACHE_WARN_AFTER_MS,
      CommonConfigurationKeys.HADOOP_SECURITY_GROUPS_CACHE_WARN_AFTER_MS_DEFAULT);
  staticUserToGroupsMap = parseStaticMapping(conf);

  this.timer = timer;
  this.cache = CacheBuilder.newBuilder()
    .refreshAfterWrite(cacheTimeout, TimeUnit.MILLISECONDS)
    .ticker(new TimerToTickerAdapter(timer))
    .expireAfterWrite(10 * cacheTimeout, TimeUnit.MILLISECONDS)
    .build(new GroupCacheLoader());

  if(negativeCacheTimeout > 0) {
    Cache<String, Boolean> tempMap = CacheBuilder.newBuilder()
      .expireAfterWrite(negativeCacheTimeout, TimeUnit.MILLISECONDS)
      .ticker(new TimerToTickerAdapter(timer))
      .build();
    negativeCache = Collections.newSetFromMap(tempMap.asMap());
  }

  if(LOG.isDebugEnabled())
    LOG.debug("Group mapping impl=" + impl.getClass().getName() + 
        "; cacheTimeout=" + cacheTimeout + "; warningDeltaMs=" +
        warningDeltaMs);
}
 

import java.util.Collections; //导入方法依赖的package包/类
/** 
 * A new configuration with the same settings cloned from another.
 * 
 * @param other the configuration from which to clone settings.
 */
@SuppressWarnings("unchecked")
public Configuration(Configuration other) {
 this.resources = (ArrayList<Resource>) other.resources.clone();
 synchronized(other) {
   if (other.properties != null) {
     this.properties = (Properties)other.properties.clone();
   }

   if (other.overlay!=null) {
     this.overlay = (Properties)other.overlay.clone();
   }

   this.updatingResource = new ConcurrentHashMap<String, String[]>(
       other.updatingResource);
   this.finalParameters = Collections.newSetFromMap(
       new ConcurrentHashMap<String, Boolean>());
   this.finalParameters.addAll(other.finalParameters);
 }
 
  synchronized(Configuration.class) {
    REGISTRY.put(this, null);
  }
  this.classLoader = other.classLoader;
  this.loadDefaults = other.loadDefaults;
  setQuietMode(other.getQuietMode());
}