Java Examples for java.util.Map.Entry

public static CodegenResult genMap(String cacheKey, Class clazz, Type[] typeArgs) {
    boolean isCollectionValueNullable = true;
    if (cacheKey.endsWith("__value_not_nullable")) {
        isCollectionValueNullable = false;
    }
    Type keyType = String.class;
    Type valueType = Object.class;
    if (typeArgs.length == 0) {
    // default to Map<String, Object>
    } else if (typeArgs.length == 2) {
        keyType = typeArgs[0];
        valueType = typeArgs[1];
    } else {
        throw new IllegalArgumentException("can not bind to generic collection without argument types, " + "try syntax like TypeLiteral<Map<String, String>>{}");
    }
    if (keyType != String.class) {
        throw new IllegalArgumentException("map key must be String");
    }
    CodegenResult ctx = new CodegenResult();
    ctx.append("public static void encode_(java.lang.Object obj, com.jsoniter.output.JsonStream stream) throws java.io.IOException {");
    ctx.append("if (obj == null) { stream.writeNull(); return; }");
    ctx.append("java.util.Map map = (java.util.Map)obj;");
    ctx.append("java.util.Iterator iter = map.entrySet().iterator();");
    ctx.append("if(!iter.hasNext()) { return; }");
    ctx.append("java.util.Map.Entry entry = (java.util.Map.Entry)iter.next();");
    ctx.buffer('{');
    ctx.append("stream.writeVal((String)entry.getKey());");
    ctx.buffer(':');
    if (isCollectionValueNullable) {
        ctx.append("if (entry.getValue() == null) { stream.writeNull(); } else {");
        CodegenImplNative.genWriteOp(ctx, "entry.getValue()", valueType, true);
        ctx.append("}");
    } else {
        CodegenImplNative.genWriteOp(ctx, "entry.getValue()", valueType, false);
    }
    ctx.append("while(iter.hasNext()) {");
    ctx.append("entry = (java.util.Map.Entry)iter.next();");
    ctx.buffer(',');
    ctx.append("stream.writeObjectField((String)entry.getKey());");
    if (isCollectionValueNullable) {
        ctx.append("if (entry.getValue() == null) { stream.writeNull(); } else {");
        CodegenImplNative.genWriteOp(ctx, "entry.getValue()", valueType, true);
        ctx.append("}");
    } else {
        CodegenImplNative.genWriteOp(ctx, "entry.getValue()", valueType, false);
    }
    ctx.append("}");
    ctx.buffer('}');
    ctx.append("}");
    return ctx;
}

@Override
public Set<java.util.Map.Entry<List<W>, V>> entrySet() {
    return new AbstractSet<java.util.Map.Entry<List<W>, V>>() {

        @Override
        public Iterator<java.util.Map.Entry<List<W>, V>> iterator() {
            return iterableWrapper.iterator();
        }

        @Override
        public int size() {
            final long size = iterableWrapper.size();
            if (size > Integer.MAX_VALUE)
                Logger.warn(NgramsForOrderMapWrapper.class.getSimpleName() + " doesn't like maps with size greater than Integer.MAX_VALUE");
            return (int) size;
        }
    };
}

@Override
public String toString() {
    StringBuilder buffer = new StringBuilder();
    buffer.append("event{");
    buffer.append(name);
    if (aspects.size() > 0) {
        buffer.append(" aspects[");
        int i = 0;
        for (Entry<String, XmlAspectAnnotation> entry : aspects.entrySet()) {
            if (i++ > 0)
                buffer.append(", ");
            buffer.append(entry.getValue());
        }
        buffer.append("]");
    }
    buffer.append("}");
    return buffer.toString();
}

/**
   *
   */
@Test(groups = "simple")
public void printSystemProperties() {
    System.out.println("Properties");
    for (Entry<Object, Object> prop : System.getProperties().entrySet()) {
        System.out.println(prop.getKey() + ":" + prop.getValue());
    }
    System.out.println("Environment Variables");
    for (Entry<String, String> prop : System.getenv().entrySet()) {
        System.out.println(prop.getKey() + ":" + prop.getValue());
    }
}

@Override
public java.util.Map.Entry<K, V> next() {
    final java.util.Map.Entry<EqualityWrapper<K>, V> e = iterator.next();
    return new java.util.Map.Entry<K, V>() {

        @Override
        public K getKey() {
            return e.getKey().getT();
        }

        @Override
        public V getValue() {
            return e.getValue();
        }

        @Override
        public V setValue(V v) {
            return e.setValue(v);
        }
    };
}

public java.util.Map.Entry<String, Object> next() {
    final String name = names.next();
    final Object value = delegate.getAttribute(name);
    return new Entry<String, Object>() {

        public String getKey() {
            return name;
        }

        public Object getValue() {
            return value;
        }

        public Object setValue(Object value) {
            throw new UnsupportedOperationException("Not allowed to set an asset attribute value, asset is immutable");
        }
    };
}

public static void appendEnvAttr(Context context, Map map) {
    if (map != null) {
        if (d == null) {
            d = new JSONObject();
        }
        Iterator iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            java.util.Map.Entry entry = (java.util.Map.Entry) iterator.next();
            d.put((String) entry.getKey(), entry.getValue());
        }
    }
}

public boolean hasNext() {
    while (hashIterator.hasNext()) {
        java.util.Map.Entry entry = (java.util.Map.Entry) hashIterator.next();
        ValueCell valuecell = (ValueCell) entry.getValue();
        Object obj = null;
        if (valuecell == null || (obj = valuecell.get()) != null) {
            next = new Entry(entry, obj);
            return true;
        }
    }
    return false;
}

public boolean hasNext() {
    while (hashIterator.hasNext()) {
        java.util.Map.Entry entry = (java.util.Map.Entry) hashIterator.next();
        ValueCell valuecell = (ValueCell) entry.getValue();
        Object obj = null;
        if (valuecell == null || (obj = valuecell.get()) != null) {
            next = new Entry(entry, obj);
            return true;
        }
    }
    return false;
}

public boolean hasNext() {
    while (hashIterator.hasNext()) {
        java.util.Map.Entry entry = (java.util.Map.Entry) hashIterator.next();
        ValueCell valuecell = (ValueCell) entry.getValue();
        Object obj = null;
        if (valuecell == null || (obj = valuecell.get()) != null) {
            next = new Entry(entry, obj);
            return true;
        }
    }
    return false;
}

@Override
public WsdlMockResponse get(Object key) {
    MockResponse other = (MockResponse) key;
    WsdlMockResponse found = null;
    Set<java.util.Map.Entry<MockResponse, WsdlMockResponse>> entries = this.entrySet();
    for (java.util.Map.Entry<MockResponse, WsdlMockResponse> entry : entries) {
        if (entry.getKey().equals(other))
            found = entry.getValue();
    }
    return found;
}

@Override
protected void ExecuteVdsBrokerCommand() {
    mVmListReturn = getBroker().list();
    ProceedProxyReturnValue();
    java.util.HashMap<Guid, java.util.Map.Entry<VmDynamic, VmStatistics>> returnVMs = new java.util.HashMap<Guid, java.util.Map.Entry<VmDynamic, VmStatistics>>();
    for (// fix
    int idx = 0; // fix
    idx < mVmListReturn.mVmList.length; // fix
    ++idx) // GetLength(0)
    {
        VmDynamic dynamicData = VdsBrokerObjectsBuilder.buildVMDynamicDataFromList(mVmListReturn.mVmList[idx]);
        returnVMs.put(dynamicData.getId(), new KeyValuePairCompat<VmDynamic, VmStatistics>(dynamicData, null));
    }
    setReturnValue(returnVMs);
}

