Java hashmap迭代器

Question

I want to make the method removeValue( "a", "x") .
It must delete all keys and values between the letters. For example:

{1=a,2=b,3=c,5=x}  ->> {1=a,5=x}

I tried with equals and iterator but I don't know how to write it.

public class CleanMapVal {

    public static void main(String[] args) throws Exception {


        Map<String, String> map = new HashMap<String, String>();
        map.put("1", "a");
        map.put("2", "b");
        map.put("3", "c");
        map.put("4", "w");
        map.put("5", "x");

         System.out.println( map );

        for (Iterator<String> it = map.keySet().iterator(); it.hasNext();)
            if ("2".equals(it.next()))
                it.remove();

        System.out.println(map);

    }

    public static <K, V> void removeValue(Map<K, V> map) throws Exception {
        Map<K, V> tmp = new HashMap<K, V>();
        for (Iterator<K> it = map.keySet().iterator(); it.hasNext();) {
            K key = it.next();
            V val = map.get(key);
            if (!tmp.containsValue(val)) {
                tmp.put(key, val);
            }
        }
        map.clear();
        for (Iterator<K> it = tmp.keySet().iterator(); it.hasNext();) {
            K key = it.next();
            map.put((K) tmp.get(key), (V) key);
        }
    }
}

Answer 1

Try the following code.I'm using treemap to maintain the order and then iterating to remove the elements.

 Map<Integer, String> map = new TreeMap<Integer, String>();
    map.put(1, "a");
    map.put(2, "b");
    map.put(3, "c");
    map.put(4, "w");
    map.put(5, "x");
    ArrayList<Integer> intList = new ArrayList<Integer>();
    for (Iterator<Integer> it = map.keySet().iterator(); it.hasNext();) {
        int key = 0;
        if (it.next() == 1) {
            while(true) {
                key = it.next();
                if(key==5)break;
                intList.add(key);

            }
        }

    }
   //removing from the map in separate loop to avoid concurrent modification exception

    for (int i : intList) {
        map.remove(i);
    }

    System.out.println(map.size()); //2

Answer 2

First of all, a HashMap never keeps the orders of the Object which are put in it. So you need to use LinkedHashMap which maintains its insertion order. For removal of Object you need to make use of Iterator

Map testMap = new LinkedHashMap<Integer, String>(); If your key is of any other type except Integer change it accordingly.

So for your requirement, you can use the below code :-

 public static void testKey(Map<Integer, String> testMap, String startValue,
            String endValue) {
 if(!testMap.containsValue(startValue) || !testMap.containsValue(endValue))
            return; // if start/end value is not present in Map then no change at all
        Iterator<Map.Entry<Integer, String>> iter = testMap.entrySet()
                .iterator();
        boolean deleteFlag = false;
        while (iter.hasNext()) {
            Map.Entry<Integer, String> entry = iter.next();
            if (endValue.equalsIgnoreCase(entry.getValue())) {
                deleteFlag = false;
            }
            if (deleteFlag)
                iter.remove();
            if (startValue.equalsIgnoreCase(entry.getValue())) {
                deleteFlag = true;
            }

        }
    }

public static void main(String[] args) {
        Map m = new LinkedHashMap<Integer, String>();
        m.put(1, "a");
        m.put(2, "b");
        m.put(3, "c");
        m.put(5, "x");
        System.out.println("before : "+m);
        removeValue(m, "a", "x");
        System.out.println("after : "+m);
    }

Output

before : {1=a, 2=b, 3=c, 5=x}
after : {1=a, 5=x}

Answer 3

Using an Iterator allows you to remove entries on the fly.

public void removeRange(Map<Integer, String> map, String from, String to) {
    // Walk each entry.
    for (Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator(); it.hasNext();) {
        // What is the value?
        String v = it.next().getValue();
        if (v.compareTo(from) > 0 && v.compareTo(to) < 0) {
            // In the specified range! Remove it.
            it.remove();
        }
    }

}

public void test() {
    Map<Integer, String> map = new HashMap<>();
    map.put(1, "a");
    map.put(2, "b");
    map.put(3, "c");
    map.put(4, "w");
    map.put(5, "x");
    System.out.println("Before:" + map);
    removeRange(map, "a", "x");
    System.out.println("After:" + map);
}

prints

Before:{1=a, 2=b, 3=c, 4=w, 5=x}

After:{1=a, 5=x}

If you are using Java 8 you can also stream and filter a Map.

public <K, V> Map<K, V> filter(Map<K, V> map, Predicate<Map.Entry<K, V>> filter) {
    return map.entrySet()
            .stream()
            // Filter out the unwanted ones.
            .filter(filter)
            // Fold back into a new Map.
            .collect(Collectors.toMap(
                            (Map.Entry<K, V> e) -> e.getKey(),
                            (Map.Entry<K, V> e) -> e.getValue()));
}

public Map<Integer, String> removeRangeWithStream(Map<Integer, String> map, String from, String to) {
    return filter(map,
            (Map.Entry<Integer, String> e) -> e.getValue().compareTo(from) <= 0 || e.getValue().compareTo(to) >= 0);
}