Java的集合框架—API文档深入研究2.0

目录

Java的集合框架

1、添加功能

boolean add(Object obj)

boolean addAll(Collection c)

2、删除功能 

boolean remove(Object o)

boolean removeAll(Collection c)

void clear()

3、获取功能

Iterator iterator()

boolean hasNext()

Object next()

4、判断功能

boolean contains(Object o)

boolean containsAll(Collection c)

boolean isEmpty()

5、获取长度功能

int size()

6、求交集功能

boolean retainAll(Collection c)

7、将集合转换成数组

Object[] toArray()


Java的集合框架

接下来我们来对Java的Collection参照API文档进行详细的分析:

1、添加功能

boolean add(Object obj)

查看API文档我们知道:

boolean add(E e)

确保此集合包含指定的元素(可选操作)。 如果此集合由于调用而更改,则返回true 。 (如果此集合不允许重复,并且已包含指定的元素,则返回false。 )

支持此操作的集合可能会限制可能添加到此集合的元素。 特别是一些集合拒绝添加null种元素,和其他人将强加可添加元素的类型限制。 收集类应在其文档中明确说明可能添加哪些元素的限制。

如果一个集合拒绝添加一个特定的元素,除了它已经包含该元素之外,它必须抛出异常(而不是返回false )。 这保留了一个集合在此调用返回后始终包含指定元素的不变量。

参数

e - 要确保在此集合中的存在的元素

结果

true如果此集合由于调用而更改

异常

UnsupportedOperationException - 如果此 集合不支持add操作

ClassCastException - 如果指定元素的类阻止将其添加到此集合

NullPointerException - 如果指定的元素为空,并且该集合不允许空元素

IllegalArgumentException - 如果元素的某些属性阻止其添加到此集合

IllegalStateException - 如果由于插入限制,此时无法添加该元素

 即确保此集合包含自定的元素(可选操作),反之抛出异常。

参考代码:

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTestDemo1 {
    public static void main(String[] args) {

        //通过子类的形式创建对象,这叫接口多态
        Collection c = new ArrayList();

        //boolean add(Object obj) 确保此集合包含指定的元素(可选操作)。
        System.out.println(c.add("hello"));
        System.out.println(c.add("hadoop"));
        c.add(20);
        c.add(31.41);
        
        System.out.println("集合c:" + c);
    }
}

输出结果:

true
true
集合c:[hello, hadoop, 20, 31.41] 


boolean addAll(Collection c)

查看API文档我们知道:

public interface Collection<E>
extends Iterable<E>

集合层次结构中的根界面 。 集合表示一组被称为其元素的对象。 一些集合允许重复元素,而其他集合不允许。 有些被命令和其他无序。 JDK不提供此接口的任何直接实现:它提供了更具体的子接口的实现,如Set和List 。 该界面通常用于传递集合,并在需要最大的通用性的情况下对其进行操作。

多重集 (可能包含重复元素的无序集合)应直接实现此接口。

所有通用的Collection实现类(通常通过其子接口间接实现88446144404803)应提供两个“标准”构造函数:一个void(无参数)构造函数,它创建一个空集合,以及一个构造函数, Collection ,它创建一个与其参数相同的元素的新集合。 实际上,后一个构造函数允许用户复制任何集合,生成所需实现类型的等效集合。 没有办法强制执行此约定(因为接口不能包含构造函数),而是所有Java平台库中的通用Collection实现。

包含在该界面中的“破坏性”的方法,即,修改其经营的收集方法,被指定抛出UnsupportedOperationException如果此collection不支持该操作。 如果是这样的话,可能会,但不要求这些方法,抛出一个UnsupportedOperationException如果调用会对收集没有影响。 例如,如果要添加的集合为空,则可以在不可修改的集合上调用addAll(Collection)方法,但不是必须抛出该异常。

Some collection implementations have restrictions on the elements that they may contain.例如,一些实现禁止空元素,有些对它们的元素的类型有限制。 尝试添加不合格元素会引发未经检查的异常,通常为NullPointerException或ClassCastException 。 尝试查询不合格元素的存在可能会引发异常,或者可能只是返回false; 一些实现将展现出前者的行为,一些实现将展现出后者。 更一般来说,尝试对不符合条件的元素进行操作,其完成不会导致将不合格元素插入到集合中可能会导致异常,或者可能会成功执行该选项。 此异常在此接口的规范中标记为“可选”。