@Override
protected void doTransform(CtClass cc) throws Exception {
    CtMethod c = cc.getMethod("init", "(Ljava.util.Hashtable;)V");
    String h2hHookCode = "" + "List listEntryPath = new ArrayList();" + "Iterator iter = myProps.entrySet().iterator();" + "while (iter.hasNext()) {" + "   java.util.Map.Entry element = (java.util.Map.Entry) iter.next();" + "   String key = (String) element.getValue();" + "   Object obj = lookup(key);" + "   if (obj instanceof javax.jms.Queue) {" + "       javax.jms.Queue queueTmp = (Queue) obj;" + "       EntryPathData entry = new EntryPathData();" + "       entry.setMethodName(\"no-method\");" + "       entry.setClassName(\"queue-jms\");" + "       entry.setTypePath(TypePath.DYNAMIC);" + "       entry.setAudit(false);" + "       try {" + "           entry.setUri(queueTmp.getQueueName());" + "       } catch (JMSException e) {" + "           entry.setUri(\"queue\");" + "           e.printStackTrace();" + "       }" + "       listEntryPath.add(entry);" + "    }" + "}" + "CoreEngine.getInstance().getFramework(\"JMS_11_CTX\").receiveData(listEntryPath);";
    c.insertAfter(h2hHookCode);
}

public void test(HashMap hashmap, String s) {
    for (int i = 0; i < hashmap.size(); i++) {
        java.util.Map.Entry entry = (java.util.Map.Entry) hashmap.entrySet().toArray()[i];
        String s1 = (String) entry.getKey();
        if (s1.startsWith(s))
            actions.add(new Action(s1.substring(s.length()), s1));
    }
    tested = true;
}

/** Sets the delegatelist to a persistablelist */
protected void setDelegateEList(InternalEObject owner, EStructuralFeature feature, List<BasicEMap.Entry<K, V>> delegateORMList) {
    assert (owner.eClass().getFeatureID(feature) == featureID);
    // NOTE BEWARE: the delegateEList is a member of the superclass!
    delegateEList = createDelegateEList(owner, feature, delegateORMList);
    logString = "EMap with entry eclass: " + entryEClass.getName() + " of member " + feature.getName() + " owned by " + owner.getClass().getName() + " with delegate list " + delegateORMList.getClass().getName();
    log.debug("Created/reset elist " + logString);
    if (delegateORMList instanceof EList) {
        setLoaded(true);
    } else if (// already loaded lists are packaged in
    delegateORMList instanceof ArrayList) {
        // an elist
        setLoaded(delegateORMList.size() > 0);
    }
}

public RoleNodeMap toRoleNodeMap() {
    RoleNodeMap roleNodeMap = new RoleNodeMap();
    for (java.util.Map.Entry<String, RoleSet> nodeRoleEntry : entrySet()) {
        String node = nodeRoleEntry.getKey();
        RoleSet nodeRoles = nodeRoleEntry.getValue();
        for (String role : nodeRoles) {
            NodeSet roleNodes = roleNodeMap.get(role);
            if (roleNodes == null) {
                roleNodes = new NodeSet();
                roleNodeMap.put(role, roleNodes);
            }
            roleNodes.add(node);
        }
    }
    return roleNodeMap;
}

public String convert(Requirement req) throws IllegalArgumentException {
    StringBuilder builder = new StringBuilder();
    builder.append(req.getNamespace());
    for (Entry<String, String> directive : req.getDirectives().entrySet()) {
        builder.append(';').append(directive.getKey()).append(":='").append(directive.getValue()).append('\'');
    }
    for (Entry<String, Object> attribute : req.getAttributes().entrySet()) {
        builder.append(';').append(attribute.getKey()).append("='").append(attribute.getValue()).append('\'');
    }
    return builder.toString();
}

public String dumpAllThreads() {
    StringBuilder result = new StringBuilder();
    Map<Thread, StackTraceElement[]> m = Thread.getAllStackTraces();
    for (Entry<Thread, StackTraceElement[]> e : m.entrySet()) {
        if (e.getKey().isDaemon())
            result.append("Daemon ");
        result.append("Thread " + e.getKey() + "\n");
        for (StackTraceElement elm : e.getValue()) result.append("\t" + elm);
    }
    return result.toString();
}

public static MessageDecoder<?, ?> createMessageDecoder(JobConf conf, String topicName) {
    MessageDecoder<?, ?> decoder;
    try {
        decoder = (MessageDecoder<?, ?>) KafkaAvroMessageDecoder.class.newInstance();
        Properties props = new Properties();
        for (Entry<String, String> entry : conf) {
            props.put(entry.getKey(), entry.getValue());
        }
        decoder.init(props, topicName);
        return decoder;
    } catch (Exception e) {
        throw new MessageDecoderException(e);
    }
}

public static Matcher<Entry<RawOption, List<String>>> isLastOption() {
    return new TypeSafeMatcher<Entry<RawOption, List<String>>>() {

        @Override
        public void describeTo(final Description description) {
            description.appendText("the last option");
        }

        @Override
        protected boolean matchesSafely(final Entry<RawOption, List<String>> item) {
            return item.getKey().isLast();
        }
    };
}

@Test
public void getActions() {
    ActionLoader actionLoader = new RegexActionLoader();
    Reflect.set(actionLoader, "typeRegex", "li.people.action.*");
    Reflect.set(actionLoader, "methodRegex", ".*(list|add|save|edit|update|delete).*");
    Map<String, Action> actions = actionLoader.getActions();
    for (Entry<String, Action> entry : actions.entrySet()) {
        System.err.println(entry.getKey() + "\t" + entry.getValue().actionMethod);
    }
}

public static String cleanContentType(MimePart mp, String contentType) {
    String result = contentType;
    for (Entry<String, String> entry : CharsetUtility.getCharsetMap().entrySet()) {
        String template1 = "charset=" + entry.getKey();
        String template2 = "charset=\"" + entry.getKey();
        if (result.toLowerCase().contains(template1)) {
            result = result.replaceAll("(?i)" + template1, "charset=" + entry.getValue());
        } else if (result.toLowerCase().contains(template2)) {
            result = result.replaceAll("(?i)" + template2, "charset=\"" + entry.getValue());
        }
    }
    return result;
}

public void run() {
    String playerName;
    PlayerData playerData;
    for (Entry<String, PlayerData> entry : plugin.dataManager.getAll()) {
        playerName = entry.getKey();
        playerData = entry.getValue();
        if (playerData.lastLogoutTime > playerData.lastLoginTime && System.currentTimeMillis() - playerData.lastLoginTime > 3600000) {
            plugin.dataManager.unregisterPlayer(playerName);
        }
    }
}

