Java 类java.util.LinkedHashSet 实例源码

public QuerySpec withQueryFilters(QueryFilter... queryFilters) {
    if (queryFilters == null) {
        this.queryFilters = null;
    } else {
        Set<String> names = new LinkedHashSet<String>();
        for (QueryFilter e : queryFilters) {
            names.add(e.getAttribute());
        }
        if (names.size() != queryFilters.length) {
            throw new IllegalArgumentException(
                    "attribute names must not duplicate in the list of query filters");
        }
        this.queryFilters = Arrays.asList(queryFilters);
    }
    return this;
}

protected T withCollectionParam(final String name, final Object value) {
    // Sanity test, if we got passed null, we should remove the collection
    if (value == null) {
        // This should remove it.
        return setParam(name, null);
    }

    // Sanity test, if we got passed a collection, we should handle it gracefully.
    if (value instanceof Collection) {
        return withCollectionParams(name, (Collection) value);
    }

    Collection<Object> existingValues = getParam(name);
    if (existingValues == null) {
        // Using linked hash set to preserve ordering.
        existingValues = new LinkedHashSet<>();
    }

    existingValues.add(value);

    return setParam(name, existingValues);
}

/**
 * Calculates the top event of the {@link BDD} based on a functionTransformer that delivers for each variable
 * {@code T} a double value.
 * 
 * @param <T>
 *            the type of variable
 * @param bdd
 *            the bdd
 * @param transformer
 *            the transformer that returns a double value for each variable
 * @return the top event of the bdd
 */
public static <T> double calculateTop(BDD<T> bdd, Transformer<T, Double> transformer) {
    if (bdd.isOne()) {
        return 1.0;
    }
    if (bdd.isZero()) {
        return 0.0;
    }

    Set<BDD<T>> upSort = new LinkedHashSet<>();
    traverseBDD(bdd, upSort);
    double top = evaluate(bdd, transformer, upSort);
    for (BDD<T> ups : upSort) {
        ups.free();
    }
    return top;
}

@Override
public Set<NitriteId> apply(final NitriteMap<NitriteId, Document> documentMap) {
    Set<NitriteId> result = new LinkedHashSet<>();
    ExecutorService executorService = nitriteService.getNitriteContext().getWorkerPool();

    try {
        List<Callable<Set<NitriteId>>> tasks = createTasks(filters, documentMap);

        List<Future<Set<NitriteId>>> futures = executorService.invokeAll(tasks);
        for (Future<Set<NitriteId>> future : futures) {
            Set<NitriteId> nitriteIds = future.get();
            if (nitriteIds != null) {
                result.addAll(nitriteIds);
            }
        }
    } catch (FilterException fe) {
        throw fe;
    } catch (Throwable t) {
        throw new FilterException(INVALID_OR_FILTER, t);
    }

    return result;
}

private static List<Vector3> doFindVector3s(final Scene scene) {
    final Set<Vector3> vector3s = new LinkedHashSet<>();

    for(final Shape shape : scene.getShapes()) {
        if(shape instanceof Plane) {
            final Plane plane = Plane.class.cast(shape);

            final Vector3 surfaceNormal = plane.getSurfaceNormal();

            vector3s.add(surfaceNormal);
        } else if(shape instanceof Triangle) {
            final Triangle triangle = Triangle.class.cast(shape);

            final Vector3 a = triangle.getA().getNormal();
            final Vector3 b = triangle.getB().getNormal();
            final Vector3 c = triangle.getC().getNormal();

            vector3s.add(a);
            vector3s.add(b);
            vector3s.add(c);
        }
    }

    return new ArrayList<>(vector3s);
}

@Test
public void zrangeByLex() {
  jedis.zadd("foo", 1, "aa");
  jedis.zadd("foo", 1, "c");
  jedis.zadd("foo", 1, "bb");
  jedis.zadd("foo", 1, "d");

  Set<String> expected = new LinkedHashSet<String>();
  expected.add("bb");
  expected.add("c");

  // exclusive aa ~ inclusive c
  assertEquals(expected, jedis.zrangeByLex("foo", "(aa", "[c"));

  expected.clear();
  expected.add("bb");
  expected.add("c");

  // with LIMIT
  assertEquals(expected, jedis.zrangeByLex("foo", "-", "+", 1, 2));
}

