精华内容
下载资源
问答
  • List集合删除元素的时候删除不掉

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

        今天博主遇到了List集合删除元素失败的问题,由于自以为对集合比较了解,所以首先排除集合删除的语句的错误

    Integer index = 1;
    list.remove(index);

    但是错误就是出现在集合中,我的本意是集合删除下标为制定数据的那一项内容,传入的index是Integer类型的,所以List集合就是调用的是remove(Object object)这个方法,而不是remove(int index),所以会出现删除不掉的问题,传入的一定要是基本数据类型哦!

    要这么用:

    int index = 1;
    list.remove(index);
    这里对我犯的错做一个总结和记录
    展开全文
  • List集合删除元素的正确姿势

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

    在阅读阿里巴巴规约的时候发现有一条规约是关于List的【不要在foreach里面进行元素的remove/add操作,remove请使用Iterator方式】。然后想起以前自己做项目的时候删除某一元素的逻辑报下标越界错误,那时候记得处理是用一新的List进行存储,然后整体从原List移除所有符合规则的元素,现在做一总结。用这个Iterator主要可以避免下标越界或者遍历是漏掉符合规则的下一个数据。

    先拉出来正确删除元素的姿势。正确姿势是利用Iterator的remove方法。具体操作如下:

    public static void main(String[] args) {
            List<Integer> lists = new ArrayList<Integer>();
            lists.add(1);
            lists.add(2);
            lists.add(3);
            lists.add(4);
            lists.add(5);
            Iterator<Integer> iterator = lists.iterator();
            while (iterator.hasNext()){
                Integer obj = iterator.next();
                if(3==obj || 4==obj){
                    iterator.remove();
                }
            }
            System.out.println(lists);
    
        }

    附上自己比较笨的操作方式:

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

    然后常用的错误方式有以下三种:
    第一种方式,多出现下标越界问题。这个主要原因是因为我们在循环遍历时,将我们的长度进行定值确定。而忽略掉在满足条件时,list的长度是减少的。

    public static void main(String[] args) {
     List<Integer> lists = new ArrayList<Integer>();
            lists.add(1);
            lists.add(2);
            lists.add(3);
            lists.add(4);
            lists.add(5);
            int size = lists.size();  // 定长设置,会造成元素下标越界,如果将for中变量直接换成lists.size()可以吗?
            for (int i = 0; i < size; i++) {
                if(3==lists.get(i) || 4 == lists.get(i)){
                    lists.remove(i); //lists.remove(lists.get(i));
                }
            }
            System.out.println(lists);
     }

    第二种方式也就是上面的注释所说,既然会出现下标越界,那我就利用动态的大小不就可以了,但是利用这种方法会产生另外一种情况,就是会忽略掉remove元素后面的一个元素,这个是因为删除符合规则的元素后,list长度减一,而同时后面的元素往前补一位,造成当前i值下对应两个元素。

    public static void main(String[] args) {
            List<Integer> lists = new ArrayList<Integer>();
            lists.add(1);
            lists.add(2);
            lists.add(3);
            lists.add(4);
            lists.add(5);
            int size = lists.size();
            for (int i = 0; i < lists.size(); i++) {
                if(3==lists.get(i) || 4 == lists.get(i)){
                    lists.remove(i); //lists.remove(lists.get(i));
                }
            }
            System.out.println(lists); // 打印[1, 2, 4, 5] 此时会将4忽略掉
        }

    第三种方式是利用增强FOR循环造成的。这种方式会直接给报错:

    ERRORInfo:
    Exception in thread "main" java.util.ConcurrentModificationException
        at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
        at java.util.ArrayList$Itr.next(ArrayList.java:851)
    
    
    public static void main(String[] args) {
            List<Integer> lists = new ArrayList<Integer>();
            lists.add(1);
            lists.add(2);
            lists.add(3);
            lists.add(4);
            lists.add(5);
           for (Integer i : lists){
               if(3==i || 4==i){
                   lists.remove(i);
               }
           }
            System.out.println(lists);
        }

    这种情况下。主要是集合遍历是使用Iterator, Iterator是工作在一个独立的线程中,并且拥有一个互斥锁。Iterator 被创建之后会建立一个指向原来对象的单链索引表,当原来的对象数量发生变化时,这个索引表的内容不会同步改变,所以当索引指针往后移动的时候就找不到要迭代的对象,所以按照 fail-fast原则 Iterator 会马上抛出java.util.ConcurrentModificationException 异常。所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。

    【 文章有查询:高爽|Coder,原文地址:http://blog.csdn.net/ghsau/article/details/9347357。】

    展开全文
  • List集合删除元素,该怎么删除?

    千次阅读 2016-07-04 22:29:37
    package com.zz.web.controller;import java.util.ArrayList; import java.util.Iterator;public class TestDelList { public static void main(String[] args) { ArrayList<String> list = new ArrayLis
    package com.zz.web.controller;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    
    public class TestDelList {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<String>();
            ArrayList<String> lists = new ArrayList<String>();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("b");
            list.add("b");
            list.add("e");
            list.add("b");
            list.add("d");
            lists.addAll(list);
            //此处先使用list的remove()方法
            for (int i = 0; i < list.size(); i++) {
                if (list.get(i).equals("b")) {
                    list.remove(i);
                }
                System.out.println(list.toString() + list.size());
            }
            //下面使用Iterator的remove()方法是跟上面做一个对比
            Iterator<String> it = lists.iterator();
            while (it.hasNext()) {
                String string = (String) it.next();
                if (string.equals("b")) {
                    it.remove();
                }
                System.out.println("w" +lists.toString()+ lists.size());
            }
        }
    }
    运行后的结果是:
    [a, b, c, b, b, e, b, d]8
    [a, c, b, b, e, b, d]7
    [a, c, b, e, b, d]6
    [a, c, b, e, b, d]6
    [a, c, b, e, d]5
    w[a, b, c, b, b, e, b, d]8
    w[a, c, b, b, e, b, d]7
    w[a, c, b, b, e, b, d]7
    w[a, c, b, e, b, d]6
    w[a, c, e, b, d]5
    w[a, c, e, b, d]5
    w[a, c, e, d]4
    w[a, c, e, d]4

    大家发现没有,如果使用list的remove()方法,想要把list集合里的b元素删除,会导致上述的情况发生(该情况是需要删除的元素都是相邻的元素,用代码解释就是list.get(i).equals(list.get(i+1))==true, 这样在移除b(i=3时)元素的时候该节点都被删除了,后面的元素就会往前移动一位,当循环下一个i=2的时候list.get(4)的值不是b元素了而是e元素);而使用迭代器Iteratoer去遍历该list集合用迭代器的remove方法就不会导致该问题出现
    为什么用list的remove()就不可以呢?我找了源码才发现它实际上调用的是另一个方法:

    private void fastRemove(int index)
        {
            modCount++;
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index, numMoved);
            elementData[--size] = null; 
        }

    看出来什么了吗?有一个数组复制的方法:
    public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
    src:源数组;
    srcPos:源数组要复制的起始位置;
    dest:目的数组;
    destPos:目的数组放置的起始位置;
    length:复制的长度。
    注意:src and dest都必须是同类型或者可以进行转换类型的数组。

    由此看出为什么会前移一位吗?
    (其实最主要的原因不在这里,最主要的原因是其中有一个计数器modCount还有期望被修改次数expectedModCount),当使用list.remove()的时候,该modCount会加1而expectedModCount是0,Iterator.remove()却不会,是因为在Iterator的remove方法中它将modCount=expectedModCount)具体见下面的文章,我就不一一解释了。仔细看完保证你有收获!

    更多详情请参照我参考的关于list和Iterator的remove方法区别文章Blog地址 ↓↓↓↓↓

    http://www.cnblogs.com/dolphin0520/p/3933551.html

    展开全文
  • java 中List 集合删除元素

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

    今天做一个排班的功能;

    设计的时候需要实现从一个list集合中  删除一个object的操作;

    for (HumanWorkTime hwt: hwtList) {
                            if (hwt.getId().equals(tempId)) {
                                hwtList.remove(hwt);
                            }
                        }
    

    然后就抛出了错误;

    SEVERE: Servlet.service() for servlet [spring] in context with path [/edu] threw exception [Request processing failed; nested exception is java.util.ConcurrentModificationException] with root cause
    java.util.ConcurrentModificationException

    理论上应该没错呀;

    dubug;

       发现  代码hwtList.remove(hwt) 并没有抛出错误;

    纳闷。。。

    逐句查看    发现是在执行过hwtList.remove(hwt)之后, 进入下一个循环的时候  抛错,  

    仔细观察了一下 , 发现执行过删除操作后  list的size发生改变

    恍然大悟, 肯定是集合的长度改变引起的, 所以改成下面的代码,运行通过 


    for(int i = 0, len = hwtList.size(); i < len; i++) {
                            if (hwtList.get(i).getId().equals(tempHwId)){
                                hwtList.remove(hwtList.get(i));
                                len--;
                                i--;
                            }
                        }


    展开全文
  • list集合添加元素,删除元素

    千次阅读 2018-03-26 14:33:37
    遍历 list 集合,删除满足条件元素的同时,也在添加元素:使用迭代器遍历删除时,会报异常: ConcurrentModificationException原因:当方法检测到对象的并发修改,但不...同时给遍历集合删除元素的代码,加同步锁。...
  • java中循环遍历删除集合list中的元素 java删除集合List中的元素 一、问题描述 1、 假设有这么一个集合,代码如下: List<java.sql.Connection> connList=new ArrayList<java.sql.Connection>(10);...
  • java list集合元素删除方法小结

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

    千次阅读 2019-05-28 17:48:49
    JAVA中循环遍历list有三种方式for循环、增强for循环(也...1.for循环删除元素 List<String> list = new ArrayList<String>(); list.add("1"); list.add("2"); list.add("3"); list.add("4");...
  • Java删除List集合中的重复元素

    千次阅读 2018-01-12 10:45:33
    Java实现删除List集合中的重复元素的方法有很多种,本文只介绍几种常用的方法。简单起见,本例中List的泛型皆为String类型,如果泛型为类,去重方法类似。 1、使用HashSet的无重复的特性,只是去重后的List不能保持...
  • 关于List集合remove删除元素的问题

    千次阅读 2018-10-23 14:03:26
    List&lt;String&gt; list = new ArrayList&lt;String&gt;(); list.add("abc"); list.add("abc"); list.add("abc"); list.add("abc"); list.add(&...
  • java中List遍历删除元素

    万次阅读 2019-03-29 14:25:33
    List<String> list = new ArrayList<>(); list.add("a"); list.add("b"); list.add("c"); list.add("d"); list.add("e"); list.add("d"); ...
  • Java 遍历集合删除元素

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

    千次阅读 热门讨论 2021-01-18 14:16:03
    如何删除一个集合对象中的特定元素?小问题,但并不简单。 常见异常: ConcurrentModificationException java.util.ConcurrentModificationException at java.util.ArrayList$Itr.checkForComodification(ArrayList...
  • (1)定义List集合,存入多个字符串,其中包含三个连续的”def” (2)删除集合中字符串”def” (3)然后利用迭代器遍历集合元素并输出 代码如下: import java.util.ArrayList; import java.util.Iterator; ...
  • JAVA遍历List集合删除其中的元素

    千次阅读 2013-07-19 14:10:15
    JAVA遍历List集合删除其中的元素 这里的两个方法主要用在需要遍历删除集合中符合某一条件的元素的情况下,如果要删除List集合中所有的元素的话,直接用List接口中的clear()方法或者直接让它的值为null就行了。 ...
  • 遍历list集合时同时添加和删除元素

    千次阅读 2019-08-13 19:57:12
    最近码代码时遇到一个坑,遍历一个集合,遍历过程中要删除和新增元素,原代码如下 List list = new ArrayList(); list.add("a"); list.add("b"); list.add("c"); list.add("d"); Iterator lit = list.iterator(); ...
  • 一、List遍历过程中删除元素 使用索引下标遍历的方式 public static void main(String[] args) { List<Integer> list = new ArrayList<Integer>(); list.add(1); list.add(2); list.add(2); ...
  • import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class TestIterator { public static void main(String[] args) { List list=new ArrayList(); list.add("a"); l
  • 1.想删除list集合中某个元素,首先list不能用for循坏遍历来删除,需要用迭代循坏,其次,需要在迭代循坏中将要删除元素添加到一个新的list集合中(创建一个list集合),然后在迭代循坏外整体删除这个新的list集合...
  • java中list集合删除其中的某一个元素

    万次阅读 2019-12-13 09:32:24
    //定义list List<User> list = new ArrayList<>(); User user1 = new User(); User user2 = new User(); user1.serName("111"); user2.serName("222"); list.add(user1); list.ad...
  • js 遍历集合删除元素

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 255,795
精华内容 102,318
关键字:

list集合删除元素