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();
        //java.util.ArrayList$Itr@4554617c
//        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千字的博客！靚仔很辛苦，給個關注吧！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/386556.html

標籤：java

上一篇：java web（ssm）簡答題考前總結——不詳細，但好背

下一篇：C++與Java共同點

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<E> 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()