每个集合决定自己的同步策略。 在没有实现的更强保证的情况下,未定义的行为可能是由于对由另一个线程进行突变的集合的任何方法的调用而导致的; 这包括直接调用,将集合传递给可能执行调用的方法,并使用现有的迭代器来检查集合。

在集合框架接口的许多方法在来定义equals方法。 例如,对于在本说明书contains(Object o)方法表示:“返回true当且仅当这个集合包含至少一个元素e使得(o==null ? e==null : o.equals(e))”。 该规范应该被解释为意味着具有非空参数调用o Collection.contains会导致o.equals(e)被调用任何元素e。 实现可以自由地实现优化,从而避免equals调用,例如,首先比较两个元素的哈希码。 ( Object.hashCode()规范保证具有不等的哈希码的两个对象不能相等。)更一般地,各种Collections Framework接口的实现可以随意使用底层Object方法的指定行为,无论执行者认为合适。

执行递归遍历集合的一些集合操作可能会失败,而自引用实例的异常会导致集合直接或间接包含其自身。 这包括clone()equals()hashCode()toString()方法。 实现可以可选地处理自引用场景,然而大多数当前实现不这样做。

此接口是成员Java Collections Framework

实现要求:

默认方法实现(继承或其他)不应用任何同步协议。 如果Collection实现具有特定的同步协议,那么它必须覆盖默认实现以应用该协议。

 即就是将指定集合中的所有元素添加到此集合(可选操作)

参考代码:

import java.util.ArrayList;
import java.util.Collection;
public class CollectionTestDemo2 {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection c1 = new ArrayList();

        //向集合中添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("java");
        c1.add("hadoop");

        //定义另一个集合
        Collection c2 = new ArrayList();
        c2.add("hello");
        c2.add("world");
        c2.add("hive");
        c2.add("spark");

        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);

        System.out.println("======================");

        //boolean addAll(Collection c)
        System.out.println("将c1添加到c2中:");
        System.out.println(c2.addAll(c1));
        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);
    }

输出结果: 

c1:[hello, world, java, hadoop]
c2:[hello, world, hive, spark]
======================
将c1添加到c2中:
true
c1:[hello, world, java, hadoop]
c2:[hello, world, hive, spark, hello, world, java, hadoop] 


2、删除功能 

boolean remove(Object o)

查看API文档我们知道:

boolean remove(Object o)

从该集合中删除指定元素的单个实例(如果存在)(可选操作)。 更正式地,删除元素e ,使得(o==null ? e==null : o.equals(e)) ,如果该集合包含一个或多个这样的元素。 如果此集合包含指定的元素(或等效地,如果此集合由于调用而更改),则返回true 。

参数

o - 要从此集合中删除的元素(如果存在)

结果

true如果一个元素因此调用而被删除

异常

ClassCastException - 如果指定元素的类型与此集合不兼容( optional

NullPointerException - 如果指定的元素为空,并且此集合不允许空元素( optional

UnsupportedOperationException - 如果此 集合不支持remove操作

参考代码:

import java.util.ArrayList;
import java.util.Collection;
/*
boolean remove(Object o)
从该集合中删除指定元素的单个实例(如果存在)(可选操作)。
只移除一个符合条件的
 */
public class CollectionTestRemove {
    public static void main(String[] args) {

        //创建一个集合对象
        Collection c1 = new ArrayList();

        //向集合中添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("java");
        c1.add("hadoop");

        //定义另一个集合
        Collection c2 = new ArrayList();
        c2.add("hello");
        c2.add("world");
        c2.add("hive");
        c2.add("spark");

        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);

        System.out.println("======================");
        //删除c1中的hello
        System.out.println(c1.remove("hello"));

    }
}

输出结果:

c1:[hello, world, java, hadoop]
c2:[hello, world, hive, spark]
======================
true
[world, java, hadoop] 

即从该集合中删除指定元素的单个实例(如果存在)(可选操作)。


boolean removeAll(Collection<?> c)

查看API文档我们知道:

boolean containsAll(Collection<?> c)

如果此集合包含指定 集合中的所有元素,则返回true。

参数

c - 要在此集合中检查遏制的集合

结果

true如果此集合包含指定集合中的所有元素

异常

ClassCastException - 如果指定集合中的一个或多个元素的类型与此集合不兼容( optional

NullPointerException - 如果指定的集合包含一个或多个空元素,并且此集合不允许空元素( optional ),或者指定的集合为空。

参考代码:

import java.util.ArrayList;
import java.util.Collection;
/*
boolean removeAll(Collection c) 删除指定集合中包含的所有此集合的元素(可选操作)
此调用返回后,此集合将不包含与指定集合相同的元素。
 */
public class CollectionTestRemoveAllDemo {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection c1 = new ArrayList();

        //向集合中添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("java");
        c1.add("hadoop");

        //定义另一个集合
        Collection c2 = new ArrayList();
        c2.add("hello");
        c2.add("world");
        c2.add("hive");
        c2.add("spark");

        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);

        System.out.println("======================");

        //boolean removeAll(Collection c) 删除指定集合中包含的所有此集合的元素(可选操作)。
        // 此调用返回后,此集合将不包含与指定集合相同的元素。
        System.out.println(c1.removeAll(c2));
        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);
    }
}

