精华内容
下载资源
问答
  • java map删除元素的正确作法

    千次阅读 2020-06-03 10:02:41
    当使用map时有一种情形,想把符合某个条件的元素删除,最直观的想法就是遍历这个map,当符合时就remove,实现起来如下 for(String index:aMap.keySet()) { String s = aMap.get(index); if (s == null) { aMap...

    当使用map时有一种情形,想把符合某个条件的元素删除,最直观的想法就是遍历这个map,当符合时就remove,实现起来如下

            for(String index:aMap.keySet()) {
                String s = aMap.get(index);
                if (s == null) {
                    aMap.remove(index);
                }
            }
    

    但是运行之后就抛了异常ConcurrentModificationException,原因应该就是当remove之后keySet集合已变了,不能再根据它遍历了。

    那么正确的方法是什么呢?就是用迭代器的方式。示例如下:

            for (Iterator<Map.Entry<String, String>> it = aMap.entrySet().iterator(); it.hasNext();){
                Map.Entry<String, String> item = it.next();
                if(item.getValue()==null) {
                    it.remove();
                }
            }

     

    展开全文
  • Map map=new LinkedHashMap();
    Map map=new LinkedHashMap();
    展开全文
  • 一、List遍历过程中删除元素 使用索引下标遍历的方式 public static void main(String[] args) { List<Integer> list = new ArrayList<Integer>(); list.add(1); list.add(2); list.add(2); ...

    一、List遍历过程中删除元素

     

    使用索引下标遍历的方式

    public static void main(String[] args) {
      List<Integer> list = new ArrayList<Integer>();
      list.add(1);
      list.add(2);
      list.add(2);
      list.add(3);
      list.add(4);
       
      for (int i = 0; i < list.size(); i++) {
       if(2 == list.get(i)){
        list.remove(i);
       }
       System.out.println(list.get(i));
      }
       
      System.out.println("list=" + list.toString());
       
     }

    输出结果:      

    1
    2
    3
    4
    list=[1, 2, 3, 4]

     

    这种方式的问题在于,删除某个元素后,list的大小发生了变化,而你的索引也在变化,所以会导致你在遍历的时候漏掉某些元素。比如当你删除第1个元素后,继续根据索引访问第2个元素时,因为删除的关系后面的元素都往前移动了一位,所以实际访问的是第3个元素。因此,这种方式可以用在删除特定的一个元素时使用,但不适合循环删除多个元素时使用。

     

     

     

    使用增强for循环的方式

    public static void listIterator2(){
      List<Integer> list = new ArrayList<Integer>();
      list.add(1);
      list.add(2);
      list.add(2);
      list.add(3);
      list.add(4);
       
      for (int value : list) {
       if(2 == value){
        list.remove(value);
       }
       System.out.println(value);
      }
       
      System.out.println("list=" + list.toString());
       
     }

    输出结果:

    Exception in thread "main" 1
    2
    java.util.ConcurrentModificationException
     at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
     at java.util.ArrayList$Itr.next(Unknown Source)
     at test.ListIterator.listIterator2(ListIterator.java:39)
     at test.ListIterator.main(ListIterator.java:10)

     

    说明:

    jdk中对ConcurrentModificationException的描述:

    public class ConcurrentModificationException extends

    RuntimeException当方法检测到对象的并发修改,但不允许这种修改时,抛出此异常。

    例如,某个线程在 Collection 上进行迭代时,通常不允许另一个线性修改该 Collection。通常在这些情况下,迭代的结果是不确定的。如果检测到这种行为,一些迭代器实现(包括 JRE 提供的所有通用 collection 实现)可能选择抛出此异常。执行该操作的迭代器称为快速失败 迭代器,因为迭代器很快就完全失败,而不会冒着在将来某个时间任意发生不确定行为的风险。

    注意:此异常不会始终指出对象已经由不同 线程并发修改。如果单线程发出违反对象协定的方法调用序列,则该对象可能抛出此异常。例如,如果线程使用快速失败迭代器在 collection 上迭代时直接修改该 collection,则迭代器将抛出此异常。

    注意:迭代器的快速失败行为无法得到保证,因为一般来说,不可能对是否出现不同步并发修改做出任何硬性保证。快速失败操作会尽最大努力抛出 ConcurrentModificationException。因此,为提高此类操作的正确性而编写一个依赖于此异常的程序是错误的做法,正确做法是:ConcurrentModificationException 应该仅用于检测 bug。

    Java中的For each实际上使用的是iterator进行处理的。而iterator是不允许集合在iterator使用期间删除的。所以导致了iterator抛出了ConcurrentModificationException

     

     

     

    正确的方式(使用Iterator)

    public static void listIterator3(){
      List<Integer> list = new ArrayList<Integer>();
      list.add(1);
      list.add(2);
      list.add(2);
      list.add(3);
      list.add(4);
       
      Iterator<Integer> it = list.iterator();
      while (it.hasNext()){
       Integer value = it.next();
       if (2 == value) {
        it.remove();
       }
        
       System.out.println(value);
      }
       
      System.out.println("list=" + list.toString());
     }

    结果:

    1
    2
    2
    3
    4
    list=[1, 3, 4]

            这种方式可以正常的循环及删除。但要注意的是,使用iterator的remove方法,如果用list的remove方法同样会报上面提到的ConcurrentModificationException错误。

     

      

     

    二、Map遍历过程中删除元素

     

    public static void main(String[] args) {
     HashMap<String, String> map = new HashMap<String, String>();
     map.put("1", "test1");
     map.put("2", "test2");
     map.put("3", "test3");
     map.put("4", "test4");
      
     //完整遍历Map
     for (Entry<String, String> entry : map.entrySet()) {
      System.out.printf("key: %s value:%s\r\n", entry.getKey(), entry.getValue());
     }
      
     //删除元素
     Iterator<Map.Entry<String, String>> it = map.entrySet().iterator(); 
     while(it.hasNext()){ 
      Map.Entry<String, String> entry= it.next(); 
      String key= entry.getKey(); 
      int k = Integer.parseInt(key);
      if(k%2==1){ 
       System.out.printf("delete key:%s value:%s\r\n", key, entry.getValue());
       it.remove(); 
      } 
     } 
      
     //完整遍历Map
     for (Entry<String, String> entry : map.entrySet()) {
      System.out.printf("key: %s value:%s\r\n", entry.getKey(), entry.getValue());
     }
    }

    结果:

    key: 1 value:test1
    key: 2 value:test2
    key: 3 value:test3
    key: 4 value:test4
    delete key:1 value:test1
    delete key:3 value:test3
    key: 2 value:test2
    key: 4 value:test4

     

    注意

    但对于iterator的remove()方法,也有需要我们注意的地方:

    每调用一次iterator.next()方法,只能调用一次remove()方法。

    调用remove()方法前,必须调用过一次next()方法。

    JDK-API中对于remove()方法的描述:

    void remove()从迭代器指向的集合中移除迭代器返回的最后一个元素(可选操作)。每次调用 next 只能调用一次此方法。如果进行迭代时用调用此方法之外的其他方式修改了该迭代器所指向的集合,则迭代器的行为是不明确的。

    抛出:UnsupportedOperationException - 如果迭代器不支持 remove 操作。IllegalStateException - 如果尚未调用 next 方法,或者在上一次调用 next 方法之后已经调用了remove 方法。

    总结

    以上就是关于List与Map的遍历过程中删除元素的全部内容了,希望本文的内容对大家的学习或者工作能带来一定的帮助,如果有疑问大家可以留言交流。

     

     

     

    展开全文
  • Java遍历List、Map添加、删除元素

    千次阅读 2019-06-04 14:04:59
    本文主要演示遍历List、Map时的添加、删除元素操作。 关于List和Map相关的遍历问题,笔者已在《Java常用数据结构基础知识总结(二)》一文中做了简要介绍,如有需要的可以参考,此处不再赘述。 源码如下: 1.基于...

             本文主要演示遍历List、Map时的添加、删除元素操作。
             关于List和Map相关的遍历问题,笔者已在《Java常用数据结构基础知识总结(二)》一文中做了简要介绍,如有需要的可以参考,此处不再赘述。

    源码如下:

    1.基于List的操作

    package com.ldl.cn.test;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    import java.util.ListIterator;
    
    public class TestList {
    
        public static void main(String[] args) {
            
            List<String> list = new ArrayList<>();
            list.add("1");
            list.add("2");
            list.add("3");
    //        byFor(list);
    //        byForEach(list);
    //        byIterator(list);
    //        byListIterator(list);
        }
        
        private static void byFor(List<String> list){
            
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).equals("2")) {
    //            list.remove(i); //OK
    //            list.add("666"); //OK
            }
        }
            System.out.println(list);
        }
        
        private static void byForEach(List<String> list){
            
        for (String string : list) {
            if (string.equals("2")) {
    //            list.remove(string);//OK
    //            list.add("666"); //java.util.ConcurrentModificationException
            }
        }
            System.out.println(list);
        }
        
        private static void byIterator(List<String> list){
            
            if (list.isEmpty()) {
                return ;
            }
            
            Iterator<String> iterator = list.iterator();
            while (iterator.hasNext()) {
                String string = iterator.next();
                if (string.equals("1")) {
    //                list.remove(string); //java.util.ConcurrentModificationException
    //                iterator.remove();//OK
                }
                
    //            if (string.equals("2")) {
    //                list.add("555"); //java.util.ConcurrentModificationException
    //            }
            }
            System.out.println(list);
        }
        
        private static void byListIterator(List<String> list){
            ListIterator<String> iterator = list.listIterator();
            while (iterator.hasNext()) {
    //            if (iterator.next().equals("2")) {
    //                iterator.remove();
    //            }//OK
                
    //            if (iterator.next().equals("1")) {
    //                iterator.add("666");
    //            }//OK  注意不能同时使用remove和add
            }
            System.out.println(list);
        }
    }

    2.基于Map的操作

    package com.ldl.cn.test;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    
    public class TestMap {
    
        public static void main(String[] args) {
    
                Map<String, Object> map = new HashMap<>();
                map.put("1", "111");
                map.put("2", "222");
                map.put("3", "333");
            
    //            byFor(map);
    //            byIterator(map);
                byIterator2(map);
        }
        
        private static void byFor(Map<String, Object> map){
                if (map.isEmpty()) {
                    return;
                }
                for (Map.Entry<String, Object> entry : map.entrySet()) {
                    if (entry.getValue().equals("111")) {
                        map.remove(entry.getKey()); //java.util.ConcurrentModificationException
                    }
                }
                System.out.println(map);
        }
        
        private static void byIterator(Map<String, Object> map){
            
            Iterator<String> iterator = map.keySet().iterator();
            while (iterator.hasNext()) {
                if (map.get(iterator.next()).equals("111")) {
                    iterator.remove(); //OK
                }
            }
            System.out.println(map);
        }
        
        private static void byIterator2(Map<String, Object> map){
            Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();
            while (iterator.hasNext()) {
                Map.Entry<String, Object> entry = iterator.next();
                if (entry.getValue().equals("111")) {
                    iterator.remove();//OK
    //                map.put(entry.getKey(), entry.getValue()+"666");//OK
                }
            }
            System.out.println(map);
        }
        
    }

    读者可以尝试运行,运行结果在源码中以注释体现。

    展开全文
  • java Map常用方法封装

    千次阅读 2018-07-16 16:08:00
    java Map常用方法封装 CreationTime--2018年7月16日15点59分 Author:Marydon 1.准备工作 import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; ...
  • java Map接口定义和常用方法

    千次阅读 2018-11-07 22:36:37
    java Map接口定义和常用方法1.Map接口的定义2.Map常用方法 1.Map接口的定义 Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value Map 中的 key 和 value 都可以是任何引用类型的数据 Map 中的 key...
  • Java Map遍历的同时进行元素删除

    千次阅读 2015-02-06 21:54:17
    import java.util.Map; import java.util.TreeMap; import java.util.Set; import static com.hutao.util.Print.*; import java.util.HashSet; public class Main { public static void main(String[] arg
  • Java根据条件删除Map元素

    万次阅读 2014-12-14 16:52:41
    今天在写程序过程中,需要根据判断条件删除一个Map中的相应数据,我自然而然想到可以通过调用Map中的remove(Object key)函数进行删除:代码如下: public Map processMap(Map list) { Map map = list; Iterator ...
  • Java map

    万次阅读 2017-12-04 19:30:11
    Java8增强的Map集合Map接口中定义了如下常用的方法。 void clear():删除该Map对象中的所有key-value对。 boolean containsKey(Object key):查询Map中是否包含指定的key,如果包含则返回true。 boolean contains...
  • java.util.Map——Map集合的常用方法

    万次阅读 多人点赞 2018-05-07 12:53:20
    Map集合用于储存元素对,Map储存的是一对键值(key和value),是通过key映射到它的value;下面介绍的是Map集合的一些经常用到的方法以及代码示例。 1.map.size(); 方法作用:获取map集合类的大小(m...
  • Java中的map集合顺序如何与添加顺序一样

    万次阅读 多人点赞 2017-05-24 14:47:54
    一般使用map用的最多的就是hashmap,但是hashmap里面的元素是不按添加顺序的,那么除了使用hashmap外,还有什么map接口的实现类可以用呢? 这里有2个,treeMap和linkedHashMap,但是,要达到我们的要求:按添加顺序...
  • java中的集合框架是我们日常使用得最多的数据结构,而List作为Collection里最重要的一员,使用就更加的频繁了。因此我们平时使用中少不了对List的增删改查,本文就针对于对List的“删”操作进行一个分析,顺便说几个...
  • Map java中的map 如何修改Map中的对应元素
  • java合并元素map的list

    千次阅读 2018-08-01 16:56:05
    list的元素信息如下图所示: {GLRS=0, BMMC=部门1, XCZY=57}, {GLRS=7, BMMC=部门1, XCZY=0}, {GLRS=0, BMMC=部门2, XCZY=14}, {GLRS=4, BMMC=部门2, XCZY=0}, {GLRS=0, BMMC=部门3, XCZY=66}, {GLRS=9, BMMC...
  • Java map集合深入学习

    万次阅读 多人点赞 2018-10-29 00:12:48
    Map 提供了一个更通用的元素存储方法Map 集合类用于存储元素对(称作“键”和“值”),其中每个键映射到一个值。 本文主要介绍java map的初始化、用法、map的四种常用的遍历方式、map的排序以及常用api。 目录 ...
  • JavaMap中的map.keySet()方法

    千次阅读 多人点赞 2019-03-28 20:27:46
    今天再代码中看到了Map集合中的HashMap的map.keySet()方法,首先看一下这个方法的定义 /** * Returns a {@link Set} view of the keys contained in this map. * The set is backed by the map, s...
  • JAVA Map 遍历Map 集合 map 的嵌套

    千次阅读 2017-12-21 21:43:40
    一、 Map 数据保存 是以 键值对形势 存储的(key – value) 键是唯一的(不能重复的) HashSet 和 HashMap 之间的关系 ... 在向HashSet 中添加的值 相当于往Map添加到Key 的位置 HashSet 和 TreeSet 去重
  • java8 Map中新增的方法介绍

    千次阅读 2019-05-07 18:25:55
    相信大家都有看到,在 java8 后,大量的方法都包含两个单词,ifAbsent 和 ifPresent。 absent 表示缺席,理解为当前不存在 即 ifAbsent 在map中主要意思就是 如果 get(key) == null 执行 present 表示当下,理解为...
  • Java基础 | Map常用方法

    千次阅读 2017-06-01 21:23:27
    Map常用方法 Map map = new HashMap(); //创建map Map iMap = new HashMap(); iMap.put("狂人日记","鲁迅") map.put("家","巴金"); //添加一个键值对,如果key已存在就覆盖,且返回被覆盖的值 map.put("朝花夕...
  • Java8 Map 中新增的方法使用记录

    千次阅读 2018-11-01 14:53:18
    得益于 Java 8 的 default 方法特性,Java 8 对 Map 增加了不少实用的默认方法,像 getOrDefault, forEach, replace, replaceAll, putIfAbsent, remove(key, value), computeIfPresent, computeIfAbsent...
  • java Map遍历的5种方法和一些基本使用

    万次阅读 多人点赞 2018-04-04 16:29:42
    Map&lt;String, Integer&gt; map = new HashMap&lt;&gt;(); map.put("a", 1); map.put("b", 2); boolean b = map.containsKey("3");//map中是否包含key为3...
  • Dart Map<> 添加 元素

    千次阅读 2019-04-02 16:38:00
    Map<String, WidgetBuilder> routesList() {  Map<String, WidgetBuilder> re = new Map<String, WidgetBuilder>();  for (var i = 0; i < RoutesData.key.length; i++) {  re.p...
  • 其中的add方法返回值是boolean类型 基本返回值都是true(因为通过源码我们可以看到它通过是否修改原有集合来返回true或者false,而多数情况下,List内容可以重复,所以相当于它的内容始终在改变,所以返回为true) ...
  • Java Map集合的详解

    万次阅读 多人点赞 2016-07-27 21:43:33
    Map是一种依照键(key)存储元素的容器,键(key)很像下标,在List中下标是整数。在Map中键(key)可以使任意类型的对象。Map中不能有重复的键(Key),每个键(key)都有一个对应的值(value)。 一个键(key)和...
  • Map java中的map 如何修改Map中的对应元素Map以按键/数值对的形式存储数据,和数组非常相似,在数组中存在的索引,它们本身也是对象。 Map的接口 Map---实现Map Map.Entry--Map的内部类,描述Map中的按键/...
  • 获取LinkedHashMap中的头部元素(最早添加元素):时间复杂度O(1) public <K, V> Entry<K, V> getHead(LinkedHashMap<K, V> map) { return map.entrySet().iterator().next(); } 获取...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 184,477
精华内容 73,790
关键字:

javamap添加元素的方法

java 订阅