Collection
概述
Collection 是所有容器集合的父类接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
它还是两个常用集合List&Set的父类接口
下面介绍常用方法示例
源码概述
public interface Collection<E> extends Iterable<E> {
//返回集合中的元素数量,返回值为int类型
int size();
//判断集合元素是否为空，空则true，否则为false
boolean isEmpty();
//判断是否包含指定元素，包含为true，否则false
boolean contains(Object o);
//返回一个迭代器接口，可以进行遍历集合
Iterator<E> iterator();
//将集合转换为一个数组对象
Object[] toArray();
//利用参数里的泛型数组对应集合的长度，根据数组参数比较集合参数，长度超出则打印null
<T> T[] toArray(T[] a);
//往集合里添加数据，参数为任意类型，返回值为布尔
boolean add(E e);
//根据参数指定元素，如果元素对应集合里的数据返回true，否则false
boolean containsAll(Collection<?> c);
//根据集合参数添加多个值
boolean addAll(Collection<? extends E> c);
//根据集合参数添加多个数据进行批量删除
boolean removeAll(Collection<?> c);
//根据Predicate过滤接口参数进行筛选
default boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
boolean removed = false;
final Iterator<E> each = iterator();
while (each.hasNext()) {
if (filter.test(each.next())) {
each.remove();
removed = true;
}
}
return removed;
}
//清除集合里的元素
void clear();
//比较此 collection 与指定对象是否相等。
boolean equals(Object o);
//返回当前集合的哈希值
int hashCode();
//用于遍历和分割“源”元素的对象。
@Override
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, 0);
}
//stream：返回一个stream流对象，可根据其方法操作集合
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
//parallelStream：和stream方法一样，parallelStream支持顺序流，线程不安全
default Stream<E> parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
}
代码演示
//这里创建一个集合
//由于这是个接口不能直接实例化,所以new实现类来演示
Collection<Object> collection = new ArrayList<>();
collection.add(233); //测试添加一条数据
size方法
int size = collection.size(); //获取集合的长度，也就是元素个数
System.out.println(size);//打印结果显示为1
isEmpty方法
boolean empty = collection.isEmpty();//判断集合元素是否为空，空则true，否则为false
System.out.println(empty);//集合为空打印为true
contains方法
boolean contains = collection.contains("Bear");//判断是否包含指定元素，包含为true，否则false
System.out.println(contains);//不包含Bear字符，结果为false
iterator
Iterator<Object> iterator = collection.iterator();// 返回一个迭代器接口
while(iterator.hasNext()) { //使用迭代器遍历集合数据
Object next = iterator.next();
System.out.println(next);//遍历集合中的元素
}
toArray:无参
Object[] objects = collection.toArray();//转换为一个数组
System.out.println(objects[0]);//获取打印第0号索引值
for (Object object : objects) {//使用增强for循环遍历数组
System.out.println(object);
}
toArray:有参
//利用参数里的对象集合对应Collection集合的长度，根据参数指定返回长度，长度超出则打印null
Object[] toArray = collection.toArray(new Object[]{233,"bear"});//集合里没有"bear"字段，打印第二个值显示为null
for (Object o : toArray) {
System.out.println(o);//超出Collection集合元素的长度，只显示233
}
add方法
System.out.println(collection.add(123));//往集合里添加数据,任意类型
System.out.println(collection.add("this is a add method"));//往集合里添加数据,字符串类型
System.out.println(collection.add('F'));//往集合里添加数据,char字符类型
remove方法
boolean remove = collection.remove(233);//移除指定的元素
System.out.println(remove);//打印为布尔值
containsAll方法
Collection<Object> obj = new ArrayList<>();
obj.add(233);
boolean b = collection.containsAll(obj);//根据新集合参数对应初始集合里的数据，对应则返回true，否则false
System.out.println(b);//两个集合数据对应，返回为true
addAll方法
Collection<Object> list = new ArrayList<>();//创建一个新集合
list.add(222);
list.add(233);
boolean addAll = collection.addAll(list);//根据集合参数添加多个值
System.out.println(addAll);//返回为true
System.out.println(collection);//打印集合内容
removeAll方法
Collection<Object> rem = new ArrayList<>();//创建一个新集合。批量移除集合元素
rem.add(222);//添加需要移除的元素
rem.add(233);
boolean removeAll = collection.removeAll(rem); //removeAll:根据集合参数添加多个数据进行批量删除
System.out.println(removeAll);
removeIf方法
//创建一个Person实体类
public class Person {
private Integer age;
public Person(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
'}';
}
}
-------------------- 方法使用 ----------------------
Collection<Person> coo = new ArrayList<Person>();//创建一个新集合，泛型为Person对象
coo.add(new Person(18));//new一个匿名Person对象
coo.add(new Person(19));
coo.removeIf(new Predicate<Person>() {
@Override
public boolean test(Person person) { //重写Predicate接口的test方法
return person.getAge() <10; //筛选掉对象Person对象年龄小于10的数据，不打印筛选结果
}
});
System.out.println(coo);//打印结果
-----------------------------------------------------------
//lambda简便格式
coo.removeIf(
person -> person.getAge() >10 //筛选掉对象Person对象年龄大于10的数据
);
System.out.println(coo);//打印结果
retainAll
Collection<Object> co = new ArrayList<>();
co.add(233);
co.add("Bear");//collection不存在这个值，所以不会打印
collection.retainAll(co); //这里使用旧集合调用retinAll方法，取得两个集合的交集,输出打印相同的数值
System.out.println(collection);
clear方法
//clear:清除集合所有数据
collection.clear();
System.out.println(collection);//清除过后则获取不到集合里的值
equals方法
Collection<Object> objects = new ArrayList<>();
objects.add(399); //比较的内容
objects.add("Bear"); //比较的内容
boolean equals = collection.equals(objects);//比较两个对象是否相同，返回值为布尔
System.out.println(equals);
hashCode方法
//hashCode:返回这个集合的哈希值
int Code = collection.hashCode();
System.out.println(Code);
spliterator方法
//spliterator:用于分割和遍历集合
Spliterator<Object> spliterator = collection.spliterator();//使用collection集合调用方法
System.out.println(spliterator.estimateSize());//获取集合的长度
spliterator.forEachRemaining(System.out::println);//遍历集合的数据
stream方法
//stream：返回一个stream流对象，可根据其方法操作集合
Stream<Object> stream = collection.stream();
stream.forEach(System.out::println);//使用forEach遍历集合元素
parallelStream方法
//parallelStream：和stream方法一样，parallelStream支持顺序流，线程不安全
Stream<Object> parallelStream = collection.parallelStream();
parallelStream.forEach(System.out :: println);