public static String toEventMap(Map<String, Object> attributeMap) {
    Map<String, Object> eventMap = Maps.newHashMap();
    for (Entry<String, Object> entry : attributeMap.entrySet()) {
        if (entry.getKey().startsWith("on")) {
            String eventName = entry.getKey().substring(2) + RICHFACES_BOOTSTRAP_EVENT_NAMESPACE;
            eventMap.put(eventName, entry.getValue());
        }
    }
    return RenderKitUtils.toScriptArgs(eventMap);
}

public static void main(String[] args) throws Exception {
    String rrdFileName = args[0];
    RRDp rrd = new RRDp(".", null);
    CommandResult result = rrd.command(new String[] { "info", rrdFileName });
    System.out.println(result);
    HashMap<String, String> hm = result.getInfo();
    if (hm != null) {
        for (Entry<String, String> e : hm.entrySet()) {
            System.out.printf("%s:\t%s\n", e.getKey(), e.getValue());
        }
    }
}

@Override
public SearchResult run(RSClient data, HashMap<String, ClassGen> classes) {
    for (Entry<String, ClassGen> c : classes.entrySet()) {
        RSClass npcNode = data.getProperClass("NPCNode");
        //if(c.getValue()){
        ConstantPoolGen cpg = c.getValue().getConstantPool();
        for (Field f : c.getValue().getFields()) {
            if (f.isStatic() && f.getType().toString().equals(npcNode.className + "[]")) {
                data.addField("NPCNodes", c.getValue().getClassName() + '.' + f.getName());
                return SearchResult.Success;
            }
        }
    //}
    }
    return SearchResult.Failure;
}

@Override
public Iterator<java.util.Map.Entry<K, V>> iterator() {
    return new Iterator<java.util.Map.Entry<K, V>>() {

        private int mId = 0;

        @Override
        public boolean hasNext() {
            return mId < mKeys.length;
        }

        @Override
        public java.util.Map.Entry<K, V> next() {
            return new ArrayMapEntry(mId++);
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("No remove!");
        }
    };
}

public static <T> T findValue(Map target, String key) {
    Iterator<Entry> it = target.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry entry = it.next();
        Object value = entry.getValue();
        if (!entry.getKey().equals(key)) {
            if (Map.class.isAssignableFrom(value.getClass())) {
                Object ret = findValue((Map) value, key);
                if (ret != null) {
                    return (T) ret;
                }
            }
        } else {
            return (T) value;
        }
    }
    return null;
}

@Override
public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
    java.util.Set<java.util.Map.Entry<K, V>> set = new java.util.HashSet<java.util.Map.Entry<K, V>>() {

        private static final long serialVersionUID = 1L;

        /**
                 * {@inheritDoc}
                 */
        @Override
        public java.util.Iterator<java.util.Map.Entry<K, V>> iterator() {
            return (new JavaCompatibleIteratorWrapper<K, V>(map, super.iterator()));
        }
    };
    if (map.trie != null && map.trie.root != null) {
        PatriciaTrie.Node n = map.trie.root;
        levelOrder(n, "", set);
    }
    return set;
}

/**
   * @see Object#equals(Object)
   */
@SuppressWarnings("unchecked")
@Override
public boolean equals(final Object obj) {
    if (this == obj) {
        return true;
    }
    if (obj == null) {
        return false;
    }
    if (this.getClass() != obj.getClass()) {
        return false;
    }
    final Entry<V, K> other = (Entry<V, K>) obj;
    if (this.m_key == null) {
        if (other.m_key != null) {
            return false;
        }
    } else if (!this.m_key.equals(other.m_key)) {
        return false;
    }
    if (this.m_value == null) {
        if (other.m_value != null) {
            return false;
        }
    } else if (!this.m_value.equals(other.m_value)) {
        return false;
    }
    return true;
}

/*
	 * (non-Javadoc)
	 * 
	 * @see jef.common.AbstractMap#put(java.lang.Object, java.lang.Object)
	 */
@Override
public V put(K key, V value) {
    int index = -1;
    for (int i = 0; i < entries.size(); i++) {
        if (Objects.equal(entries.get(i).getKey(), key)) {
            index = i;
            break;
        }
    }
    if (index > -1) {
        entries.set(index, new jef.common.Entry<K, V>(key, value));
    } else {
        entries.add(new jef.common.Entry<K, V>(key, value));
    }
    return value;
}

/**
     * Removes the specified element from this set if it is present (optional
     * operation).
     * This method conforms to the {@link Set#remove} interface.
     *
     * @param mapEntry is a {@link java.util.Map.Entry} instance to be removed.
     *
     * @return true if the key-value pair was removed from the set, or false if
     * the mapEntry is not a {@link java.util.Map.Entry} instance or is not
     * present in the set.
     *
     *
     * @throws UnsupportedOperationException if the collection is read-only.
     *
     * @throws RuntimeExceptionWrapper if a checked exception is thrown,
     * including a {@code DatabaseException} on BDB (C edition).
     */
public boolean remove(Object mapEntry) {
    if (!(mapEntry instanceof Map.Entry)) {
        return false;
    }
    DataCursor cursor = null;
    boolean doAutoCommit = beginAutoCommit();
    try {
        cursor = new DataCursor(view, true);
        Map.Entry entry = (Map.Entry) mapEntry;
        OperationStatus status = cursor.findBoth(entry.getKey(), entry.getValue(), true);
        if (status == OperationStatus.SUCCESS) {
            cursor.delete();
        }
        closeCursor(cursor);
        commitAutoCommit(doAutoCommit);
        return (status == OperationStatus.SUCCESS);
    } catch (Exception e) {
        closeCursor(cursor);
        throw handleException(e, doAutoCommit);
    }
}

@Override
public Set<java.util.Map.Entry<String, String>> entrySet() {
    Set<java.util.Map.Entry<String, String>> entrySet = new HashSet<>();
    for (Object entry : wrappedMap.entrySet()) {
        if (entry instanceof java.util.Map.Entry) {
            final String key = ObjectUtils.isNull(((java.util.Map.Entry) entry).getKey()) ? KFSConstants.EMPTY_STRING : ((java.util.Map.Entry) entry).getKey().toString();
            final String value = stringifyValue(((java.util.Map.Entry) entry).getValue());
            final java.util.Map.Entry<String, String> stringyEntry = new AbstractMap.SimpleImmutableEntry(key, value);
            entrySet.add(stringyEntry);
        }
    }
    return entrySet;
}

/**
   * @see java.lang.Object#equals(java.lang.Object)
   */
@SuppressWarnings("unchecked")
@Override
public boolean equals(final Object obj) {
    if (this == obj) {
        return true;
    }
    if (obj == null) {
        return false;
    }
    if (this.getClass() != obj.getClass()) {
        return false;
    }
    final Entry<V, K> other = (Entry<V, K>) obj;
    if (this.m_key == null) {
        if (other.m_key != null) {
            return false;
        }
    } else if (!this.m_key.equals(other.m_key)) {
        return false;
    }
    if (this.m_value == null) {
        if (other.m_value != null) {
            return false;
        }
    } else if (!this.m_value.equals(other.m_value)) {
        return false;
    }
    return true;
}

public final ScrollPositions getScrollPositions() {
    ScrollPositions scrollpositions = new ScrollPositions();
    Iterator iterator = mRows.entrySet().iterator();
    while (iterator.hasNext()) {
        java.util.Map.Entry entry = (java.util.Map.Entry) iterator.next();
        String s = (String) entry.getKey();
        ColumnGridView columngridview = (ColumnGridView) entry.getValue();
        View view = columngridview.getChildAt(0);
        int i;
        if (view != null)
            i = view.getLeft();
        else
            i = 0;
        scrollpositions.setScrollPosition(s, columngridview.getFirstVisiblePosition(), i);
    }
    return scrollpositions;
}

