Java 将树映射修剪为n个条目

我有一个排序树形图，我想删除除前10个元素以外的所有元素。这样做的方法是什么？我考虑过在贴图大小大于10时从贴图末尾删除元素，但我不知道如何做到这一点。我可以转换成列表然后再返回吗

---

谢谢

哈希映射没有开始或结束-它们是无序的。迭代项的顺序与插入项的顺序完全无关。如果您可以使用LinkedHashMap，那么该类实际上会保留项目插入的顺序。然后，您可以简单地在entrySet上迭代，在迭代了前十个条目之后，对每个条目在迭代器上调用remove。

哈希映射没有开始或结束-它们是无序的。迭代项的顺序与插入项的顺序完全无关。如果您可以使用LinkedHashMap，那么该类实际上会保留项目插入的顺序。然后，您可以简单地迭代entrySet，在迭代了前十个条目之后，为每个条目调用迭代器上的remove。也许可以创建一个大小限制为10个元素的地图类，并以这种方式复制/构建有限的地图段：

package main;

import java.util.LinkedHashMap;
import java.util.Map;

import com.google.common.collect.Maps;

public class HashMap10<K, V> extends LinkedHashMap<K, V> {

    private static final long serialVersionUID = -4943383947326287590L;

    static Map<Integer, String> x = Maps.newHashMap();

    public HashMap10() {
        super();
    }

    public HashMap10(int initialCapacity, float loadFactor, boolean accessOrder) {
        super(initialCapacity, loadFactor, accessOrder);
    }

    public HashMap10(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
    }

    public HashMap10(int initialCapacity) {
        super(initialCapacity);
    }

    public HashMap10(Map<? extends K, ? extends V> m) {
        putAll(m);
    }

    @Override
    public V put(K key, V value) {
        if (this.size() == 10) {
            return null;
        }
        return super.put(key, value);
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        for (java.util.Map.Entry<? extends K, ? extends V> x : m.entrySet()) {
            put(x.getKey(), x.getValue());
        }
    }

}

通过向有限大小映射添加100个元素，一次通过多个put调用，一次使用构造函数来测试它：

package main;

import java.util.HashMap;
import java.util.Map.Entry;

public class TestIt {

    /**
     * @param args
     */
    public static void main(String[] args) {
        HashMap10<Integer, String> map10 = new HashMap10<Integer, String>();

        for (int i = 1; i < 99; i++) {
            map10.put(i, Integer.toString(i + 100));
        }

        for (Entry<Integer, String> x : map10.entrySet()) {
            System.out.println(x.getKey() + "->" + x.getValue());
        }
        System.out.println("");
        System.out.println("");

        HashMap<Integer, String> mapUnlimited = new HashMap<Integer, String>();

        for (int i = 1; i < 99; i++) {
            mapUnlimited.put(i, Integer.toString(i + 200));
        }

        HashMap10<Integer, String> anotherMap10 = new HashMap10<Integer, String>(
                mapUnlimited);
        for (Entry<Integer, String> x : anotherMap10.entrySet()) {
            System.out.println(x.getKey() + "->" + x.getValue());
        }

    }

}

转储映射，您只有10个元素的映射，无论您是一次添加一个元素，还是使用构造函数构建映射：

package main;

import java.util.HashMap;
import java.util.Map.Entry;

public class TestIt {

    /**
     * @param args
     */
    public static void main(String[] args) {
        HashMap10<Integer, String> map10 = new HashMap10<Integer, String>();

        for (int i = 1; i < 99; i++) {
            map10.put(i, Integer.toString(i + 100));
        }

        for (Entry<Integer, String> x : map10.entrySet()) {
            System.out.println(x.getKey() + "->" + x.getValue());
        }
        System.out.println("");
        System.out.println("");

        HashMap<Integer, String> mapUnlimited = new HashMap<Integer, String>();

        for (int i = 1; i < 99; i++) {
            mapUnlimited.put(i, Integer.toString(i + 200));
        }

        HashMap10<Integer, String> anotherMap10 = new HashMap10<Integer, String>(
                mapUnlimited);
        for (Entry<Integer, String> x : anotherMap10.entrySet()) {
            System.out.println(x.getKey() + "->" + x.getValue());
        }

    }

}

1->101 2->102 3->103 4->104 5->105 6->106 7->107 8->108 9->109 10->110 1->201 2->202 3->203 4->204 5->205 6->206 7->207 8->208 9->209 10->210

---

我没有在防御性编程上投入任何时间，检查空值，诸如此类的事情。这里的意思是我不知道也不在乎你原来的地图是什么。链接地图。树图。常规地图。无论返回元素的顺序如何，都定义了前10个元素的含义，我的map类将只存储前10个元素，并忽略其后的任何元素。现在你有了你的前10个，不管这对你的地图意味着什么。也许可以创建一个大小限制为10个元素的地图类，并以这种方式复制/构建有限的地图段：

package main;

import java.util.LinkedHashMap;
import java.util.Map;

import com.google.common.collect.Maps;