/**
 * Get child users of this group
 * @param paging Paging object with max number to return, and items to skip
 * @param sortBy What to sort on (authorityName, shortName or displayName)
 */
public ScriptUser[] getChildUsers(ScriptPagingDetails paging, String sortBy)
{
    if (childUsers == null)
    {
        Set<String> children = getChildNamesOfType(AuthorityType.USER);
        Set<ScriptUser> users = new LinkedHashSet<ScriptUser>();
        for (String authority : children)
        {
            ScriptUser user = new ScriptUser(authority, null, serviceRegistry, this.scope);
            users.add(user);
        }
        childUsers = users.toArray(new ScriptUser[users.size()]);
    }
    return makePagedAuthority(paging, sortBy, childUsers);
}

/**
 * Returns the AlloyType corresponding to the given sig; create an AlloyType
 * for it if none existed before.
 */
private void sigMETA(SubsetSig s) throws Err {
    AlloyAtom atom;
    AlloyType type = sig2type.get(s);
    if (type != null)
        return;
    type = makeType(s.label, s.isOne != null, s.isAbstract != null, false, s.isPrivate != null, s.isMeta != null,
            s.isEnum != null);
    atom = new AlloyAtom(type, Integer.MAX_VALUE, s.label);
    atom2sets.put(atom, new LinkedHashSet<AlloySet>());
    sig2atom.put(s, atom);
    sig2type.put(s, type);
    ts.put(type, AlloyType.SET);
    for (Sig p : ((SubsetSig) s).parents) {
        if (p instanceof SubsetSig)
            sigMETA((SubsetSig) p);
        else
            sigMETA((PrimSig) p);
        ins.add(new AlloyTuple(atom, sig2atom.get(p)));
    }
}

private ClassPath getToolingImpl() {
    if (!gradleHomeDir.exists()) {
        throw new IllegalArgumentException(String.format("The specified %s does not exist.", locationDisplayName));
    }
    if (!gradleHomeDir.isDirectory()) {
        throw new IllegalArgumentException(String.format("The specified %s is not a directory.", locationDisplayName));
    }
    File libDir = new File(gradleHomeDir, "lib");
    if (!libDir.isDirectory()) {
        throw new IllegalArgumentException(String.format("The specified %s does not appear to contain a Gradle distribution.", locationDisplayName));
    }
    LinkedHashSet<File> files = new LinkedHashSet<File>();
    for (File file : libDir.listFiles()) {
        if (hasExtension(file, ".jar")) {
            files.add(file);
        }
    }
    return new DefaultClassPath(files);
}

/** Returns every top-level user type that is itself visible or has a visible subtype.
 * @param vizState
 */
static Set<AlloyType> partiallyVisibleUserTopLevelTypes(final VizState vizState) {
   final AlloyModel model = vizState.getOriginalModel();
   final Set<AlloyType> visibleUserTypes = visibleUserTypes(vizState);
   //final Set<AlloyType> topLevelTypes = topLevelTypes(vizState);

   final Set<AlloyType> result = new LinkedHashSet<AlloyType>();

   for (final AlloyType t : visibleUserTypes) {
      if (visibleUserTypes.contains(t)) {
         result.add(model.getTopmostSuperType(t));
      }
   }

   return Collections.unmodifiableSet(result);
}

/**
 * Stores the Array in static for username + connectionId
 * 
 * @param array
 *            the Array to store
 */
public void put(Array array) {

    debug("Creating an array for user: " + connectionKey);
    if (array == null) {
        throw new IllegalArgumentException("array is null!");
    }

    Set<Array> arraySet = arrayMap.get(connectionKey);
    if (arraySet == null) {
        arraySet = new LinkedHashSet<Array>();
    }

    arraySet.add(array);
    arrayMap.put(connectionKey, arraySet);

}

/**
 * Makes a deep copy (for security)
 */
