精华内容
下载资源
问答
  • java中遍历集合删除元素方法

    千次阅读 2019-04-26 14:32:27
    报错示例一: ...3、第二种遍历删除直接使用迭代器进行遍历,而且删除时使用的迭代器的删除元素方法,这个删除方法里面会对位置索引进行调整,使得迭代器在继续遍历查找下一个元素时,不会抛出异常错误。

    报错示例一:

    List<String> list = new ArrayList<>();
    
    list.add("1");
    list.add("2");
    list.add("3");
    list.add("4");
    
    for(String str : list){
        if(!str.equals("1")) {
            list.remove(str);
        }
    }
    System.out.println(list.size());

    错误使用二:这种情况不会报错,因为最后一个元素未被遍历到就程序跳出了循环遍历

    List<String> list = new ArrayList<>();
    
    list.add("1");
    list.add("2");
    list.add("3");
    
    for(String str : list){
        if(!str.equals("1")) {
            list.remove(str);
        }
    }
    System.out.println(list.size());

    方法一:for循环遍历

    List<String> list = new ArrayList<>();
    
    list.add("1");
    list.add("2");
    list.add("3");
    
    for (int i = 0; i < list.size(); i++) {
        String item = list.get(i);
        if("2".equals(item)) {
            //逻辑判断,剔除满足条件的元素
            list.remove(item);
            //元素删除后,后面的元素位置向前挪一位,位置索引i需要自减一,否则访问不到后面的元素
            i--;
        }
    }
    System.out.println(list.size());

    方法二:使用集合的迭代器

    List<String> list = new ArrayList<>();
    
    list.add("1");
    list.add("2");
    list.add("3");
    
    for(Iterator<String> it = list.iterator(); it.hasNext(); ){
        if("2".equals(it.next())) {
            //使用迭代器的删除方法,不要使用集合对象的删除方法remove
            it.remove();
        }
    }
    System.out.println(list.size());

    原因说明:

    1、如果使用增强for循环进行遍历,那么实际上使用的是集合的迭代器进行遍历,这时如果使用的是集合对象自己的删除方法,迭代器不知道元素集合发生了变化,进行获取下一个元素的时候就会爆出错误:ConcurrentModificationException,但这里有一点需要注意,如果遍历过程中第一个被删除的元素处在倒数第二个被遍历的位置时,程序不会报错,正常结束。实际的结果是:集合中最后一个元素之前,会调用迭代器的hasNext()方法,该方法发现当前位置索引等于集合元素数量,判断遍历结束,跳出循环,实则最后一个元素未被遍历到。

    2、第一种遍历删除方法,是自己控制并调整元素位置索引,只要位置索引控制正确,就可以正常删除元素,否则会出现IndexOutOfBoundsException

    3、第二种遍历删除直接使用迭代器进行遍历,而且删除时使用的迭代器的删除元素方法,这个删除方法里面会对位置索引进行调整,使得迭代器在继续遍历查找下一个元素时,不会抛出异常错误。

    展开全文
  • Java 遍历集合删除元素

    千次阅读 2018-08-03 17:08:05
    Java 遍历集合删除元素? 问题及分析 正确删除集合元素 问题及分析 注:在浏览阿里巴巴Java开发手册时,自己测试Java遍历集合并删除元素时发现有些巧合以及总结 先写开发手册里一个例子,大家猜一下以下...
    • 问题及分析
    • 正确删除集合元素

    问题及分析

    注:在浏览阿里巴巴Java开发手册时,自己测试Java遍历集合并删除元素时发现有些巧合以及总结

    先写开发手册里一个例子,大家猜一下以下代码的输出

    List<String> list = new ArrayList<>();
    list.add("1");
    list.add("2");
    list.add("3");
    
    System.out.println("list original size is " + list.size());
    
    for (String item : list) {
        if ("1".equals(item)) {
            list.remove(item);
        }
    }
    
    System.out.println("list size is " + list.size());
    List<String> list = new ArrayList<>();
    list.add("1");
    list.add("2");
    list.add("3");
    
    System.out.println("list original size is " + list.size());
    
    for (String item : list) {
        if ("1".equals(item)) {
            list.remove(item);
        }
    }
    
    System.out.println("list size is " + list.size());

    上面两个例子的输出结果是什么?意外吗?
    1,2可以成功;1, 2, 3删除抛出异常

    • 第一个:
      list original size is 2
      list size is 1
    • 第二个:
      list original size is 3
      java.util.ConcurrentModificationException

    我们可以看一下此处代码的反编译代码:

    List<String> list = new ArrayList();
    list.add("1");
    list.add("2");
    // list.add("3");
    System.out.println("list original size is " + list.size());
    Iterator var2 = list.iterator();
    
    while(var2.hasNext()) {
        String item = (String)var2.next();
            if ("1".equals(item)) {
                list.remove(item);
            }
    }
    
    System.out.println("list size is " + list.size());

    通过查看反编译代码,发现我们使用的foreach遍历仍然是迭代器Iterator遍历,而ArrayList中Iterator源码:

     private class Itr implements Iterator<E> {
         int cursor;       // index of next element to return
         int lastRet = -1; // index of last element returned; -1 if no such
         int expectedModCount = modCount;
    
         Itr() {}
    
         public boolean hasNext() {
             return cursor != size;   // 游标
         }
    
         @SuppressWarnings("unchecked")
         public E next() {
             checkForComodification();   // 检查是否并发修改
             int i = cursor;
             if (i >= size)
                 throw new NoSuchElementException();
             Object[] elementData = ArrayList.this.elementData;
             if (i >= elementData.length)
                 throw new ConcurrentModificationException();
             cursor = i + 1;  // 游标后移
             return (E) elementData[lastRet = i];
         }
    
         public void remove() {
             if (lastRet < 0)
                 throw new IllegalStateException();
             checkForComodification();
    
             try {
                 ArrayList.this.remove(lastRet);
                 cursor = lastRet;
                 lastRet = -1;
                 expectedModCount = modCount;   // 修改预期值(迭代器删除的重要参考)
             } catch (IndexOutOfBoundsException ex) {
                 throw new ConcurrentModificationException();
             }
         }
         ......
      }
    

    modCount是集合添加,删除等改变集合结构的次数(改变集合大小),expectedModCount是预期的变化次数;
    分析一下:
    [“1”, “2”] : 当”1”被遍历删除后,游标cursor的值从0变为1,集合长度也变为1,这是hasNext返回false,比较表示没有下一个元素,结束遍历;
    [“1”, “2”, “3”] : 如上,当”1”遍历删除后,游标cursor从0变为1,集合长度变为2,hasNext返回true,执行remove时,checkForComodification()方法验证是否同时修改,此方法表modCount != expectedModCount,modCount是3,expectedModCount也是3,而在删除后modCount变为4,而hasNext()方法不返回false,next()方法调用时就会抛出异常;
    注:由其游标变化规律可以看出,如果hasNext提前结束,不执行后面的next取数据,就可以删除集合元素,故可以删除集合中倒数第二个元素而不抛出异常(实践也如此)


    正确删除集合元素

    • 迭代器方式
     public void positiveForEachTest() {
          List<String> list = new ArrayList<>();
          list.add("w");
          list.add("li");
          list.add("z");
    
          System.out.println("list original size is " + list.size());
    
          Iterator<String> iterator = list.iterator();
          while (iterator.hasNext()) {
              String item = iterator.next();
              if ("li".equals(item)) {
                  iterator.remove();
              }
          }
    
          System.out.println("after list remove elem `li`, it's size is " + list.size());
      }
    展开全文
  • java Collection集合删除某一元素方法汇总

    千次阅读 多人点赞 2016-09-13 11:22:32
    无论在自己写程序玩还是实际项目应用中,操作java.util.Collection结合都是最常用的,而且也是最重要的...下面总结了从集合删除某一元素的几种方法 package test; import java.text.MessageFormat; import java.util

    无论在自己写程序玩还是实际项目应用中,操作java.util.Collection结合都是最常用的,而且也是最重要的知识点。从集合中删除某一元素同样是很常用的操作。对了,面试中也总考察,面试官说要考察你的实际编程的能力,谁知道呢。下面总结了从集合中删除某一元素的几种方法

    package test;
    
    import java.text.MessageFormat;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Locale;
    import java.util.function.Predicate;
    
    public class T {
    
    	public static void main(String[] args) {
    		//对于list添加数据,也有几种方法,性能不同,有兴趣可以自己详细了解
    		List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5));
    		
    		//List<Integer> list = new ArrayList<>();
    		//Collections.addAll(list,1,2,3,4,5);
    	 
    		remove(list, 3);
    		print(list);
    	}
    	
    	public static void print(List<Integer> list) {
    		/*for (Integer i : list) {
    			System.out.println(i);
    		}*/
    		
    		/**
    		 * 利用java8新特性打印集合信息
    		 */
    		list.stream().forEach(System.out::println);
    	}
    	
    	/**
    	 * 删除集合某一元素的方法汇总
    	 * @param list
    	 * @param toRemoveValue
    	 * @return
    	 */
    	public static List<Integer> remove(List<Integer> list, int toRemoveValue) {
    		/**
    		 * 方法1,利用java.util.Iterator删除某一个元素
    		 */
    		for (Iterator<Integer> iterator=list.iterator();iterator.hasNext();) {
    			int value = iterator.next();
    			if(value == toRemoveValue) {
    				iterator.remove();
    			}
    		}
    		//----------------------------------------------------------------------------
    		/**
    		 * 方法2,利用操作集合索引删除某一个元素
    		 */
    		for (int i = 0; i < list.size(); i++) {
    			int value = list.get(i);
    			if(value == toRemoveValue) {
    				list.remove(i);
    				i--;
    			}
    		}
    		
    		//----------------------------------------------------------------------------
    		/**
    		 * 方法3,利用反向遍历集合删除某一个元素
    		 */
    		for (int i = list.size() - 1;i > 0; i--) {
    			int value = list.get(i);
    			if(value == toRemoveValue) {
    				list.remove(i);
    			}
    		}
    		
    		//----------------------------------------------------------------------------
    		/**
    		 * 方法4,利用增加一个新集合删除某一个元素
    		 */
    		List<Integer> toRemoveList = new ArrayList<>();
    		for (int i = 0; i < list.size(); i++) {
    			int value = list.get(i);
    			if(value == toRemoveValue) {
    				toRemoveList.add(value);
    			}
    		}
    		
    		list.removeAll(toRemoveList);
    		
    		//----------------------------------------------------------------------------
    		/**
    		 * 方法5,利用break取巧删除某一个元素,实际应用不常用
    		 */
    		for (int i = 0; i < list.size(); i++) {
    			int value = list.get(i);
    			if(value == toRemoveValue) {
    				list.remove(i);
    				break;
    			}
    		}
    		
    		//----------------------------------------------------------------------------
    		/**
    		 * 方法6,利用java8新特性删除某一个元素
    		 */
    		list.removeIf(value -> value==toRemoveValue);
    		
    		//----------------------------------------------------------------------------
    		/**
    		 * 方法7,利用java8新特性的forEach()方法删除某一个元素,其实不是删除,是过滤
    		 */
    		list.stream().filter(value -> value!=toRemoveValue).forEach(System.out::println);
    		
    		//----------------------------------------------------------------------------
    		/**
    		 * 方法8,利用java8新特性的forEach()方法删除某一个元素,其实不是删除,是过滤,等同上一种写法
    		 */
    		list.stream().forEach(value -> { if(value!=toRemoveValue) System.out.println(value);});
    		
    		
    		return list;
    	}
    
    }
    




    展开全文
  • 一、list集合循环删除元素 1.通过普通的for删除删除符合条件的多个元素 for(int i=0;ilist.size();i++){ if(list.get(i).equals("del")) list.remove(i); } 上面这种方式会抛出java.lang....

    一、list集合循环删除元素

    1.通过普通的for删除删除符合条件的多个元素
    for(int i=0;i<list.size();i++){
        if(list.get(i).equals("del"))
            list.remove(i);
    }
    

    上面这种方式会抛出java.lang.IndexOutOfBoundsException异常。这种方式的问题在于,删除某个元素后,list的大小发生了变化,而你的索引也在变化。假设被遍历list中共有10个元素,当删除了第3个元素后,第4个元素就变成了第3个元素了,第5个就变成了第4个了,但是程序下一步循环到的索引是第4个,这时候取到的就是原本的第5个元素了。这样当迭代到最后一个的时候就会抛异常。因此,这种方式可以用在删除特定的一个元素时使用,但不适合循环删除多个元素时使用。
      可以对上面的程序进行如下改进:

    for(int i=0,len=list.size();i< len;i++){
        if(list.get(i).equals("del")){
           list.remove(i);
           --len;//减少一个
           //此时要注意,因为list会动态变化不像数组会占位,所以当前索引应该后退一位
           --i;
         }
    }
    
    2.通过增强的for循环删除符合条件的元素
    for(String x:list){
        if(x.equals("del"))
            list.remove(x);
    }
    

    上面这种方式在循环过程中从List中删除数据以后,继续循环List时会导致List的next()方法内部出现modCount和expectedModCount不一致(modCount++,而expectedCount值未变),导致抛出ConcurrentModificationException,导致抛出异常。

    modCount是List对象的一个成员变量,它代表该List对象被修改的次数,每对List对象修改一次,modCount都会加1。而expectedModCount是Iterator类里的一个成员变量,创建迭代器的时候将当时的modCount赋值给expectedModCount,随后迭代过程中会检查这个值,一旦发现这个值发生变化,就说明你对容器做了修改,就会抛异常。

    删除完毕马上使用break跳出,则不会触发报错。

    for(String x:list){
        if(x.equals("del")){
            list.remove(x);
            break;
        }
    }
    
    3.过Iterator进行遍历删除符合条件的元素

    使用Iterator的方式可以顺利删除和遍历

    Iterator<String> it = list.iterator();
    while(it.hasNext()){
        String x = it.next();
        if(x.equals("del")){
            it.remove();
        }
    }
    

    这种方式可以正常的循环及删除。但要注意的是,使用iterator的remove方法,如果用list的remove方法同样会报上面提到的ConcurrentModificationException错误。
      迭代器iterator的remove()方法不仅会删除元素,还会维护一个标志,用来记录目前是不是可删除状态。例如,你不能连续两次调用它的remove()方法,调用之前至少有一次next()方法的调用。但是要注意的是:list.remove()只是删除元素,可是不会改变原有元素的位置。比如有 0 1 2 3 4 5这六个元素,我删除掉3这个元素,则4还是处于第四个位置,不会跳到第三个位置。

    4.用一个List 记录要删除的数据,最后removeAll(List);
    List<Integer> removeList = new ArrayList()  
    for(Integer i : intList)  
    {  
        if(i == 13)  
        {  
            removeList.add(i);  
        }  
    }  
    //最后  
    if(removeList.size()>0)  
    {  
        intList.removeAll(removeList);  
    }  


    作者:水桶的魔法
    链接:https://www.jianshu.com/p/5091d03720a4
    來源:简书

    展开全文
  • List集合删除元素的正确姿势

    万次阅读 2018-06-18 16:14:40
    作为Java大家庭中的集合类框架,List应该是平时开发中最常用的,可能有这种需求,当集合中的某些元素符合一定条件时,想要删除这个元素。如:[java] view plain copy print?public&amp;nbsp;class&amp;nbsp;...
  • List集合删除元素的时候删除不掉

    千次阅读 2016-03-25 22:57:47
    今天博主遇到了List集合删除元素失败的问题,由于自以为对集合比较了解,所以首先排除集合删除的语句的错误 Integer index = 1; list.remove(index); 但是错误就是出现在集合中,我的本意是集合删除下标为制定数据的...
  • js 遍历集合删除元素

    千次阅读 2019-04-09 10:12:00
    js 遍历集合删除元素 /** * 有效的方式 - 改变下标,控制遍历 */ for (var i = 0; i < arr.length; i++) {  if (...) {  arr.splice(i, 1); // 将使后面的元素依次前移,数组长度减1  i--; // ...
  • list集合添加元素,删除元素

    千次阅读 2018-03-26 14:33:37
    遍历 list 集合,删除满足条件元素的同时,也在添加元素:使用迭代器遍历删除时,会报异常: ConcurrentModificationException原因:当方法检测到对象的并发修改,但不...同时给遍历集合删除元素的代码,加同步锁。...
  • java list集合元素删除方法小结

    千次阅读 2017-11-07 11:10:00
    印象中循环删除list中的元素使用for循环的方式是有问题的,但是可以使用增强的for循环,然后今天在使用时发现报错了,然后去科普了一下,再然后发现这是一个误区。下面就来讲一讲。。伸手党可直接跳至文末。看总结。...
  • List集合删除元素,该怎么删除?

    千次阅读 2016-07-04 22:29:37
    大家发现没有,如果使用list的remove()方法,想要把list集合里的b元素删除,会导致上述的情况发生(该情况是需要删除元素都是相邻的元素,用代码解释就是list.get(i).equals(list.get(i+1))==true, 这样在移除b(i=3...
  • 一、List遍历过程中删除元素 使用索引下标遍历的方式 public static void main(String[] args) { List<Integer> list = new ArrayList<Integer>(); list.add(1); list.add(2); list.add(2); ...
  • java 中List 集合删除元素

    千次阅读 2014-03-24 18:09:44
    今天做一个排班的功能;设计的时候需要实现从一个list集合删除一个object的操作; for (HumanWorkTime hwt: hwtList) {  if (hwt.getId().equals(tempId)) {  hwtList.remove(hwt);  
  • java集合遍历删除元素

    千次阅读 2019-06-17 15:48:57
    java集合遍历删除的几种方式 1、for循环遍历list for(int i=0;i<list.size();i++){ if(list.get(i).equals("del")) list.remove(i); } 这种方式的问题在于,删除某个元素后,list的大小发生了变化,而你的...
  • Java集合删除元素的正确操作

    千次阅读 2019-04-18 09:48:38
    //删除元素 Iterator < Map . Entry < String , String > > it = map . entrySet ( ) . iterator ( ) ; while ( it . hasNext ( ) ) { Map . Entry < String , String > entry = it . next ( ) ;...
  • 它的添加和删除元素的相关方法比较多,容易混淆,这里简单总结下。 add,remove,addFirst,addLast,removeFirst,removeLast,pollFirst,pollLast,offerFirst,offerLast等方法看名字就知道添加和删除的顺序,就不举例了...
  • System.out.println("删除之前List的大小:"+list.size()); Iterator<String> stringIterator=list.iterator(); while(stringIterator.hasNext()){ String s=stringIterator.next(); if(s.equals("c")){...
  • js数组添加元素和数组方法js数组添加、修改、删除元素和数组方法集合数组添加、修改、删除元素数组合并功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一...
  • 1.问题描述: 今天遇到一个问题,就是在前端想要...通过查资料,集合存在动态删除元素方法——splice() 2.具体解决方式: for(var k = 0;k&lt; curThis.List.length;k++){ if(curThis.List[k].Status ==...
  • java中集合删除元素的两种常用方式及新手易错: 创建集合: ArrayList aList = new ArrayList(); aList.add("a"); aList.add("b"); aList.add("c"); aList.add("abc"); aList.add("abc"); aList.add(...
  • java中循环遍历删除集合list中的元素 java删除集合List中的元素 一、问题描述 1、 假设有这么一个集合,代码如下: List<java.sql.Connection> connList=new ArrayList<java.sql.Connection>(10);...
  • 循环集合方法有三种: 简单for循环 iterator循环 增强for循环 例子如下: List fList = new ArrayList(); fList.add(1L); fList.add(2L); fList.add(3L); fList.add(4L); // 简单for循环 ...
  • 问题:在我们使用java开发的过程中可能会遇到这样的问题,删除List集合中与已知元素 相同的所有元素;比如下面这个需求: 删除List集合中字符串为“edf”的所有记录案例:方案一:你可能回想到使用forEach遍历,...
  • 集合元素删除

    千次阅读 2010-05-25 17:05:00
    集合元素删除 最近在工作中遇到一个问题,就是要在集合中Remove一个指定的Object,一开始犯了一个很可笑的错误,比如一个ArrayList array中有如下元素:”a”,”b”,”c”,”d”,”e”,要Remove其中的”c” ...
  • 删除集合中特定元素的几种情况

    千次阅读 2019-01-23 15:44:35
    集合删除元素一直是一个比较容易遗漏的知识点,今天来给大家介绍一下删除集合​​中特定元素的一些情况。 ​(一)List如何实现遍历删除 以ArrayList为例  List&lt;String&gt; a1 = new ArrayList...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 448,071
精华内容 179,228
关键字:

集合删除元素的方法