public class HashMap10<K, V> extends LinkedHashMap<K, V> {

    private static final long serialVersionUID = -4943383947326287590L;

    static Map<Integer, String> x = Maps.newHashMap();

    public HashMap10() {
        super();
    }

    public HashMap10(int initialCapacity, float loadFactor, boolean accessOrder) {
        super(initialCapacity, loadFactor, accessOrder);
    }

    public HashMap10(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
    }

    public HashMap10(int initialCapacity) {
        super(initialCapacity);
    }

    public HashMap10(Map<? extends K, ? extends V> m) {
        putAll(m);
    }

    @Override
    public V put(K key, V value) {
        if (this.size() == 10) {
            return null;
        }
        return super.put(key, value);
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        for (java.util.Map.Entry<? extends K, ? extends V> x : m.entrySet()) {
            put(x.getKey(), x.getValue());
        }
    }

}

通过向有限大小映射添加100个元素，一次通过多个put调用，一次使用构造函数来测试它：

package main;

import java.util.HashMap;
import java.util.Map.Entry;

public class TestIt {

    /**
     * @param args
     */
    public static void main(String[] args) {
        HashMap10<Integer, String> map10 = new HashMap10<Integer, String>();

        for (int i = 1; i < 99; i++) {
            map10.put(i, Integer.toString(i + 100));
        }

        for (Entry<Integer, String> x : map10.entrySet()) {
            System.out.println(x.getKey() + "->" + x.getValue());
        }
        System.out.println("");
        System.out.println("");

        HashMap<Integer, String> mapUnlimited = new HashMap<Integer, String>();

        for (int i = 1; i < 99; i++) {
            mapUnlimited.put(i, Integer.toString(i + 200));
        }

        HashMap10<Integer, String> anotherMap10 = new HashMap10<Integer, String>(
                mapUnlimited);
        for (Entry<Integer, String> x : anotherMap10.entrySet()) {
            System.out.println(x.getKey() + "->" + x.getValue());
        }

    }

}

转储映射，您只有10个元素的映射，无论您是一次添加一个元素，还是使用构造函数构建映射：

package main;

import java.util.HashMap;
import java.util.Map.Entry;

public class TestIt {

    /**
     * @param args
     */
    public static void main(String[] args) {
        HashMap10<Integer, String> map10 = new HashMap10<Integer, String>();

        for (int i = 1; i < 99; i++) {
            map10.put(i, Integer.toString(i + 100));
        }

        for (Entry<Integer, String> x : map10.entrySet()) {
            System.out.println(x.getKey() + "->" + x.getValue());
        }
        System.out.println("");
        System.out.println("");

        HashMap<Integer, String> mapUnlimited = new HashMap<Integer, String>();

        for (int i = 1; i < 99; i++) {
            mapUnlimited.put(i, Integer.toString(i + 200));
        }

        HashMap10<Integer, String> anotherMap10 = new HashMap10<Integer, String>(
                mapUnlimited);
        for (Entry<Integer, String> x : anotherMap10.entrySet()) {
            System.out.println(x.getKey() + "->" + x.getValue());
        }

    }

}

1->101 2->102 3->103 4->104 5->105 6->106 7->107 8->108 9->109 10->110 1->201 2->202 3->203 4->204 5->205 6->206 7->207 8->208 9->209 10->210

---

我没有在防御性编程上投入任何时间，检查空值，诸如此类的事情。这里的意思是我不知道也不在乎你原来的地图是什么。链接地图。树图。常规地图。无论返回元素的顺序如何，都定义了前10个元素的含义，我的map类将只存储前10个元素，并忽略其后的任何元素。现在你有了你的前10个，不管这对你的地图意味着什么。

+1：如果排序需要的不是键的自然顺序，另一个选择是使用带有比较器的树形图。但是如果OP的前10个元素指的是前10个插入对，那么LinkedHashMap就是这里的方法。是的，@CoolBeans，这就是我所做的。+1：另一个选择是使用带有比较器的树映射，如果排序需要的不是密钥的自然排序。但是，如果OP的前10个元素指的是前10个插入对，那么LinkedHashMap就是这里的方法。是的，@CoolBeans，这就是我所做的。@Laurence Gonsalves:我已经使用值比较器按值对映射进行排序。当我打印map.toString时，我会按值顺序对值进行排序。我只想打印前十张。啊。。。。这是一个树形图。按值排序的树映射。我在comparator实用程序中将其从HashMap转换为TreeMap。对不起！：/谢谢你发现了我的纸条up@LaurenceGonsalves：我已经使用值比较器按值对地图进行了排序。当我打印map.toString时，我会按值顺序对值进行排序。我只想打印前十张。啊。。。。这是一个树形图。按值排序的树映射。我在comparator实用程序中将其从HashMap转换为TreeMap。对不起！：/谢谢你发现我的上肢，这很酷。不得不在mapreduce中对其进行一些修改，但结果非常棒。再次感谢汉克斯-这很酷。不得不在mapreduce中对其进行一些修改，但结果非常棒。再次感谢