解析Collection接口中的常用的被实现子类重写的方法

1 添加单个元素方法

1.1 使用方法

Collection接口的间接实现子类.add(E e);
//返回值类型为布尔类型,若增加成功,则返回true,若增加不成功,则返回false
//对于List接口下面的实现子类,一般只要增加元素都会返回true
//对于Set接口下面的实现子类,若增加重复的元素,则返回false,因为会Set接口下面的实现子类的元素的特点是无序不可重复
//默认是添加在集合中已经存在的有效元素的后一个位置,若集合无有效元素,则添加的位置为0
1
2
3
4
5

1.2 List接口下面的实现子类示例代码

package Work;
import java.util.List;
import java.util.ArrayList;
public class Test07 {
    public static void main(String[] args) {
        List arr=new ArrayList();
        arr.add(1);
        System.out.println(arr.add(1));
    }

}

1
2
3
4
5
6
7
8
9
10
11
12

1.3 List接口下面的实现子类示例代码运行截图

1.4 Set接口下面的实现子类的示例代码

package Work;
import java.util.HashSet;
import java.util.Set;
public class Test07 {
    public static void main(String[] args) {
        Set arr=new HashSet();
        arr.add(1);
        System.out.println(arr.add(1));
    }

}
1
2
3
4
5
6
7
8
9
10
11

1.5 Set接口下面的实现子类的示例代码运行截图

2 删除指定元素

2.1 使用方法

Collection接口的间接实现子类.remove(Object o);
//返回值类型为布尔,若有这个元素,则删除成功返回true,若没有这个元素,则显示删除失败返回false
//理解:因为你传入的实参是一个对象,所以无需告知你删除的是啥东西,只需要返回是否删除成功就行了
1
2
3

2.2 示例代码