public Base deepClone() {
    Base newBase = new Base(getPosition().deepCopy(), teamName, team.deepCopy(), isHomeBase);

    newBase.energy = energy;
    newBase.setAlive(isAlive);
    newBase.id = id;
    newBase.maxEnergy = maxEnergy;
    newBase.currentPowerups = new LinkedHashSet<SpaceSettlersPowerupEnum>(currentPowerups);
    newBase.weaponCapacity = weaponCapacity;
    newBase.healingIncrement = healingIncrement;
    newBase.resources = new ResourcePile();
    newBase.resources.add(resources);
    newBase.numFlags = numFlags;
    return newBase;
}

/**
 * Return an unordered set all the foreign key ancestor tables for the given table
 * @param catalog_tbl
 */
public Collection<Table> getAncestors(Table catalog_tbl) {
    Database catalog_db = (Database) catalog_tbl.getParent();
    Set<Table> ret = new LinkedHashSet<Table>();
    String key = CatalogKey.createKey(catalog_tbl);
    for (String ancestor_key : this.table_ancestors.get(key)) {
        // If this table is missing from the catalog, then we want to stop
        // the ancestor list
        Table ancestor_tbl = CatalogKey.getFromKey(catalog_db, ancestor_key, Table.class);
        if (ancestor_tbl == null)
            break;
        // Otherwise, add it to our list
        ret.add(ancestor_tbl);
    } // FOR
    return (ret);
}

public Set<String> getAndRemZRange(String key, long score) {
  Jedis jedis = null;
  try {
    jedis = pool.getResource();
    Transaction trans = jedis.multi();
    trans.zrangeByScore(key.getBytes(), MIN_INF, SafeEncoder.encode(String.valueOf(score)));
    trans.zremrangeByScore(key.getBytes(), MIN_INF, SafeEncoder.encode(String.valueOf(score)));
    List<Object> response = trans.exec();
    Set<byte[]> data = (Set<byte[]>) response.get(0);
    Set<String> members = new LinkedHashSet<>(data.size());
    for (byte[] d : data) {
      members.add(new String(d));
    }
    pool.returnResource(jedis);
    return members;
  } catch (Exception e) {
    LOGGER.warn("Failed to get zrem keys from cache {0}:{1}", key, score, e);
    pool.returnBrokenResource(jedis);
    throw e;
  }
}

private synchronized Collection<AntLogger> getInterestedLoggersByTask(String task) {
    Collection<AntLogger> c = interestedLoggersByTask.get(task);
    if (c == null) {
        c = new LinkedHashSet<AntLogger>(interestedLoggers.size());
        interestedLoggersByTask.put(task, c);
        for (AntLogger l : interestedLoggers) {
            String[] tasks = l.interestedInTasks(thisSession);
            if (tasks == AntLogger.ALL_TASKS ||
                    (task != null && Arrays.asList(tasks).contains(task)) ||
                    (task == null && tasks == AntLogger.NO_TASKS)) {
                c.add(l);
            }
        }
        LOG.log(Level.FINEST, "getInterestedLoggersByTask: task={0} loggers={1}", new Object[] {task, c});
    }
    return c;
}

@SuppressWarnings("unchecked")
public Set<String> build(Object data) {
  if (null == data) {
    return null;
  }
  List<byte[]> l = (List<byte[]>) data;
  final Set<String> result = new LinkedHashSet<String>(l.size());
  for (final byte[] barray : l) {
    if (barray == null) {
      result.add(null);
    } else {
      result.add(SafeEncoder.encode(barray));
    }
  }
  return result;
}

public void unregisterThrower(Class<?> interfaceClass, IEventThrower<?> thrower, boolean keepSubscribers){
    synchronized (EVENT_THROWERS) {
        if(EVENT_THROWERS.containsKey(interfaceClass)){
            LinkedHashSet<IEventThrower<?>> list = EVENT_THROWERS.get(interfaceClass);
            if(keepSubscribers){
                Queue<Object> toKeep = new ArrayDeque<>();
                Iterator<?> subscribers = thrower.getSubscribers();
                while(subscribers.hasNext()){
                    Object listener = subscribers.next();
                    toKeep.add(listener);
                }
                if(!QUEUED_LISTENERS.containsKey(interfaceClass)){
                    QUEUED_LISTENERS.put(interfaceClass, toKeep);
                }
            }else{
                thrower.clearSubscribers();
            }
            list.remove(thrower);
            if(list.isEmpty()){
                EVENT_THROWERS.remove(interfaceClass);  
            }
        }
    }
}