@Override
public Set<java.util.Map.Entry<Object, Value>> entrySet() {
    if (entrySet == null) {
        Set<java.util.Map.Entry<Object, Value>> set = new HashSet<Entry<Object, Value>>();
        for (Value value : values) {
            set.add(new AbstractMap.SimpleEntry<Object, Value>(value.getField(), value));
        }
        entrySet = Collections.unmodifiableSet(set);
    }
    return entrySet;
}

@Override
public java.util.Map.Entry<String, Object> next() {
    final Field field = fields[n];
    return new Map.Entry<String, Object>() {

        @Override
        public String getKey() {
            return field.getName();
        }

        @Override
        public Object getValue() {
            try {
                return field.get(dto);
            } catch (IllegalArgumentExceptionIllegalAccessException |  e) {
                throw new RuntimeException(e);
            }
        }

        @Override
        public Object setValue(Object value) {
            try {
                Object old = field.get(dto);
                field.set(dto, value);
                return old;
            } catch (IllegalArgumentExceptionIllegalAccessException |  e) {
                throw new RuntimeException(e);
            }
        }
    };
}

/**
     * Compares this <code>Map.Entry</code> with another <code>Map.Entry</code>.
     * <p>
     * Implemented per API documentation of {@link java.util.Map.Entry#equals(Object)}
     *
     * @param obj the object to compare to
     * @return true if equal key and value
     */
public boolean equals(Object obj) {
    if (obj == this) {
        return true;
    }
    if (!(obj instanceof Map.Entry)) {
        return false;
    }
    Map.Entry other = (Map.Entry) obj;
    return (getKey() == null ? other.getKey() == null : getKey().equals(other.getKey())) && (getValue() == null ? other.getValue() == null : getValue().equals(other.getValue()));
}

/**
     *  Implemented per API documentation of 
     *  {@link java.util.Map.Entry#equals(Object)}
     **/
public boolean equals(Object o) {
    if (o == null)
        return false;
    if (o == this)
        return true;
    if (!(o instanceof Map.Entry))
        return false;
    Map.Entry e2 = (Map.Entry) o;
    return ((getKey() == null ? e2.getKey() == null : getKey().equals(e2.getKey())) && (getValue() == null ? e2.getValue() == null : getValue().equals(e2.getValue())));
}

@Override
public java.util.Map.Entry<String, Object> next() {
    final Field field = fields[n];
    return new Map.Entry<String, Object>() {

        @Override
        public String getKey() {
            return field.getName();
        }

        @Override
        public Object getValue() {
            try {
                return field.get(dto);
            } catch (IllegalArgumentExceptionIllegalAccessException |  e) {
                throw new RuntimeException(e);
            }
        }

        @Override
        public Object setValue(Object value) {
            try {
                Object old = field.get(dto);
                field.set(dto, value);
                return old;
            } catch (IllegalArgumentExceptionIllegalAccessException |  e) {
                throw new RuntimeException(e);
            }
        }
    };
}

/**
     * @param args
     */
public static void main(String[] args) {
    MyClass myClass = new MyClass("123");
    HashMap<Integer, SoftReference<MyClass>> map = new HashMap<>();
    map.put(myClass.hashCode(), new SoftReference<>(myClass));
    map.put(myClass.hashCode(), new SoftReference<>(myClass));
    myClass = new MyClass("456");
    map.put(myClass.hashCode(), new SoftReference<>(myClass));
    System.out.println(map.size());
    Iterator<Entry<Integer, SoftReference<MyClass>>> iterator = map.entrySet().iterator();
    while (iterator.hasNext()) {
        Entry<Integer, SoftReference<MyClass>> entry = iterator.next();
        SoftReference<MyClass> val = entry.getValue();
        MyClass item = val.get();
        if (null != item) {
            System.out.println(item.mString);
        }
    //
    // map.remove(item.hashCode());
    // Exception in thread "main" java.util.ConcurrentModificationException
    // at java.util.HashMap$HashIterator.nextNode(Unknown Source)
    // at java.util.HashMap$EntryIterator.next(Unknown Source)
    // at java.util.HashMap$EntryIterator.next(Unknown Source)
    // at test4HashMap.main(test4HashMap.java:30)
    }
    map.remove(myClass.hashCode());
    // System.out.println(map.size());
    listHashMap();
    listHashMap1();
}

public HashSet<String> MemcacheStore() {
    Map<String, String[]> map = req.getParameterMap();
    for (Entry<String, String[]> entry : map.entrySet()) {
        String name = entry.getKey();
        String[] values = entry.getValue();
        for (int i = 0; i < values.length; i++) {
            storKeyVal(name, values[i]);
        }
    }
    return actions;
}

protected boolean filter() {
    java.util.Map.Entry entry = (java.util.Map.Entry) mapIterator.next();
    String entryKey = (String) entry.getKey();
    int pos = entryKey.indexOf('.');
    this.category = "";
    if (-1 == pos) {
        this.group = entryKey;
    } else {
        this.group = entryKey.substring(0, pos);
        int length = entryKey.length();
        if (length > pos + 1)
            this.category = entryKey.substring(pos + 1, length);
    }
    if (!findall && !entryKey.startsWith(this.key))
        // end of criteria
        return false;
    bucket = (HashMap) entry.getValue();
    bucketIterator = bucket.entrySet().iterator();
    iteratingMaps = false;
    if (bucketIterator.hasNext() == false)
        return false;
    return getPortletEntry();
}

public static void writeResources(Map<String, Integer> resources, File resourcesFile) throws IOException {
    Properties properties = new Properties();
    for (Entry<String, Integer> entry : resources.entrySet()) {
        properties.setProperty(entry.getKey(), String.valueOf(entry.getValue()));
    }
    resourcesFile.getParentFile().mkdirs();
    FileOutputStream out = new FileOutputStream(resourcesFile);
    try {
        properties.store(out, "");
    } finally {
        out.close();
    }
}

public static String getStringFromKitCooldowns(HashMap<String, Long> kit_map) {
    String kit_string = "";
    for (Entry<String, Long> kit_data : kit_map.entrySet()) {
        kit_string += kit_data.getKey() + "=" + kit_data.getValue() + ",";
    }
    if (kit_string.endsWith(",")) {
        kit_string = kit_string.substring(0, kit_string.length() - 1);
    }
    return kit_string;
}

//绑定javascript，建立通过javascript调用java的程�接�
public void bindJavascriptObject(WebActivity webactivity) {
    System.out.println("bindJavascriptObject bridges.size() = " + bridges.size());
    if (bridges.size() > 0) {
        WebView webview = webactivity.getWebView();
        String s;
        Object obj;
        Iterator iterator = bridges.entrySet().iterator();
        while (iterator.hasNext()) {
            java.util.Map.Entry entry = (java.util.Map.Entry) iterator.next();
            s = (String) entry.getKey();
            obj = entry.getValue();
            System.out.println("bindJavascriptObject s = " + s + " obj = " + obj);
            //ScriptBridge设置context
            if (obj instanceof ScriptBridge) {
                ((ScriptBridge) obj).setContext(webactivity);
            }
            //添加javasscript接�，桥接java和javascript的一个函数，�以通过javascript调用java的程�接�
            /*
				 * 是实例化一个对象，在htmlçš„js中调用，第二个å?‚数是实例化对象的别å??，
				 * 如果è¦?使用这个obj，则在js中使用的å??字就是interfaceName
				 * */
            webview.addJavascriptInterface(obj, s);
        }
    }
}