package Work;
import java.util.List;
import java.util.ArrayList;
public class Test07 {
    public static void main(String[] args) {
        List arr=new ArrayList();
        arr.add("1234");
        System.out.println(arr.remove("1456"));
        System.out.println(arr.remove("1234"));
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13

2.3 示例代码运行截图

3 查找元素是否存在

3.1 使用方法

Collection接口的实现间接子类.contains(Object 0);
//如果该集合包含Object对象,那么就会返回true,如果不包含,就会返回false
1
2

3.2 底层分析

3.2.1 底层源码(ArrayList集合为例)

public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12

3.2.2 结论

contains方法底层是调用equals方法进行比较的,若自定义类没有重写equals方法,默认就是使用Object里面的equals方法,默认比较的是内存地址,而这不是我们想要的结果

因此,自定义类一定要重写equals方法

3.3 示例代码

package Work;
import java.util.List;
import java.util.ArrayList;
import java.util.Objects;

public class Test07 {
    public static void main(String[] args) {
        List arr=new ArrayList();
        arr.add(new Book01("三国演义",13,"罗贯中"));
        arr.add(new Book01("红楼梦",15,"曹雪芹"));
        arr.add(new Book01("西游记",16,"吴承恩"));
        System.out.println(arr.contains(new Book01("三国演义",13,"罗贯中")));
        System.out.println(arr.contains(new Book01("三国演义",15,"罗贯中")));
    }

}
class Book01{
    private String name;
    private double price;
    private String author;

    public Book01() {
    }

    public Book01(String name, double price, String author) {
        this.name = name;
        this.price = price;
        this.author = author;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Book01 book01 = (Book01) o;
        return Double.compare(book01.price, price) == 0 && Objects.equals(name, book01.name) && Objects.equals(author, book01.author);
    }


    @Override
    public String toString() {
        return "Book01{" +
                "name='" + name + '\'' +
                ", price=" + price +
                ", author='" + author + '\'' +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

3.4 示例代码运行截图

4 获取集合里面有效元素的个数

4.1 使用方法

Collection接口下面的间接实现子类.size();
//返回值类型为int类型,返回的是实现类里面有效元素的个数,注意不是Object[] elementData的长度
1
2

4.2 示例代码

package Work;
import java.util.List;
import java.util.ArrayList;
import java.util.Objects;

public class Test07 {
    public static void main(String[] args) {
        List arr=new ArrayList();
        arr.add("wskfdh");
        arr.add(12);
        //实际上发生了自动装箱
        arr.add(14);
        System.out.println(arr.size());
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4.3 示例代码运行截图

5 判断集合里面有效元素的个数是否为0

5.1 使用方法

Collection接口的间接实现子类.isEmpty();
//返回值为布尔类型,若集合里面的有效元素个数为0,则返回true,否则返回false
1
2

5.2 示例代码

package Work;
import java.util.List;
import java.util.ArrayList;
public class Test07 {
    public static void main(String[] args) {
        List arr=new ArrayList();
        System.out.println("添加元素之前");
        System.out.println(arr.isEmpty());
        arr.add("wskfdh");
        System.out.println("添加元素之后");
        System.out.println(arr.isEmpty());
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5.3 示例代码运行截图

6 清空集合里面所有的有效元素

6.1 使用方法

Collection接口的间接实现子类对象.clear();
//返回值为void类型
1
2

6.2 示例代码

package Work;
import java.util.List;
import java.util.ArrayList;
public class Test07 {
    public static void main(String[] args) {
        List arr=new ArrayList();
        System.out.println("清空元素之前");
        arr.add("wskfdh");
        System.out.println(arr.isEmpty());
        System.out.println("清空元素之后");
        arr.clear();
        System.out.println(arr.isEmpty());
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6.3 示例代码运行截图

7 添加多个元素

7.1 使用方法

Collection接口的间接实现子类对象.addAll(Collection c);
//返回值为布尔类型,一般传入一个Collection接口的实现子类的返回值结果就为true
//就算有重复的元素也一样,只是该元素加不进去而已,并不影响返回值结果的
//添加进入的集合元素会转换成调用者的这个集合类型
//如果是List下面的实现类,就添加到集合有效元素的后一个位置
1
2
3
4
5

7.2 示例代码

package Work;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;
import java.util.HashSet;
public class Test07 {
    public static void main(String[] args) {
        Set arr=new HashSet();
        arr.add("12");
        arr.add("66");
        ArrayList arrayList=new ArrayList();
        arrayList.add("13");
        arrayList.add("12");
        arrayList.add("14");
        System.out.println("有重复元素的添加结果为:");
        System.out.println(arr.addAll(arrayList));
        System.out.println("添加后arr的结果为:");
        Iterator iterator = arr.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println(next);
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

7.3 示例代码运行截图

8 查看多个元素是否都存在

8.1 使用方法

Collection接口的间接实现子类对象.containsAll(Collection c);
//如果包含传入集合里面的所有元素,那就返回true,否则返回false
1
2

8.2 示例代码

package Work;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;
import java.util.HashSet;
public class Test07 {
    public static void main(String[] args) {
        Set arr=new HashSet();
        arr.add("12");
        arr.add("66");
        ArrayList arrayList=new ArrayList();
        arrayList.add("13");
        arrayList.add("12");
        System.out.println("查找结果为:"+arr.containsAll(arrayList));
        System.out.println("移除传入参数里面的特有元素后:");
        arrayList.remove("13");
        System.out.println("查找结果为:"+arr.containsAll(arrayList));
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

8.3 示例代码运行截图

9 删除多个元素

9.1 使用方法

Collection接口的间接实现子类对象.removeAll(Collection c);
//返回为true.只要删除成功一个,就返回true
1
2

9.2 示例代码

package Work;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test07 {
    public static void main(String[] args) {
        List arr = new ArrayList();
        arr.add("12");
        arr.add("66");
        ArrayList arrayList = new ArrayList();
        arrayList.add("13");
        arrayList.add("12");
        //只要删除成功集合里面的一个元素就返回true,否则就返回false;添加元素的也一样
        System.out.println("删除结果为:" + arr.removeAll(arrayList));
        Iterator iterator = arr.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println(next);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

9.3 示例代码运行截图