java - 过滤LinkedList的首选方法

TestListRemoveFunctional和TestListRemoveUpdateState类在LinkedList运行时执行过滤。

我认为TestListRemoveFunctional实现更干净，因为它不更新状态，但是效率较低，因为它在每个过滤步骤都创建了一个新List。

尽管TestListRemoveFunctional和TestListRemoveUpdateState本质上执行相同的工作，但与TestListRemoveUpdateState中的筛选实现不同，TestListRemoveFunctional更可取，因为它不更新状态。

请注意，我仅限于不使用java8 lambdas或项目Guava lambdas。

可以确认我的主张TestListRemoveFunctional是可取的吗？

import java.util.LinkedList;

public class TestListRemoveFunctional {

    public static void main(String args[]) {

        TestListRemoveFunctional t = new TestListRemoveFunctional();
        LinkedList<MyObj> l = new LinkedList<MyObj>();
        l.add(new MyObj("1"));
        l.add(new MyObj("2"));

        System.out.println("size : "+l.size());

        LinkedList<MyObj> f1 = t.filterItem1(l);
        System.out.println("size : "+f1.size());

        LinkedList<MyObj> f2 = t.filterItem2(f1);
        System.out.println("size : "+f2.size());
    }

    private LinkedList<MyObj> filterItem1(LinkedList<MyObj> l) {

        LinkedList<MyObj> toReturn = new LinkedList<MyObj>();
        for (MyObj myObj : l) {

            if (!myObj.param.equalsIgnoreCase("1")) {
                toReturn.add(myObj);
            }
        }
        return toReturn;
    }

    private LinkedList<MyObj> filterItem2(LinkedList<MyObj> l) {

        LinkedList<MyObj> toReturn = new LinkedList<MyObj>();
        for (MyObj myObj : l) {

            if (!myObj.param.equalsIgnoreCase("2")) {
                System.out.println(myObj.param);
                toReturn.add(myObj);
            }
        }
        return toReturn;
    }



    private static class MyObj {

        public String param;

        public MyObj(String param) {
            this.param = param;
        }
    }

}

********************************************************************************************


import java.util.Iterator;
import java.util.LinkedList;

public class TestListRemoveUpdateState {

    public static void main(String args[]) {

        TestListRemoveUpdateState t = new TestListRemoveUpdateState();
        LinkedList<MyObj> l = new LinkedList<MyObj>();
        l.add(new MyObj("1"));
        l.add(new MyObj("2"));

        System.out.println("size is : " + l.size());

        t.filterItem1(l);
        System.out.println("size is : " + l.size());

        t.filterItem2(l);
        System.out.println("size is : " + l.size());
    }

    private void filterItem1(LinkedList<MyObj> l) {

        Iterator<MyObj> iter = l.iterator();
        while (iter.hasNext()) {
            MyObj myObj = iter.next();

            if (myObj.param.equalsIgnoreCase("1")) {
                iter.remove();
            }
        }
    }

    private void filterItem2(LinkedList<MyObj> l) {

        Iterator<MyObj> iter = l.iterator();
        while (iter.hasNext()) {
            MyObj myObj = iter.next();

            if (myObj.param.equalsIgnoreCase("2")) {
                iter.remove();
            }
        }
    }

    private static class MyObj {

        public String param;

        public MyObj(String param) {
            this.param = param;
        }
    }

}

最佳答案

链接列表的优点之一是拥有非常有效的remove操作。

让我们考虑以下链表（在Java中，链表实际上是双链表）：

e1 <-> e2 <-> e3 <-> e4 <-> e5

如果要删除e3，只需要做的是：

e3.previous.next = e3.next;
e3.next.previous = e3.previous;
e3.next = null;
e3.previous = null;
e3.element = null;

这正是iterator.remove()的作用。

因此，TestListRemoveUpdateState效率更高，因为您正在处理LinkedList



附带说明，ArrayList上的首选方法是TestListRemoveFunctional。

如果要对ArrayList进行过滤，则TestListRemoveFunctional会比TestListRemoveUpdateState效率更高，因为ArrayList上的remove操作每次被调用时都会重新创建一个完整的支持数组（即使System.arrayCopy非常有用）。高效）。

关于java - 过滤LinkedList的首选方法，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/28049810/