public static void main(String[] args) throws Exception {
    Document doc = new Document(dataDir + "Document.doc");
    for (java.util.Map.Entry entry : doc.getVariables()) {
        String name = entry.getKey().toString();
        String value = entry.getValue().toString();
        // Do something useful.
        System.out.println("Name: " + name + ", Value: " + value);
    }
}

@Override
public Object process(Entry<String, User> entry) {
    logger.debug("process.enter; entry: {}", entry);
    if (entry.getValue() != null) {
        User user = entry.getValue();
        if (user.getVersion() == getVersion()) {
            entry.setValue(null);
            auditEntity(AuditType.delete, user);
            return user;
        } else {
            // throw ex ?
            logger.warn("process; outdated user version: {}; entry version: {}; process terminated", getVersion(), entry.getValue().getVersion());
        }
    }
    return null;
}

@Override
public JsonElement view(Properties properties, JsonBuilder ctx) {
    JsonArray json = new JsonArray();
    for (Entry<Object, Object> entry : properties.entrySet()) {
        JsonObject object = new JsonObject();
        object.addProperty("key", (String) entry.getKey());
        object.addProperty("value", (String) entry.getValue());
        json.add(object);
    }
    return json;
}

public String format(final String message) {
    String errorMsg = message;
    for (final Entry<String, String> formatter : params.entrySet()) {
        if (!formatter.getValue().isEmpty()) {
            errorMsg = errorMsg.replaceAll(formatter.getKey(), Matcher.quoteReplacement(formatter.getValue()));
        } else {
            errorMsg = errorMsg.replaceAll(formatter.getKey(), "null");
        }
    }
    return errorMsg;
}

public static <K, V> Map<V, Set<K>> invertMapOfCollection(Map<K, ? extends Collection<V>> mapOfCollection) {
    Map<V, Set<K>> result = new TreeMap<V, Set<K>>();
    for (Entry<K, ? extends Collection<V>> inputEntry : mapOfCollection.entrySet()) {
        K inputKey = inputEntry.getKey();
        Collection<V> inputCollection = inputEntry.getValue();
        for (V inputValue : inputCollection) {
            Set<K> resultSet = result.get(inputValue);
            if (resultSet == null) {
                resultSet = new TreeSet<K>();
                result.put(inputValue, resultSet);
            }
            resultSet.add(inputKey);
        }
    }
    return result;
}

public static MessageDecoder<?, ?> createMessageDecoder(JobContext context, String topicName) {
    MessageDecoder<?, ?> decoder;
    try {
        decoder = (MessageDecoder<?, ?>) EtlInputFormat.getMessageDecoderClass(context, topicName).newInstance();
        Properties props = new Properties();
        for (Entry<String, String> entry : context.getConfiguration()) {
            props.put(entry.getKey(), entry.getValue());
        }
        decoder.init(props, topicName);
        return decoder;
    } catch (Exception e) {
        throw new MessageDecoderException(e);
    }
}

@PostConstruct
public void init() {
    LOGGER.info(constellationOGCModules.size() + " Constellation OGC module" + (constellationOGCModules.size() > 1 ? "s" : "") + " detected.");
    for (Entry<String, ? extends ConstellationOGCModule> moduleEntry : constellationOGCModules.entrySet()) {
        LOGGER.info(String.format("\t* %-5s (%s)", moduleEntry.getValue().getName(), moduleEntry.getKey()));
    }
}

/* (non-Javadoc)
	 * @see org.dita2indesign.indesign.inx.model.InDesignComponent#updatePropertyMap()
	 */
@Override
public void updatePropertyMap() throws Exception {
    InxValueList ptagValue = new InxValueList();
    for (Entry<String, String> entry : this.tags.entrySet()) {
        InxValueList labelItem = new InxValueList();
        InxString key = new InxString(entry.getKey());
        InxString value = new InxString(entry.getValue());
        labelItem.add(key);
        labelItem.add(value);
        ptagValue.add(labelItem);
    }
    this.setProperty(InDesignDocument.PROP_PTAG, ptagValue);
}

// provides a rough estimate of the size of the images
// in the cache.
public int getRoughSize() {
    int size = 0;
    for (Entry<String, CacheReference<String, Bitmap>> e : cache.entrySet()) {
        Bitmap b = e.getValue().get();
        if (b != null) {
            // a rough estimate of a bitmaps size;
            size += (b.getWidth() * b.getHeight());
        }
    }
    return size;
}

public static void main(String[] args) throws Exception {
    Future<Stream<Stream<Entry<String, Integer>>>> resultFuture = DStream.ofType(String.class, "wc").flatMap( line -> Stream.of(line.split("\\s+"))).reduceValues( word -> word,  word -> 1, Integer::sum).executeAs("WordCount");
    // each stream within a stream represents a partition essentially giving you access to each result partition
    Stream<Stream<Entry<String, Integer>>> result = resultFuture.get();
    result.forEach( resultPartitionStream -> {
        resultPartitionStream.forEach(System.out::println);
    });
    // will close Tez client
    result.close();
    SampleUtils.clean("WordCount");
}

/**
	 * ·­ÒëÁ¬½ÓÖеĻúÆ÷ÃûΪIPµØÖ·
	 * @param datanodePutuRL master ·µ»Øʵ¼Ê´æ´¢Â·¾¶
	 * @return ʵ¼ÊÌá½»µØÖ·
	 */
public String transDataNodePutUrl(String datanodePutuRL) {
    for (Iterator it = EasystorConstants.hostIPMap.entrySet().iterator(); it.hasNext(); ) {
        Map.Entry<String, String> en = (Entry<String, String>) it.next();
        String hostName = en.getKey();
        String ip = en.getValue();
        datanodePutuRL = datanodePutuRL.replace(hostName, ip);
    }
    return datanodePutuRL;
}

@Override
public void mouseMove(MouseEvent e) {
    Entry<Integer, Vaccination> entry = vcpl.naviVacMap.floorEntry(e.y);
    if (entry == null)
        return;
    Vaccination vac = entry.getValue();
    if (vac != selectedVacc) {
        selectedVacc = vac;
        Control control = (Control) e.getSource();
        vcpl.setSelection(selectedVacc, control);
    }
}

// -------------------------------------------- //
// OVERRIDE
// -------------------------------------------- //
@Override
public void perform() {
    // Event
    EventFactionsExpansions event = new EventFactionsExpansions(sender);
    event.run();
    // Title
    Object title = "Factions Expansions";
    title = Txt.titleize(title);
    message(title);
    // Lines
    for (Entry<String, Boolean> entry : event.getExpansions().entrySet()) {
        String name = entry.getKey();
        Boolean installed = entry.getValue();
        String format = (installed ? "<g>[X] <h>%s" : "<b>[ ] <h>%s");
        msg(format, name);
    }
    // URL Suggestion
    msg("<i>Learn all about expansions in the online documentation:");
    msg("<aqua>https://www.massivecraft.com/factions");
}

