一段有趣的重载代码

Question

重载

Answer 1

set remove的是对象，list remove的是下标

Answer 2

for (int i = 0; i < 3; i++) {
set.remove(i);
list.remove(0);  //你指的有意思，是在说此处？
}

Answer 3

是的，remove 重载了，remove(int a)   和remove (Integer a)

Answer 4

因为HashSet没有      int为参数的remove 方法。
ArrayList有

Answer 5

做了一些修改，可以了。如果你要删除set,或者list里面的元素,最好用string座位其类型,这样不容易让JVM搞混淆了。 list.remove(i);//因为你要删除的是int,而jvm不知道你需要删除的是值.
            在jdk中是这么定义remove方法的:                \\\\\\\jvm将你的意思理解成了下面这种\\\\\\\\\
                public E remove(int index)
                移除此列表中指定位置上的元素。向左移动所有后续元素（将其索引减 1）。
                **********************实质上你想用的是下面这样的***********************                public boolean remove(Object o)
                移除此列表中首次出现的指定元素（如果存在）。
                如果列表不包含此元素，则列表不做改动。
                更确切地讲，移除满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引的元素（如果存在此类元素）。
                如果列表中包含指定的元素，则返回 true（或者等同于这种情况：如果列表由于调用而发生更改，则返回 true）。
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;/**
 * Created by Administrator on 2014/8/13.
 */
public class Test {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<Integer>();
        List<Integer> list = new ArrayList<Integer>();        for (int i = 0; i < 6; i++) {
            set.add(i);
            list.add(i);
        }
        System.out.println("removed set: "+set.toString());
        System.out.println("removed list: "+list.toString());
        for (int i = 0; i < 3; i++) {
            System.out.println("----------- set: "+set.toString());
            System.out.println("------------ list: "+list.toString());
            set.remove(i);
            list.remove(new Integer(i));
            /*
            list.remove(i);//因为你要删除的是int,而jvm不知道你需要删除的是值.
            在jdk中是这么定义remove方法的:                \\\\\\\jvm将你的意思理解成了下面这种\\\\\\\\\
                public E remove(int index)
                移除此列表中指定位置上的元素。向左移动所有后续元素（将其索引减 1）。
                **********************实质上你想用的是下面这样的***********************                public boolean remove(Object o)
                移除此列表中首次出现的指定元素（如果存在）。
                如果列表不包含此元素，则列表不做改动。
                更确切地讲，移除满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引的元素（如果存在此类元素）。
                如果列表中包含指定的元素，则返回 true（或者等同于这种情况：如果列表由于调用而发生更改，则返回 true）。             */
        }
        System.out.println("removed set: "+set.toString());
        System.out.println("removed list: "+list.toString());
    }
}
运行结果:removed set: [0, 1, 2, 3, 4, 5]
removed list: [0, 1, 2, 3, 4, 5]
----------- set: [0, 1, 2, 3, 4, 5]
------------ list: [0, 1, 2, 3, 4, 5]
----------- set: [1, 2, 3, 4, 5]
------------ list: [1, 2, 3, 4, 5]
----------- set: [2, 3, 4, 5]
------------ list: [2, 3, 4, 5]
removed set: [3, 4, 5]
removed list: [3, 4, 5]Process finished with exit code 0

Answer 6

你这样删的是按下标来的，可以这样 list.remove(new Integer(i));，这样删的就是对象了，传的的参数是不一样的

Answer 7

remove方法重载了，你怎么确定调用的是下面那个方法呢？

Answer 8

remove方法重载了，你怎么确定调用的是下面那个方法呢？
你传入i是一个int,会默认为第一个参数,而new Integer()相当于新创建了一个对象,自然就是Object类型的了

Answer 9

那关重载事，
那是自动装箱。
public class Testb { public static void main(String[] args) {
// TODO Auto-generated method stub
//new Testb().dox("2");
new Testb().dox(2);
}

/*
public void dox(int a){
System.out.println("do1");
}
*/
/*
public void dox(Integer a){
System.out.println("do2");
}
*/
public void dox(Object a){
System.out.println("do3");
}

public void dox(String a){
System.out.println("do4");
}

}

Answer 10

Set和list的实现机制本来就是这样的

Answer 11

ArrayList中有两种remove方法，对比下就知道区别了。
public Object remove(int i)
    {
        rangeCheck(i);
        modCount++;
        Object obj = elementData(i);
        int j = size - i - 1;
        if(j > 0)
            System.arraycopy(((Object) (elementData)), i + 1, ((Object) (elementData)), i, j);
        elementData[--size] = null;
        return obj;
    }    public boolean remove(Object obj)
    {
        if(obj == null)
        {
            for(int i = 0; i < size; i++)
                if(elementData[i] == null)
                {
                    fastRemove(i);
                    return true;
                }        } else
        {
            for(int j = 0; j < size; j++)
                if(obj.equals(elementData[j]))
                {
                    fastRemove(j);
                    return true;
                }        }
        return false;
    }

Answer 12

哟，开始的时候我没发现，这 i 改成0 是妙笔呀。如此即可实现本来的意图：去除 0 1  2。
有点trick的感觉。

Answer 13

这是最最最容易掉坑里的地方了。
List<Integer>.remove(int);大部分人写这段代码的本意，可能是按照元素删除，殊不知，由于java的泛型，按照元素删除其实还是remove(Object)；而int或者Integer的参数，更接近remove(int)而不是remove(Object)。所以，编译时候，直接编译到按下标删除。

Answer 14

只有dox(Integer a) 时就装箱，但是dox(Integer a) 和dox(int a) 同时有就重载了，编译器会选dox(int a)

Answer 15

哟，开始的时候我没发现，这 i 改成0 是妙笔呀。如此即可实现本来的意图：去除 0 1  2。
有点trick的感觉。我后来经你启发，想了想，其实也可以这么搞的for (Integer i = 0; i < 3; i++) {  //把int换成Integer，这样也更容易理解
set.remove(i);
list.remove(i); 
}

Answer 16

昨天就因为这个remove掉坑里了，还好爬的快

Answer 17

涨姿势！明天去翻API和源码，现在去洗洗睡觉。大神们晚安！