输出结果:

c1:[hello, world, java, hadoop]
c2:[hello, world, hive, spark]
======================
true
c1:[java, hadoop]
c2:[hello, world, hive, spark] 

 从输出结果来看boolean removeAll(Collection c)就是删除指定集合中包含的所有此集合的元素(可选操作)。


void clear()

查看API文档我们知道:

void clear()

从此集合中删除所有元素(可选操作)。 此方法返回后,集合将为空。

异常

UnsupportedOperationException - 如果此 集合不支持clear操作

参考代码:

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTestClearDemo {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection c1 = new ArrayList();

        //向集合中添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("java");
        c1.add("hadoop");

        //定义另一个集合
        Collection c2 = new ArrayList();
        c2.add("hello");
        c2.add("world");
        c2.add("hive");
        c2.add("spark");

        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);

        System.out.println("======================");

        //void clear() 从此集合中删除所有元素(可选操作)
        c1.clear();
        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);

    }
}

输出结果:

c1:[hello, world, java, hadoop]
c2:[hello, world, hive, spark]
======================
c1:[]
c2:[hello, world, hive, spark] 

 从输出结果来看void claear()就是从此集合中删除所有元素(可选操作)。


3、获取功能

Iterator<E> iterator()

查看API文档我们知道:

Iterator<E> iterator()

返回此集合中的元素的迭代器。 没有关于元素返回顺序的保证(除非这个集合是提供保证的某个类的实例)。

Specified by:

iterator在接口 Iterable<E>

结果

一个 Iterator在这个集合中的元素

 迭代器,集合的专用遍历方式

boolean hasNext()

查看API文档我们知道:

boolean hasNext()

如果迭代具有更多的元素,则返回true 。 (换句话说,如果next()返回一个元素而不是抛出一个异常,则返回true

结果

true如果迭代有更多的元素

 如果迭代具有跟多更多元素,则返回true

Object next()

查看API文档我们知道:

E next()

返回迭代中的下一个元素。

结果

迭代中的下一个元素

异常

NoSuchElementException - 如果迭代没有更多的元素

 返回此集合中的元素的迭代器,返回迭代的下一个元素

在学习集合之前我们会采用遍历数组的方法来获取元素,参考代码如下:

import java.util.ArrayList;
import java.util.Collection;

public class IteratorTest1 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c1 = new ArrayList();

        //添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("java");
        c1.add("20");

        //将集合转换成数组
        Object[] array = c1.toArray();

        //遍历数组获取数组中每一个元素
        for (int i = 0;i < array.length;i++){
//            System.out.println(array[i]);
            /*
            因为获取到的元素类型是Object类型,
            所以没有length()方法
            要想调用字符串中的方法,就需要进行向下转型
             */
            String s = (String)array[i];
            System.out.println(s+",长度为:" + s.length());
        }
    }

输出结果:

hello,长度为:5
world,长度为:5
java,长度为:4
20,长度为:2 

 需求:向集合中添加3个学生对象,并遍历学生信息。

参考代码2:

import java.util.ArrayList;
import java.util.Collection;

/*
        需求:向集合中添加3个学生对象,并遍历学生信息
 */
public class IteratorTest2 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c1 = new ArrayList();

        //创建3个学生对象
        Student s1 = new Student("刘德华", 21);
        Student s2 = new Student("张学友", 22);
        Student s3 = new Student("郭富城", 23);

        //将学生对象添加到集合中
        c1.add(s1);
        c1.add(s2);
        c1.add(s3);

        //将学生对象集合转换成数组
        Object[] array = c1.toArray();

        //遍历数组
        for (int i =0;i<array.length;i++){
            //向下转型
            Student s = (Student)array[i];
            System.out.println("姓名:" + s.getName() + "---" + "年龄:" + s.getAge());
        }
    }
}