private void loadAll() {
    mFiles = new LinkedHashSet<String>();
    mDirs = new LinkedHashMap<String, AbstractDirectory>();

    File[] files = getDir().listFiles();
    for (int i = 0; i < files.length; i++) {
        File file = files[i];
        if (file.isFile()) {
            mFiles.add(file.getName());
        } else {
            // IMPOSSIBLE_EXCEPTION
            try {
                mDirs.put(file.getName(), new FileDirectory(file));
            } catch (DirectoryException e) {}
        }
    }
}

/**
 * Stores the Savepoint in static for username + connectionId
 * 
 * @param savepoint
 *            the Savepoint to store
 */
public void put(Savepoint savepoint) {

    debug("Creating a Savepoint for user: " + connectionKey);
    if (savepoint == null) {
        throw new IllegalArgumentException("savepoint is null!");
    }

    Set<Savepoint> savepointSet = savepointMap.get(connectionKey);
    if (savepointSet == null) {
        savepointSet = new LinkedHashSet<Savepoint>();
    }

    savepointSet.add(savepoint);
    savepointMap.put(connectionKey, savepointSet);
}

/**
 * Returns the total number of annotations.
 */
int countAnnotations() {
    Set<Annotation> set = new LinkedHashSet<Annotation>();
    for (Layer layer : layers.values())
        set.addAll(layer);
    return set.size();
}

List getAopTypesValue(ConditionContext context){
    String aopTypesKey = DruidStatProperties.DRUID_STAT_PREFIX+".aop-types";
    Set<String> keySet = new LinkedHashSet<String>();
    for (int i = 0; i <3 ; i++) {
        String field = context.getEnvironment().getProperty(aopTypesKey+"["+i+"]", String.class);
        if (!StringUtils.isEmpty(field))
            keySet.add(field.toLowerCase());
    }
    if (keySet.size() > 0 ){
        return new ArrayList<String>(keySet);
    }else {
        return new ArrayList<String>();
    }

}

/**
 * Prunes the forest by making sure that every node is either
 * a root, or a child of exactly one parent.
 */
public void prune() {
    Collection<LayoutNode> remaining = one();
    // Add real roots one by one
    List<LayoutNode> roots = new ArrayList<>();
    while (!remaining.isEmpty()) {
        Iterator<LayoutNode> remainingIter = remaining.iterator();
        LayoutNode root = remainingIter.next();
        roots.add(root);
        remainingIter.remove();
        // compute reachable children and take them from remaining candidate roots
        // also adjust the branch sets of the reachable leaves
        Set<LayoutNode> children = new LinkedHashSet<>();
        children.add(root);
        while (!children.isEmpty()) {
            Iterator<LayoutNode> childIter = children.iterator();
            LayoutNode child = childIter.next();
            childIter.remove();
            // look up the next generation
            Set<LayoutNode> branches = getBranches(child);
            // restrict to remaining layoutables
            branches.retainAll(remaining);
            children.addAll(branches);
            // remove the new branches from the remaining candidate roots
            remaining.removeAll(branches);
        }
    }
    setOne(roots);
}

/**
 * 将字符串词性转为Enum词性
 * @param name 词性名称
 * @param customNatureCollector 一个收集集合
 * @return 转换结果
 */
public static Nature convertStringToNature(String name, LinkedHashSet<Nature> customNatureCollector)
{
    try
    {
        return Nature.valueOf(name);
    }
    catch (Exception e)
    {
        Nature nature = CustomNatureUtility.addNature(name);
        if (customNatureCollector != null) customNatureCollector.add(nature);
        return nature;
    }
}

/**
 * Geef de waarde van betrokkenheid set.
 * @param soortBetrokkenheid soort betrokkenheid
 * @return betrokkenheid set
 */
public Set<Betrokkenheid> getBetrokkenheidSet(final SoortBetrokkenheid soortBetrokkenheid) {
    final Set<Betrokkenheid> result = new LinkedHashSet<>();
    for (final Betrokkenheid betrokkenheid : betrokkenheidSet) {
        if (soortBetrokkenheid.equals(betrokkenheid.getSoortBetrokkenheid())) {
            result.add(betrokkenheid);
        }
    }
    return result;
}

