Java List.remove删除奇数元素

这可能是显而易见的，但无法合理化此代码段的输出。 参考：

公共类示例{
公共静态void main（字符串[]args）{
Set=新树集（）；
列表=新的ArrayList（）；
for（int i=-3；i<3；i++）{
增加（i）；
列表.添加（i）；
}
System.out.println（“添加元素后：”）；
System.out.println（set+“”+列表）；
对于（int i=0；i<3；i++）{
设置。移除（i）；
列表。删除（i）；
}
System.out.println（“删除元素后：”）；
System.out.println（set+“”+列表）；
}
}

输出：

添加元素后：

[3，-2，-1,0,1,2][-3，-2，-1,0,1,2]

删除元素后：

[3，-2，-1][2,0,2]

我期待着：

删除元素后：

[3，-2，-1][0,1,2]

---

i、 删除（i）应实际删除列表中的第一项、第二项和第三项。足够公平吗？

删除第一个元素时，会更改元素在列表中的位置，因此代码的行为是有意义的：

e、 g

for (int i = -3; i < 3; i++) {
    set.add(i);
    list.add(i);
}
System.out.println("After adding elements:");
System.out.println(set + " " + list);

for (int i = 0; i < 3; i++) {
    set.remove(i);
    list.remove(i);
}

---

不，下面一行：

 set.remove(i);

获取您传递的int类型并将其框到Integer对象（），然后它使用Integer equals（）方法确定必须删除哪个元素。之所以会发生这种情况，是因为在

remove（int index）

集合中没有这样的方法，而只有

remove（Object o）

，这意味着必须“以某种方式”将基元类型转换为对象，在Java中，每个基元类型都有一个包装器类型，“转换”称为自动装箱。请注意，还有一种“现象”称为取消装箱：）

---

您在列表中的位置会随着每次删除而改变。只需删除位置“0”的3倍。

如果是您指定的

集合

，则它实际上从集合中删除值

0

、

1

和

2

。因此，您将得到剩余的元素作为结果

对于指定的

列表

，它实际上从列表中删除索引

0

、

1

和

2

处的值。因此，您将得到剩余的元素作为结果。其工作原理如下：

Initially (i=0): [-3, -2, -1, 0, 1, 2]
                   ^
                   X 
Step 1 (i=1): [-2, -1, 0, 1, 2]
                    ^
                    X
Step 2 (i=2): [-2, 0, 1, 2]
                      ^
                      X
Result:       [-2, 0, 2]

---

有没有想过用函数式编程的方式来实现它

//确保为matcher和lambdaj添加静态导入以模拟以下代码

import static ch.lambdaj.Lambda.*;
import static org.test.matcher.MatcherFactory.*;   //this can be anything

    List<Integer> original = Arrays.asList(1,2,3,4,5,6);

    List<Integer> oddList = filter(odd, original);

   for(int s : oddList){
    System.out.println(s);
    }
   //and it prints out   1,3,5

导入静态ch.lambdaj.Lambda.*；
导入静态org.test.matcher.MatcherFactory.*//这可以是任何东西
List original=Arrays.asList（1,2,3,4,5,6）；
列表oddList=过滤器（奇数，原始）；
用于（int s:oddList）{
系统输出打印项次；
}
//然后打印出1,3,5

并创建一个名为MatcherFactory.java的类

public class MatcherFactory {

    public static Matcher<Integer> odd = new Predicate<Integer>() {
        public boolean apply(Integer item) {
                return item % 2 == 1;
            }
    };

   //put as many as matchers you want and reuse them
}

公共类MatcherFactory{
公共静态匹配器奇数=新谓词（）{
公共布尔应用（整数项）{
返回项目%2==1；
}
};
//放置尽可能多的匹配器，并重复使用它们
}

您可以从这里下载lambdaj库

---

请参阅更多示例

+1。我只是好奇，

set.remove（0）

和

list.remove（0）

在循环内部解决问题了吗？或者它仍然有一个未定义的行为？（难看的解决办法……但我只是在想……）@Marounnaroun：我想会的。

Initially (i=0): [-3, -2, -1, 0, 1, 2]
                   ^
                   X 
Step 1 (i=1): [-2, -1, 0, 1, 2]
                    ^
                    X
Step 2 (i=2): [-2, 0, 1, 2]
                      ^
                      X
Result:       [-2, 0, 2]

import static ch.lambdaj.Lambda.*;
import static org.test.matcher.MatcherFactory.*;   //this can be anything

    List<Integer> original = Arrays.asList(1,2,3,4,5,6);

    List<Integer> oddList = filter(odd, original);

   for(int s : oddList){
    System.out.println(s);
    }
   //and it prints out   1,3,5

public class MatcherFactory {

    public static Matcher<Integer> odd = new Predicate<Integer>() {
        public boolean apply(Integer item) {
                return item % 2 == 1;
            }
    };

   //put as many as matchers you want and reuse them
}