输出结果:

姓名:刘德华---年龄:21
姓名:张学友---年龄:22
姓名:郭富城---年龄:23

 这时我们学习了集合中的迭代器,下面将教大家如何使用迭代器:

import java.util.Iterator;

参考代码3:

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo5 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c1 = new ArrayList();

        //向集合中添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("java");
        c1.add("hadoop");

        //获取c1的迭代器对象
        Iterator iterator = c1.iterator();
        //[email protected]
//        System.out.println(iterator);

        //Object next() 返回迭代中的下一个元素。
//        Object obj = iterator.next();
//        System.out.println(obj);
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
        //NoSuchElementException
//        System.out.println(iterator.next());
        //我们通过观察发现,最后一个System.out.println(iterator.next());
        //是多余的,因为此刻已经将迭代器中的元素遍历完了,不应该写
        //我们实际应该在获取之前判断一下下一个位置上是否有元素,如果有就next()获取
        //如果没有就不获取
        //boolean hasNext() 如果迭代具有更多元素,则返回 true 。
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }
//
//        if(iterator.hasNext()){
//            System.out.println(iterator.next());
//        }


        //通过加入了判断我们发现,虽然代码不报错,也可以将结果元素正确的打印
        //但是呢,我们并不知道迭代器什么时候遍历到最后一个元素
        //怎么改进呢?用循环改进
        //由于我们不知道什么时候结束循环,使用while循环

        while (iterator.hasNext()) {
            Object next = iterator.next();

            //向下转型
            String s = (String) next;
            System.out.println(s + ",长度为:" + s.length());
        }


    }
}

输出结果:

 hello,长度为:5
world,长度为:5
java,长度为:4
hadoop,长度为:6

 从代码中可以看出,我们使用了迭代器,并进一步使用while循环进行了优化。

参考代码4:

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;


public class CollectionDemo6 {
    public static void main(String[] args) {
        //创建学生集合对象
        Collection c1 = new ArrayList();

        //创建学生对象
        Student s1 = new Student("刘德华", 21);
        Student s2 = new Student("张学友", 22);
        Student s3 = new Student("郭富城", 23);

        //将学生对象添加到集合中
        c1.add(s1);
        c1.add(s2);
        c1.add(s3);

        //获取迭代器对象
        Iterator iterator = c1.iterator();

        //遍历迭代器对象,获取迭代器中的每个元素
        while (iterator.hasNext()) {
            Object next = iterator.next();

//            //向下转型
//            Student s = (Student) next;
//            System.out.println(s.getName() + "--" + s.getAge());
            System.out.println("姓名" + ((Student) next).getName() + "---" + "年龄:" +  ((Student) next).getAge());
        }

        //NoSuchElementException
//        Object next = iterator.next();
//        System.out.println(((Student) next).getName() + "--" + ((Student) next).getAge());




//        System.out.println("======用普通for循环遍历(不推荐)========");
//
//        Iterator iterator = c1.iterator();
//        for(;iterator.hasNext();){
//            Object next = iterator.next();
//
            //向下转型
//            Student s = (Student) next;
//            System.out.println(s.getName() + "--" + s.getAge());
//        }


    }
}

输出结果:

姓名刘德华---年龄:21
姓名张学友---年龄:22
姓名郭富城---年龄:23 

 从输出结果可以看出使用迭代器一样能输出,更方便!

注意:

1、能否将while循环改成普通for循环呢?能,但是不推荐,推荐使用whil循环
2、为什么将Iterator一个接口呢?而不是一个类呢?
    将来你需要根据不同的数据创建不同的集合进行存储,每个集合都有自身独有特点,很有可能每一个
    集合遍历的顺序特点不一样,所以取值的方式也很有可能不一样,所以不应该直接实现,而是通过一个接口
    将来特有的集合要去使用迭代器时候,就实现一下这个接口,添加自己特有的遍历元素逻辑代码。

 参考代码4里注释已给出为什么使用while循环。


4、判断功能

boolean contains(Object o)

查看API文档我们知道:

boolean contains(Object o)

如果此集合包含指定的元素,则返回true 。 更正式地,返回true如果且仅当该集合至少包含一个元素e使得(o==null ? e==null : o.equals(e)) 。

参数

o - 要在此集合中存在的元素要进行测试

结果

true如果此集合包含指定的元素

异常