public JSONObject getErrorsAsJson() {
    JSONObject jsonObject = new JSONObject();
    for (Entry<String, String> error : this.getErrors().entrySet()) {
        try {
            jsonObject.put(error.getKey(), error.getValue());
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }
    return jsonObject;
}

@Override
public void parse(CommandParserArgs arguments) {
    arguments.confirm("List of commands:");
    for (Entry<String, IrcCommand> command : IrcHandler.getInstance().commands.entrySet()) {
        arguments.confirm(COMMAND_CHAR + command.getKey() + " " + command.getValue().getCommandUsage() + ": " + command.getValue().getCommandHelp());
    }
}

public List<PveEventDetails> getEventDetails() {
    final List<PveEventDetails> result = new ArrayList<>();
    for (final Entry<String, PveEventDetails> details : _events.entrySet()) {
        final PveEventDetails detail = details.getValue();
        detail.setEvent_id(details.getKey());
        result.add(detail);
    }
    return result;
}

@Override
public Field deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext ctx) {
    JsonObject obj = json.getAsJsonObject();
    String theKey;
    fields = new HashMap<String, JsonElement>();
    for (Entry<String, JsonElement> entry : obj.entrySet()) {
        theKey = entry.getKey();
        JsonElement theRawDetail = obj.get(theKey);
        fields.put(theKey, theRawDetail);
    }
    return new Field(fields);
}

@SubscribeEvent
public void serverStarted(WorldEvent.Load event) {
    if (!event.getWorld().isRemote && event.getWorld().provider.getDimension() == 0) {
        logger.debug("Applying the game rules");
        GameRules rules = event.getWorld().getGameRules();
        for (Entry<String, String> entry : gameRules.entrySet()) {
            rules.setOrCreateGameRule(entry.getKey(), entry.getValue());
        }
    }
}

public String toJSONString() {
    StringBuilder b = new StringBuilder();
    b.append("{");
    boolean addComa = false;
    for (Entry<String, Object> e : map.entrySet()) {
        if (addComa)
            b.append(", ");
        addComa = true;
        b.append("\"" + e.getKey() + "\" : ");
        b.append(JSONUtils.toJSONString(e.getValue()));
    }
    b.append("}");
    return b.toString();
}

@Override
public void displayErrorsInFile(String fileName, HashMap<Integer, Severity> errors) {
    codeViewer.reset();
    ArrayList<Error> errorList = new ArrayList<Error>();
    for (Entry<Integer, Severity> entry : errors.entrySet()) {
        Severity severity = entry.getValue();
        Error error = new Error(entry.getKey(), severity.getColor());
        errorList.add(error);
    }
    codeViewer.setErrors(errorList);
    codeViewer.parseFile(fileName);
    mainController.getViewController().showCodeViewer();
}

/**
	 * Displays a list of all commands
	 */
public void handle(CommandSender sender) {
    sender.sendMessage(ChatColor.YELLOW + "Help of /" + getRoot().getName());
    for (Entry<String, Command> e : getRoot().registers.entrySet()) {
        String args = "";
        for (Param param : e.getValue().getParamList()) {
            String brace = (param.isNeeded() ? "[" : "(") + (param.isNeeded() ? "]" : ")");
            args += brace.charAt(0) + param.getName() + brace.charAt(1);
        }
        sender.sendMessage(ChatColor.YELLOW + "/" + getRoot().getName() + " " + ChatColor.GRAY + e.getKey() + " " + args + " " + e.getValue().getDescription());
    }
}

public Iterator<Entry<A, B>> iterator() {
    return new AbstractIterator<Entry<A, B>>() {

        private Iterator<A> first = firstIterable.iterator();

        private Iterator<B> second = secondIterable.iterator();

        @Override
        protected Entry<A, B> computeNext() {
            if (!first.hasNext() || !second.hasNext()) {
                return endOfData();
            }
            return Maps.immutableEntry(first.next(), second.next());
        }
    };
}

public static String parseInputStream(final InputStream is, Map<String, String> values) throws IOException {
    StringWriter writer = new StringWriter();
    IOUtils.copy(is, writer);
    String theString = writer.toString();
    String replace = theString;
    for (Entry<String, String> pair : values.entrySet()) {
        if (pair.getValue() == null) {
            pair.setValue("");
        }
        replace = replace.replace(pair.getKey(), pair.getValue());
        LOGGER.debug("Settings.xml variable: {}={}", pair.getKey(), pair.getValue());
    }
    return replace;
}

public static void main(String[] args) {
    Map<StringBuilder, String> m = new WeakHashMap<StringBuilder, String>();
    StringBuilder a = new StringBuilder("123");
    StringBuilder b = new StringBuilder("456");
    m.put(a, "good");
    m.put(b, "okok");
    m.put(null, "ccc");
    m.put(null, "ddd");
    a.append("4");
    b.append("7");
    a = null;
    b = null;
    System.gc();
    Set<Entry<StringBuilder, String>> set = m.entrySet();
    for (Entry<StringBuilder, String> e : set) {
        System.out.println(e);
    }
}

@Override
public Set<Map.Entry<K, V>> entrySet() {
    return new AbstractSet<Map.Entry<K, V>>() {

        @Override
        public Iterator<Map.Entry<K, V>> iterator() {
            return map.iterator();
        }

        @Override
        public int size() {
            return map.size();
        }

        @Override
        public Spliterator<Entry<K, V>> spliterator() {
            return new AbstractTreeMap.EntrySpliterator<>(map.root, map.size(), map.comparator, false);
        }
    };
}

public static String ppCfgBlockMapSet(Map<CfgBlock, Set<CfgBlock>> ms) {
    // sort the map for easy use
    TreeMap<String, String> sortedMap = new TreeMap<String, String>();
    for (Entry<CfgBlock, Set<CfgBlock>> entry : ms.entrySet()) {
        sortedMap.put(entry.getKey().getLabel(), ppCfgBlockSet(entry.getValue()));
    }
    return sortedMap.toString().replace("],", "],\n");
}

/**
     * Returns values aggregated from all the delegates, without overriding
     * values that already exist.
     * 
     * @return The Map of aggregated values
     */
@Override
public Map<String, String> values() {
    Map<String, String> values = new LinkedHashMap<String, String>();
    for (Row each : delegates) {
        for (Entry<String, String> entry : each.values().entrySet()) {
            String name = entry.getKey();
            if (!values.containsKey(name)) {
                values.put(name, entry.getValue());
            }
        }
    }
    return values;
}

@Override
public JsonElement visit(JsonObject json) {
    JsonElement result;
    if (json.has("$sparqlStep")) {
        JsonObject $sparqlStep = json.get("$sparqlStep").getAsJsonObject();
        JsonObject o = new JsonObject();
        o.addProperty("type", "org.aksw.jena_sparql_api.batch.step.FactoryBeanStepSparqlDiff");
        for (Entry<String, JsonElement> entry : $sparqlStep.entrySet()) {
            o.add(entry.getKey(), entry.getValue());
        }
        //			JsonObject autwired = new JsonObject();
        //			autwired.addProperty("autowired", "byType");
        //			o.add("stepBuilders", autwired);
        result = o;
    } else {
        result = json;
    }
    return result;
}