/**
 * 去重提取
 * 
 * @param memberList
 * @return
 */
private Set<String> formatEmailDuplicateRemoval(List<Map<String, String>> memberList) {

    Set<String> emails = new LinkedHashSet<String>();
    for (Map<String, String> map : memberList) {
        String emailList = map.get("emailList");
        String[] splits = emailList.split(",");
        for (int i = 0; i < splits.length; i++) {
            emails.add(splits[i]);
        }
    }

    return emails;
}

SymmInfo(int size) {
    this.parts = new LinkedHashSet<IntSet>();
    for (int i = 0, max = size; i < max; i++) {
        parts.add(Ints.singleton(i));
    }
    this.time = "t\\o";
    this.symms = "t\\o";
}

public CommandRegistry(ConsoleLogger logger, Command[] commands) {
    this.logger = logger;
    this.commands = new LinkedHashSet<>(asList(commands));
    this.commands.add(new ShowCommand(logger));
    this.commands.add(new ExitCommand(logger));
    this.commands.add(new ResetProgressionCommand(logger));
    this.commands.add(this);
}

private static Set<String> getModifiers(int flags, int[] modifierFlags, Kind t) {
    Set<String> s = new LinkedHashSet<>();
    for (int m: modifierFlags) {
        if ((flags & m) != 0)
            s.add(flagToModifier(m, t));
    }
    return s;
}

private static List<Surface> doFindSurfaces(final Scene scene) {
    final Set<Surface> surfaces = new LinkedHashSet<>();

    for(final Shape shape : scene.getShapes()) {
        final Surface surface = shape.getSurface();

        surfaces.add(surface);
    }

    return new ArrayList<>(surfaces);
}

/**
 * Obtain a resource object for the given name and type through autowiring
 * based on the given factory.
 * @param factory the factory to autowire against
 * @param element the descriptor for the annotated field/method
 * @param requestingBeanName the name of the requesting bean
 * @return the resource object (never {@code null})
 * @throws BeansException if we failed to obtain the target resource
 */
protected Object autowireResource(BeanFactory factory, LookupElement element, String requestingBeanName)
        throws BeansException {

    Object resource;
    Set<String> autowiredBeanNames;
    String name = element.name;

    if (this.fallbackToDefaultTypeMatch && element.isDefaultName &&
            factory instanceof AutowireCapableBeanFactory && !factory.containsBean(name)) {
        autowiredBeanNames = new LinkedHashSet<String>();
        resource = ((AutowireCapableBeanFactory) factory).resolveDependency(
                element.getDependencyDescriptor(), requestingBeanName, autowiredBeanNames, null);
    }
    else {
        resource = factory.getBean(name, element.lookupType);
        autowiredBeanNames = Collections.singleton(name);
    }

    if (factory instanceof ConfigurableBeanFactory) {
        ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
        for (String autowiredBeanName : autowiredBeanNames) {
            if (beanFactory.containsBean(autowiredBeanName)) {
                beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);
            }
        }
    }

    return resource;
}

private void setTagApps(List<AppAndTag> list, AppTopic topic) {
    Set<TagApps> tagApps = new LinkedHashSet<TagApps>();
    for (AppAndTag appAndTag : list) {
        if (topic.getId() == appAndTag.getTag().getId()) {
            tagApps.add(new TagApps(appAndTag.getId(), appAndTag.getRank(), "", appAndTag.getApp()));
        }
    }
    topic.setTagApps(tagApps);
}

/** Returns all of the top-level types in the original model.
 * @param vizState
 */
static Set<AlloyType> topLevelTypes(final VizState vizState) {
   final Set<AlloyType> result = new LinkedHashSet<AlloyType>();
   final AlloyModel model = vizState.getOriginalModel();
   for (final AlloyType t : model.getTypes()) {
      if (vizState.isTopLevel(t)) {
         result.add(t);
      }
   }
   return Collections.unmodifiableSet(result);
}