ClassCastException - 如果指定元素的类型与此集合不兼容( optional

NullPointerException - 如果指定的元素为空,并且此集合不允许空元素( optional

参考代码:

import java.util.ArrayList;
import java.util.Collection;

public class CollectionContainsTestDemo {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection c1 = new ArrayList();

        //向集合中添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("java");
        c1.add("hadoop");
        c1.add("hive");
//        c1.add("spark");

        //定义另一个个集合
        Collection c2 = new ArrayList();
        c2.add("hello");
        c2.add("world");
        c2.add("hive");
        c2.add("spark");

        System.out.println("c1: "+c1);
        System.out.println("c2: "+c2);
        System.out.println("===============================");

        //判断c1是否包含指定字符hadoop
        System.out.println("判断c1是否包含指定字符hadoop:n" + c1.contains("hadoop"));
        //判断c1是否包含指定字符fink
        System.out.println("判断c1是否包含指定字符fink:n" + c1.contains("fink"));

    }
}

输出结果:

c1: [hello, world, java, hadoop, hive]
c2: [hello, world, hive, spark]
c3: [hello, world, hive, spark]
===============================
判断c1是否包含指定字符hadoop:
true
判断c1是否包含指定字符fink:
false

  从输出结果可以看出,就是判断指定元素是否包含在集合中即如果此集合包含指定的元素,则返回 true ,反之false。


boolean containsAll(Collection<?> c)

查看API文档我们知道:

boolean containsAll(Collection<?> c)

如果此集合包含指定 集合中的所有元素,则返回true。

参数

c - 要在此集合中检查遏制的集合

结果

true如果此集合包含指定集合中的所有元素

异常

ClassCastException - 如果指定集合中的一个或多个元素的类型与此集合不兼容( optional

NullPointerException - 如果指定的集合包含一个或多个空元素,并且此集合不允许空元素( optional ),或者指定的集合为空。

参考代码:

import java.util.ArrayList;
import java.util.Collection;

public class CollectionContainsAllTestDemo {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection c1 = new ArrayList();

        //向集合中添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("java");
        c1.add("hadoop");
        c1.add("hive");
//        c1.add("spark");

        //定义另一个个集合
        Collection c2 = new ArrayList();
        c2.add("hello");
        c2.add("world");
        c2.add("hive");
        c2.add("spark");

//        定义第三个集合
        Collection c3 = new ArrayList();
        c3.add("hello");
        c3.add("world");
        c3.add("hive");
        c3.add("spark");

        System.out.println("c1: "+c1);
        System.out.println("c2: "+c2);
        System.out.println("c3: "+c3);
        System.out.println("===============================");

//        boolean contains(Object o)
        //判断c1是否包含c2(c1和c2元素不相同)
        System.out.println("判断c1是否包含c2(c1和c2元素不相同):n" + c1.containsAll(c2));
        //判断c2是否包含c3(c2和c3的元素相同)
        System.out.println("判断c2是否包含c3(c2和c3的元素相同):n" + c2.containsAll(c3));

    }
}

输出结果:

 c1: [hello, world, java, hadoop, hive]
c2: [hello, world, hive, spark]
c3: [hello, world, hive, spark]
===============================
判断c1是否包含c2(c1和c2元素不相同):
false
判断c2是否包含c3(c2和c3的元素相同):
true

如果在c1集合上添加一个spark,则输出结果为:

c1: [hello, world, java, hadoop, hive, spark]
c2: [hello, world, hive, spark]
c3: [hello, world, hive, spark]
===============================
判断c1是否包含c2(c1和c2元素不相同):
true
判断c2是否包含c3(c2和c3的元素相同):
true

从输出结果可以看出如果此集合包含指定 集合中的所有元素,则返回true,反之false。 


boolean isEmpty()

查看API文档我们知道:

boolean isEmpty()

如果此集合不包含元素,则返回 true 。

结果

true如果此集合不包含元素

参考代码:

import java.util.ArrayList;
import java.util.Collection;

public class CollectionIsEmptyTest {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection c1 = new ArrayList();

        //向集合中添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("java");
        c1.add("hadoop");

        //定义另一个集合
        Collection c2 = new ArrayList();

        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);

        System.out.println("======================");

        //boolean isEmpty()
        //如果此集合不包含元素,则返回 true 。
        
        //c1集合中含有元素
        System.out.println(c1.isEmpty());
        //c2集合中没有元素
        System.out.println(c2.isEmpty());
    }
}

运行结果:

c1:[hello, world, java, hadoop]
c2:[]
======================
false
true

 如果此集合不包含元素,则返回 true ,反之false


5、获取长度功能

int size()

查看API文档我们知道:

int size()

返回此集合中的元素数。 如果此收藏包含超过Integer.MAX_VALUE个元素,则返回Integer.MAX_VALUE 。

结果

此集合中的元素数  

参考代码:

import java.util.ArrayList;
import java.util.Collection;

public class CollectionSizeTest {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection c1 = new ArrayList();

        //向集合中添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("java");
        c1.add("hadoop");

        //定义另一个集合
        Collection c2 = new ArrayList();

        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);

        System.out.println("======================");

        //获取长度功能int size()
        // 返回此集合中的元素数。
        System.out.println("集合c1的元素个数为:" + c1.size());
        System.out.println("集合c2的元素个数为:" + c2.size());

    }
}

输出结果:

c1:[hello, world, java, hadoop]
c2:[]
======================
集合c1的元素个数为:4
集合c2的元素个数为:0

 通过运行结果可以看出int size()是返回此集合中的元素数。


6、求交集功能

boolean retainAll(Collection<?> c)

查看API文档我们知道:

boolean retainAll(Collection<?> c)

仅保留此集合中包含在指定集合中的元素(可选操作)。 换句话说,从该集合中删除所有不包含在指定集合中的元素。

参数

c - 包含要保留在此集合中的元素的集合

结果

true如果此收集因呼叫而更改

异常

UnsupportedOperationException - 如果此 集合不支持retainAll操作

ClassCastException - 如果此集合中的一个或多个元素的类型与指定的集合不兼容( optional

NullPointerException - 如果此集合包含一个或多个空元素,并且指定的集合不允许空元素( optional ),或者如果指定的集合为空

 参考代码:

import java.util.ArrayList;
import java.util.Collection;

public class CollectionRetainAllTestDemo {
    public static void main(String[] args) {

        //创建一个集合对象
        Collection c1 = new ArrayList();

        //向集合中添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("java");
        c1.add("hadoop");

        //定义另一个集合
        Collection c2 = new ArrayList();
        c2.add("hello");
        c2.add("world");
        c2.add("hive");
        c2.add("spark");

        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);

        System.out.println("======================");
        
        /*
          boolean retainAll(Collection c)
          仅保留此集合中包含在指定集合中的元素(可选操作)。
          换句话说,从该集合中删除所有不包含在指定集合中的元素。

          假设有两个集合c1,c2
          c1对c2做交集,最终的结果保存在c1中,c2不变
          并且c1中删除与c2不是共同的其他元素
         */

        System.out.println(c1.retainAll(c2));
        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);
    }
}

输出结果:

c1:[hello, world, java, hadoop]
c2:[hello, world, hive, spark]
======================
true
c1:[hello, world]
c2:[hello, world, hive, spark] 

  从输出结果可以看出c1对c2做交集,最终的结果保存在c1中,c2不变,并且c1中删除与c2不是共同的其他元素仅保留此集合中包含在指定集合中的元素(可选操作),换句话说:从该集合中删除所有不包含在指定集合中的元素。 


7、将集合转换成数组

Object[] toArray()

查看API文档我们知道:

Object[] toArray()

返回一个包含此集合中所有元素的数组。 如果此集合对其迭代器返回的元素的顺序做出任何保证,则此方法必须以相同的顺序返回元素。

返回的数组将是“安全的”,因为该集合不保留对它的引用。 (换句话说,这个方法必须分配一个新的数组,即使这个集合是由数组支持的)。 因此,调用者可以自由地修改返回的数组。

此方法充当基于阵列和基于集合的API之间的桥梁。

参考代码:

import java.util.ArrayList;
import java.util.Collection;

public class IteratorTest1 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c1 = new ArrayList();

        //添加元素
        c1.add("hello");
        c1.add("world");
        c1.add("java");
        c1.add("20");

        //将集合转换成数组
        Object[] array = c1.toArray();

        //遍历数组获取数组中每一个元素
        for (int i = 0;i < array.length;i++){
//            System.out.println(array[i]);
            /*
            因为获取到的元素类型是Object类型,
            所以没有length()方法
            要想调用字符串中的方法,就需要进行向下转型
             */
            String s = (String)array[i];
            System.out.println(s+",长度为:" + s.length());
        }
    }
}

输出结果:

hello,长度为:5
world,长度为:5
java,长度为:4
20,长度为:2

通过运行结果可以看出 Object[] array = c1.toArray(); 返回一个包含此集合中所有元素的数组。


到底啦!写了2万1千字的博客!靓仔很辛苦,给个关注吧!

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>