protected void createReverseMapping() {
    if (this.reverseMapping == null) {
        this.reverseMapping = new String[this.table.size() + 1];
        for (Entry<String, Integer> entry : table.entrySet()) {
            int type = (entry.getValue()).intValue();
            String text = entry.getKey();
            this.reverseMapping[type] = text;
        }
    }
}

@Override
public boolean execute(String... arguments) {
    if (arguments.length > 0) {
        String name = arguments[0];
        for (Entry<String, List<String>> entry : FileManager.getRuntimeClasses().entrySet()) if (entry.getKey().equalsIgnoreCase(name))
            for (String method : entry.getValue()) System.out.println(method);
        return true;
    }
    return false;
}

@SuppressWarnings("unchecked")
@Override
public <T> Object execute(T... args) {
    Map<Object, Long> result = null;
    if (args != null && args.length > 0) {
        List<Map<Object, Long>> list = (List<Map<Object, Long>>) args[0];
        result = new HashMap<Object, Long>();
        for (Map<Object, Long> each : list) {
            for (Entry<Object, Long> e : each.entrySet()) {
                Object key = e.getKey();
                Long val = e.getValue();
                if (result.containsKey(key)) {
                    val += result.get(key);
                }
                result.put(key, val);
            }
        }
    }
    return result;
}

public void run() {
    Integer current;
    String playerName;
    HashMap<String, Integer> messageCount;
    for (Entry<String, HashMap<String, Integer>> entry : collector.messageCounter.entrySet()) {
        playerName = entry.getKey();
        messageCount = entry.getValue();
        current = (messageCount.size() > 0) ? Collections.max(messageCount.values()) : 0;
        if (!collector.maxViolationLevel.containsKey(playerName) || current > collector.maxViolationLevel.get(playerName)) {
            collector.maxViolationLevel.put(playerName, current);
        }
    }
    collector.messageCounter.clear();
}

@Override
public String getText(Object element) {
    if (element instanceof DBObject) {
        return "";
    }
    if (element instanceof Entry) {
        Entry entry = (Entry) element;
        Object value = entry.getValue();
        if (value instanceof DBObject) {
            return "";
        }
        if (value instanceof byte[]) {
            return "";
        }
        return (value != null) ? value.toString() : "";
    }
    return "";
}

public synchronized void put(FieldData key, FieldMapper value) {
    List<FieldData> update = new ArrayList<>();
    for (Entry<FieldData, FieldMapper> entry : mappers.entrySet()) {
        FieldData data = entry.getKey();
        if (data.equals(key)) {
            update.add(data);
        }
    }
    mappers.put(key, value);
    for (FieldData data : update) {
        mappers.remove(data);
    }
}

@Override
protected Request.Builder buildRequset(String url, Map<String, Object> params) {
    FormBody.Builder builder = new FormBody.Builder();
    if (params != null) {
        for (Entry<String, ?> entry : params.entrySet()) {
            builder.add(entry.getKey(), String.valueOf(entry.getValue()));
        }
    }
    RequestBody formBody = builder.build();
    return new Request.Builder().url(url).put(formBody);
}

@Override
public void insert(RedisConnectionCallback connection, InputStream dataset) throws Throwable {
    Properties properties = new Properties();
    properties.load(dataset);
    BinaryJedisCommands insertionJedis = connection.insertionJedis();
    Set<Entry<Object, Object>> entrySet = properties.entrySet();
    for (Entry<Object, Object> entry : entrySet) {
        String key = (String) entry.getKey();
        String value = (String) entry.getValue();
        insertionJedis.set(key.getBytes(), value.getBytes());
    }
}

@Override
public String sniff(Resource resource) {
    Map<String, String> httpHeaders = resource.getHttpHeaders();
    for (Entry<String, String> e : httpHeaders.entrySet()) {
        String headerKey = e.getKey();
        if (headerKey.equalsIgnoreCase(HTTP_CONTENT_TYPE_HEADER)) {
            String ctype = e.getValue();
            String charsetName = contentTypeToCharset(ctype);
            return charsetName;
        }
    }
    return null;
}

@SuppressWarnings("unchecked")
@Override
protected void addItemText(Object item) {
    Entry<Guid, EntityModel<Boolean>> entry = (Entry<Guid, EntityModel<Boolean>>) item;
    EntityModelCheckBoxWidget cb = new EntityModelCheckBoxWidget(Align.RIGHT, "- " + entry.getValue().getMessage(), //$NON-NLS-1$
    entry.getValue().getTitle());
    cb.edit(entry.getValue());
    itemPanel.add(cb);
}