@Test
public void zrangeWithScores() {
  jedis.zadd("foo", 1d, "a");
  jedis.zadd("foo", 10d, "b");
  jedis.zadd("foo", 0.1d, "c");
  jedis.zadd("foo", 2d, "a");

  Set<Tuple> expected = new LinkedHashSet<Tuple>();
  expected.add(new Tuple("c", 0.1d));
  expected.add(new Tuple("a", 2d));

  Set<Tuple> range = jedis.zrangeWithScores("foo", 0, 1);
  assertEquals(expected, range);

  expected.add(new Tuple("b", 10d));
  range = jedis.zrangeWithScores("foo", 0, 100);
  assertEquals(expected, range);

  // Binary
  jedis.zadd(bfoo, 1d, ba);
  jedis.zadd(bfoo, 10d, bb);
  jedis.zadd(bfoo, 0.1d, bc);
  jedis.zadd(bfoo, 2d, ba);

  Set<Tuple> bexpected = new LinkedHashSet<Tuple>();
  bexpected.add(new Tuple(bc, 0.1d));
  bexpected.add(new Tuple(ba, 2d));

  Set<Tuple> brange = jedis.zrangeWithScores(bfoo, 0, 1);
  assertEquals(bexpected, brange);

  bexpected.add(new Tuple(bb, 10d));
  brange = jedis.zrangeWithScores(bfoo, 0, 100);
  assertEquals(bexpected, brange);

}

public SearchLayer addIgnored(String first, String... rest) {
  if (this.ignored == null) {
    this.ignored = new LinkedHashSet<>();
  }
  this.ignored.addAll(Lists.asList(first, rest));
  return this;
}

Set<File> getAllFiles () {
    if (allFiles == null) {
        allFiles = new LinkedHashSet<File> ();
        addFiles (loadPresistentState ());
    }
    return allFiles;
}

private LinkedHashSet<String> getPersistedCache() {
  String serialized = prefs.getString(EMOJI_LRU_PREFERENCE, "[]");
  try {
    CollectionType collectionType = TypeFactory.defaultInstance()
                                               .constructCollectionType(LinkedHashSet.class, String.class);
    return JsonUtils.getMapper().readValue(serialized, collectionType);
  } catch (IOException e) {
    Log.w(TAG, e);
    return new LinkedHashSet<>();
  }
}

private static Collection<String> createRequestSubprotocols(
        Collection<String> subprotocols)
{
    LinkedHashSet<String> sp = new LinkedHashSet<>(subprotocols.size(), 1);
    for (String s : subprotocols) {
        if (s.trim().isEmpty() || !isValidName(s)) {
            throw illegal("Bad subprotocol syntax: " + s);
        }
        if (!sp.add(s)) {
            throw illegal("Duplicating subprotocol: " + s);
        }
    }
    return Collections.unmodifiableCollection(sp);
}

private String[] toReversePrimitiveArray(@NonNull LinkedHashSet<String> emojiSet) {
  String[] emojis = new String[emojiSet.size()];
  int i = emojiSet.size() - 1;
  for (String emoji : emojiSet) {
    emojis[i--] = emoji;
  }
  return emojis;
}

@Test
public void zremrangeByScore() {
  jedis.zadd("foo", 1d, "a");
  jedis.zadd("foo", 10d, "b");
  jedis.zadd("foo", 0.1d, "c");
  jedis.zadd("foo", 2d, "a");

  long result = jedis.zremrangeByScore("foo", 0, 2);

  assertEquals(2, result);

  Set<String> expected = new LinkedHashSet<String>();
  expected.add("b");

  assertEquals(expected, jedis.zrange("foo", 0, 100));

  // Binary
  jedis.zadd(bfoo, 1d, ba);
  jedis.zadd(bfoo, 10d, bb);
  jedis.zadd(bfoo, 0.1d, bc);
  jedis.zadd(bfoo, 2d, ba);

  long bresult = jedis.zremrangeByScore(bfoo, 0, 2);

  assertEquals(2, bresult);

  Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
  bexpected.add(bb);

  assertByteArraySetEquals(bexpected, jedis.zrange(bfoo, 0, 100));
}

/**
 * Retrieves all dependencies with given kind(s).
 */
protected Set<Node> getDependencies(DependencyKind... depKinds) {
    Set<Node> buf = new LinkedHashSet<Node>();
    for (DependencyKind dk : depKinds) {
        Set<Node> depsByKind = deps.get(dk);
        if (depsByKind != null) {
            buf.addAll(depsByKind);
        }
    }
    return buf;
}