public List<String> getList() {
    List<String> result = new ArrayList<String>();
    HttpServletRequest request = (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest();
    Map<String, String[]> parameterMap = request.getParameterMap();
    if (!parameterMap.isEmpty()) {
        for (Entry<String, String[]> param : parameterMap.entrySet()) {
            String values = Strings.join(Arrays.asList(param.getValue()), ", ");
            result.add(param.getKey() + ": " + values);
        }
    }
    return result;
}

@Test
public void tokenize() {
    String text = //
    "Twitter is an online social networking service and microblogging service" + //
    " that enables its users to send and read text-based posts of up to 140 characters," + " known as \"tweets\". You can signup and test it yourself.";
    Map<String, Integer> tokenMap = new TweetParser().tokenize(text);
    assertThat(tokenMap).hasSize(25);
    assertThat(tokenMap.get("microblogging")).isEqualTo(1);
    assertThat(tokenMap.get("and")).isEqualTo(3);
    assertThat(tokenMap.get("unknown")).isNull();
    for (Entry<String, Integer> e : tokenMap.entrySet()) {
        System.out.println(e.getKey() + ": " + e.getValue());
    }
}

public static void main(String[] args) {
    TreeMap<String, String> map = new TreeMap<String, String>();
    for (Method method : Observable.class.getMethods()) {
        if (Modifier.isPublic(method.getModifiers()) && !Modifier.isNative(method.getModifiers()))
            map.put(method.getName(), method.toString());
    }
    System.out.println("| Method | Signature |");
    System.out.println("| ------ | --------- |");
    for (Entry<String, String> entry : map.entrySet()) {
        System.out.println("| " + entry.getKey() + " | " + entry.getValue().replaceAll("\\w+\\.", "").replaceAll("public ", "").replaceAll("final ", "").replaceAll("Observable", "Ob") + " |");
    }
}

public JSONObject getErrorsAsJson() {
    JSONObject jsonObject = new JSONObject();
    for (Entry<String, String> error : this.getErrors().entrySet()) {
        try {
            jsonObject.put(error.getKey(), error.getValue());
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }
    return jsonObject;
}

@Override
public void run(String... arg0) throws Exception {
    p(">>> test map");
    for (Entry<String, TestObjectWithList> e : props.getTestMap().entrySet()) {
        p(e.getKey() + " -> ");
        String[] strings = e.getValue().getStringList();
        if (strings == null) {
            p("  null");
        } else {
            for (String string : strings) {
                p("  '" + string + "'");
            }
        }
    }
}

public void print(StringBuilder b) {
    for (Iterator<Entry<MachineState, StateModel>> iterator = states.entrySet().iterator(); iterator.hasNext(); ) {
        Entry<MachineState, StateModel> type = (Entry<MachineState, StateModel>) iterator.next();
        MachineState stateDesc = type.getKey();
        StateModel state = type.getValue();
        b.append("\texp: " + state.timesExplored + "\n");
        state.print(b);
    }
}

@Override
public void start(String name, Attributes attributes) throws IOException {
    Map<String, Object> dynamicAttributes = (Map<String, Object>) context.getParameters().get("dynamicAttributes");
    for (Entry<String, Object> attribute : dynamicAttributes.entrySet()) {
        if (attribute.getKey().startsWith("ajax")) {
            attributes.add(String.format("data-%s", attribute.getKey()), ObjectUtils.toString(attribute.getValue()));
        }
    }
    super.start(name, attributes);
}

public static void dumpParameters(XMLStringBuffer xsb, Map<String, String> parameters) {
    // parameters
    if (!parameters.isEmpty()) {
        for (Map.Entry<String, String> para : parameters.entrySet()) {
            Properties paramProps = new Properties();
            paramProps.setProperty("name", para.getKey());
            paramProps.setProperty("value", para.getValue());
            // BUGFIX: TESTNG-27
            xsb.addEmptyElement("parameter", paramProps);
        }
    }
}

@Test
public void testMapNameNormalization() {
    final Map<String, String> testPairs = Maps.newHashMap();
    testPairs.put("same.zip", "same.zip");
    testPairs.put("camelCase.zip", "camel_case.zip");
    testPairs.put("spaces removed.zip", "spaces_removed.zip");
    testPairs.put("LowerCased.zip", "lower_cased.zip");
    testPairs.put("LOWER.zip", "lower.zip");
    for (final Entry<String, String> testPair : testPairs.entrySet()) {
        assertThat(ResourceLoader.normalizeMapZipName(testPair.getKey()), is(testPair.getValue()));
    }
}

@Override
protected void realExecute() {
    LObject<String> datum = ParamChecking.datum(project, datumId);
    Collection<CategoryValue> cp = new ArrayList<CategoryValue>();
    for (Entry<String, Double> e : project.getResults().getDatumResult(datum).getCategoryProbabilites().entrySet()) {
        cp.add(new CategoryValue(e.getKey(), e.getValue()));
    }
    setResult(cp);
}

public boolean matches(NameDescription nameDescription) {
    for (String term : terms) {
        boolean match = false;
        if (nameDescription.getQualifiedName().toLowerCase().contains(term))
            continue;
        if (nameDescription.getAliasSet() != null) {
            for (Entry<String, String> entry : nameDescription.getAliasSet().getAliases().entrySet()) {
                if (entry.getKey().toLowerCase().contains(term) || entry.getValue().toLowerCase().contains(term)) {
                    match = true;
                    break;
                }
            }
        }
        if (!match)
            return false;
    }
    return true;
}

public String toString() {
    int n;
    String[] s = new String[map.size() * 4 + 1];
    Iterator i = map.entrySet().iterator();
    for (n = 0; i.hasNext(); n += 4) {
        Entry e = (Entry) i.next();
        s[n] = n == 0 ? "{" : ",";
        s[n + 1] = Core.show(e.getKey());
        s[n + 2] = ":";
        Object v = e.getValue();
        s[n + 3] = v == null ? "null" : Core.show(v);
    }
    s[n] = "}";
    return Core.concat(s);
}

public static void main(String[] args) {
    GroupedSet set = new GroupedSet("config/demo.set");
    log.debug("path: {}", set.getPath());
    log.debug("groups: {}", set.getGroups());
    log.debug("特殊分组是�包�字符1: {}", set.contains("特殊分组", "1"));
    Set<Entry<String, LinkedHashSet<String>>> entrySet = set.entrySet();
    for (Entry<String, LinkedHashSet<String>> entry : entrySet) {
        log.debug(entry.toString());
    }
}

protected static String buildArgumentsOutput(Map<Object, Object> var) {
    StringBuilder sb = new StringBuilder();
    if (var == null) {
        return "do not have variable";
    }
    for (Entry<Object, Object> entry : var.entrySet()) {
        sb.append("[").append(entry.getKey()).append("=").append(entry.getValue()).append("|type:").append(entry.getValue() == null ? null : entry.getValue().getClass()).append("]");
    }
    return sb.toString();
}

@Test(timeout = 1000)
public void testToJsonTree_add1192() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(), this, "testToJsonTree_add1192");
    TestTypes.BagOfPrimitives bag = new TestTypes.BagOfPrimitives(10L, 5, false, "foo");
    JsonElement json = gson.toJsonTree(bag);
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(), 1719, json, 1718, json.isJsonObject());
    JsonObject obj = json.getAsJsonObject();
    Set<java.util.Map.Entry<java.lang.String, com.google.gson.JsonElement>> children = obj.entrySet();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(), 1721, children, 1720, children.size());
    assertContains(obj, new JsonPrimitive(10L));
    assertContains(obj, new JsonPrimitive(10L));
    assertContains(obj, new JsonPrimitive(5));
    assertContains(obj, new JsonPrimitive(false));
    assertContains(obj, new JsonPrimitive("foo"));
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

public void marshall(Prediction prediction, AwsJsonWriter jsonWriter) throws Exception {
    jsonWriter.beginObject();
    if (prediction.getPredictedLabel() != null) {
        String predictedLabel = prediction.getPredictedLabel();
        jsonWriter.name("predictedLabel");
        jsonWriter.value(predictedLabel);
    }
    if (prediction.getPredictedValue() != null) {
        Float predictedValue = prediction.getPredictedValue();
        jsonWriter.name("predictedValue");
        jsonWriter.value(predictedValue);
    }
    if (prediction.getPredictedScores() != null) {
        java.util.Map<String, Float> predictedScores = prediction.getPredictedScores();
        jsonWriter.name("predictedScores");
        jsonWriter.beginObject();
        for (java.util.Map.Entry<String, Float> predictedScoresEntry : predictedScores.entrySet()) {
            Float predictedScoresValue = predictedScoresEntry.getValue();
            if (predictedScoresValue != null) {
                jsonWriter.name(predictedScoresEntry.getKey());
                jsonWriter.value(predictedScoresValue);
            }
        }
        jsonWriter.endObject();
    }
    if (prediction.getDetails() != null) {
        java.util.Map<String, String> details = prediction.getDetails();
        jsonWriter.name("details");
        jsonWriter.beginObject();
        for (java.util.Map.Entry<String, String> detailsEntry : details.entrySet()) {
            String detailsValue = detailsEntry.getValue();
            if (detailsValue != null) {
                jsonWriter.name(detailsEntry.getKey());
                jsonWriter.value(detailsValue);
            }
        }
        jsonWriter.endObject();
    }
    jsonWriter.endObject();
}

/**
     * @param  map
     * @return String
     */
public static String getKeyOfHighestValue(HashMap<String, Integer> map) {
    int max = 0;
    String key = "";
    Iterator it = map.entrySet().iterator();
    while (it.hasNext()) {
        java.util.Map.Entry pairs = (java.util.Map.Entry) it.next();
        int value = Integer.parseInt(pairs.getValue().toString());
        if (value > max) {
            max = value;
            key = pairs.getKey().toString();
        }
        // Avoid ConcurrentModificationException
        it.remove();
    }
    return key;
}