摘要：如果需要創(chuàng)建對象，則必須與一個被迭代的集合。這是一個有狀態(tài)的方法該方法用于保證對該流的后續(xù)訪問中最大允許訪問的元素個數(shù)。可以對集合元素進行整體的聚集操作。

Java集合分為Set（無序、不可重復(fù)）、List（有序、重復(fù)）、Queue（隊列）和Map（映射關(guān)系）

數(shù)組元素既可以是基本類型的值，也可以是對象（實際保存對象的引用變量）
集合只能保存對象（實際保存對象的引用變量）

Collection和Map是Java集合框架的根接口

Collection集合體系的繼承樹

Map體系的繼承樹

所有的Map實現(xiàn)類用于保存具有映射關(guān)系的數(shù)據(jù)，Map保存的每項數(shù)據(jù)都是key-value對。
Map里的key是不可重復(fù)的，用于標(biāo)識集合里的每項數(shù)據(jù)，如果需要查閱Map中的數(shù)據(jù)時，總是根據(jù)Map的key來獲取

Collection接口是List、Set和Queue接口的父接口，定義了如下操作集合元素的方法

boolean add(Object o)：該方法用于向集合里添加一個元素。如果集合對象被添加操作改變了，則返回true

boolean addAll(Collection c)：該方法把集合c里的所有元素添加到指定集合里。如果集合對象被添加操作改變了，則返回true

void clear()：清除集合里的所有元素，將集合長度變?yōu)?

boolean contains(Object o)：返回集合里是否包含指定元素

boolean containsAll(Collection c)：返回集合里是否包含集合c里的所有元素

boolean isEmpty()：返回集合是否為空，當(dāng)集合長度為0時返回true，否則返回false

Iterator iterator()：返回一個Iterator對象，用于遍歷集合里的元素

boolean remove(Object o)：刪除集合中的指定元素o，當(dāng)集合中包含了一個或多個元素o時，該方法只刪除第一個符合條件的元素，該方法將返回true

boolean removeAll(Collection c)：從集合中刪除集合c里包含的所有元素（相當(dāng)于調(diào)用該方法的集合減集合c），如果刪除了一個或一個以上的元素，則返回true

boolean retainAll(Collection c)：從集合中刪除集合c里不包含的元素（相當(dāng)于把調(diào)用該方法的集合和集合c的交集），如果該操作改變了調(diào)用該方法的集合，則該方法返回true

int size()：該方法返回集合里元素的個數(shù)

Object[] toArray()：該方法把集合轉(zhuǎn)換成一個數(shù)組，所有的集合元素變成對應(yīng)的數(shù)組元素

下面程序創(chuàng)建了兩個Collection對象，一個是ArrayList的collection集合，另一個是HashSet的number集合。雖然實現(xiàn)類不同，但當(dāng)成Collection來使用時，操作集合元素沒有任何區(qū)別

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

public class CollectionTest 
{
    public static void main(String[] args) 
    {
        Collection collection = new ArrayList<>(); 
        //添加元素
        collection.add("杜蘭特");
        //雖然集合里不能放基本類型的值，但Java支持自動裝箱
        collection.add(35);
        System.out.println("collection集合的元素個數(shù)為：" + collection.size());        //輸出2
        //刪除指定元素
        collection.remove(35);
        System.out.println("collection集合的元素個數(shù)為：" + collection.size());        //輸出1    
        //判斷是否包含指定字符串
        System.out.println("collection集合是否包含"杜蘭特"字符串："
                + collection.contains("杜蘭特"));                                    //輸出true
        collection.add("維斯布魯克");
        System.out.println("collection集合的元素：" + collection);
        Collection number = new HashSet<>();
        number.add(35);
        number.add(0);
        System.out.println("collection集合是否完全包含number集合？" + collection.containsAll(number));        //輸出false
        //用collection集合減去number集合里的元素
        collection.removeAll(number);
        System.out.println("collection集合的元素：" + collection);
        //刪除collection集合里的所有元素
        collection.clear();
        System.out.println("collection集合的元素：" + collection);
        //控制number集合里只剩下collection集合里也包含的元素
        number.retainAll(collection);
        System.out.println("number集合的元素：" + number);
    }
}


collection集合的元素個數(shù)為：2    
collection集合的元素個數(shù)為：1
collection集合是否包含"杜蘭特"字符串：true
collection集合的元素：[杜蘭特, 維斯布魯克]
collection集合是否完全包含number集合？false
collection集合的元素：[杜蘭特, 維斯布魯克]
collection集合的元素：[]
number集合的元素：[]

Iterable接口的forEach(Consumer action)默認(rèn)方法，該方法需要參數(shù)的類型是一個函數(shù)式接口，而Iterable接口是Collection接口的父接口，因此Collection集合可直接調(diào)用該方法

import java.util.Collection;
import java.util.HashSet;

public class CollectionEach 
{
    public static void main(String[] args)
    {
        //創(chuàng)建一個集合
        Collection teams = new HashSet<>();
        teams.add("Thunder");
        teams.add("Cavaliers");
        teams.add("Warriors");
        //調(diào)用forEach()方法遍歷集合
        teams.forEach(obj -> System.out.println("迭代集合元素： " + obj));
    }
}

程序調(diào)用Iterable的forEach(Consumer action)遍歷集合元素是，程序會依次將集合元素傳給Consumer的accept(T t)方法（該接口中唯一的抽象方法）

Iterator主要用于遍歷（即迭代訪問）Collection集合中的元素，Iterator對象也被稱為迭代器

boolean hasNext()：如果被迭代的集合元素還沒有被遍歷完，則返回true

Object next()：返回集合里的下一個元素

void remove()：刪除集合里上一次next方法返回的元素

void forEachRemaining(Consumer action)：該方法可以使用Lambda表達(dá)式來遍歷集合元素

Iterator僅用于遍歷集合，Iterator本身并不提供盛裝對象的能力。如果需要創(chuàng)建Iterator對象，則必須與一個被迭代的集合。當(dāng)使用Iterator對集合元素進行迭代時，Iterator并不是把集合元素本身傳給了迭代變量，而是把集合元素的值傳給了迭代變量，所以修改迭代變量的值對集合元素本身沒有任何影響

//獲取teams集合對應(yīng)的迭代器
Iterator iterator = teams.iterator();
while (iterator.hasNext())
{
    //iterator.next()方法返回的數(shù)據(jù)類型是Object類型，因此需要強制類型轉(zhuǎn)換
    String team = (String) iterator.next();
    System.out.println(team);
    if (team.equals("Cavaliers")) 
    {
        //從集合中刪除上一次next()方法返回的元素
        iterator.remove();
    }
    //對iterator變量賦值，不會改變集合元素本身
    team = "Rocket";        //①
}
System.out.println(teams);

當(dāng)使用Iterator迭代訪問Collection集合元素時，Collection集合里的元素不能被改變，只有通過Iterator的remove()方法刪除上一次next()方法返回的集合元素才可以；否則將會引發(fā)java.util.ConcurrentModificationException異常

//獲取teams集合對應(yīng)的迭代器
Iterator iterator = teams.iterator();
//使用Lambda表達(dá)式（目標(biāo)類型是Comsumer）來遍歷集合元素
iterator.forEachRemaining(obj -> System.out.println("迭代集合元素： " + obj));

使用foreach循環(huán)來迭代訪問Collection集合里的元素更加簡潔，迭代變量不是集合元素本身，系統(tǒng)只是依次把集合元素的值賦給迭代變量，集合也不能被改變，否則引發(fā)ConcurrentModificationException異常

import java.util.*;

public class ForeachTest
{
    public static void main(String[] args)
    {
        // 創(chuàng)建集合、添加元素的代碼與前一個程序相同
        Collection books = new HashSet();
        books.add(new String("輕量級Java EE企業(yè)應(yīng)用實戰(zhàn)"));
        books.add(new String("瘋狂Java講義"));
        books.add(new String("瘋狂Android講義"));
        for (Object obj : books)
        {
            // 此處的book變量也不是集合元素本身
            String book = (String)obj;
            System.out.println(book);
            if (book.equals("瘋狂Android講義"))
            {
                // 下面代碼會引發(fā)ConcurrentModificationException異常
                books.remove(book);     //①
            }
        }
        System.out.println(books);
    }
}

removif(Predicate filter)方法，該方法將會批量刪除符合filter條件的所有元素。該方法需要一個Predicate（謂詞）對象作為參數(shù)，Predicate也是函數(shù)式接口，因此可使用Lambda表達(dá)式作為參數(shù)

import java.util.*;
import java.util.function.*;

public class PredicateTest2
{
    public static void main(String[] args)
    {
        // 創(chuàng)建books集合、為books集合添加元素的代碼與前一個程序相同。
        Collection books = new HashSet();
        books.add(new String("輕量級Java EE企業(yè)應(yīng)用實戰(zhàn)"));
        books.add(new String("瘋狂Java講義"));
        books.add(new String("瘋狂iOS講義"));
        books.add(new String("瘋狂Ajax講義"));
        books.add(new String("瘋狂Android講義"));
        // 統(tǒng)計書名包含“瘋狂”子串的圖書數(shù)量
        System.out.println(calAll(books , ele->((String)ele).contains("瘋狂")));
        // 統(tǒng)計書名包含“Java”子串的圖書數(shù)量
        System.out.println(calAll(books , ele->((String)ele).contains("Java")));
        // 統(tǒng)計書名字符串長度大于10的圖書數(shù)量
        System.out.println(calAll(books , ele->((String)ele).length() > 10));
    }
    public static int calAll(Collection books , Predicate p)
    {
        int total = 0;
        for (Object obj : books)
        {
            // 使用Predicate的test()方法判斷該對象是否滿足Predicate指定的條件
            if (p.test(obj))
            {
                total ++;
            }
        }
        return total;
    }
}

獨立使用Stream的步驟

使用Stream或XxxStream的builder()類方法創(chuàng)建該Stream對應(yīng)的Builder

重復(fù)調(diào)用Builder的add()方法向該流中添加多個元素

調(diào)用Builder的build()方法獲取對應(yīng)的Stream

調(diào)用Stream的聚集方法

Stream提供了大量的聚集方法供用戶調(diào)用，對于大部分聚集方法而言，每個Stream只能執(zhí)行一次

import java.util.stream.IntStream;

import javax.lang.model.element.Element;
import javax.print.attribute.standard.PrinterLocation;
import javax.swing.text.html.HTMLDocument.HTMLReader.IsindexAction;

public class IntStreamTest 
{
    public static void main(String[] args) 
    {
        IntStream is = IntStream.builder()
                .add(20)
                .add(16)
                .add(12)
                .add(22)
                .build();
        //下面調(diào)用聚集方法的代碼每次只能執(zhí)行一行
        System.out.println("is所有元素的最大值：" + is.max().getAsInt());
        System.out.println("is所有元素的最小值：" + is.min().getAsInt());
        System.out.println("is所有元素的總和：" + is.sum());
        System.out.println("is所有元素的總數(shù)：" + is.count());
        System.out.println("is所有元素的平均值：" + is.average());
        System.out.println("is所有元素的平方是否都大于20：" + is.allMatch(ele -> ele * ele > 20));
        System.out.println("is是否包含任何元素的平方大于20：" + is.anyMatch(ele -> ele * ele > 20));
        //將is映射成一個新Stream，新Stream的每個元素是原Stream元素的2倍+1
        IntStream newIs =  is.map(ele -> ele * 2 + 1);
        //使用方法引用的方式來遍歷集合元素
        newIs.forEach(System.out::println);
    }
}

使用流的時候應(yīng)當(dāng)格外注意，它只能消費一次。上述聚集方法執(zhí)行操作每次只能執(zhí)行一行，否則出現(xiàn)java.lang.IllegalStateException: stream has already been operated upon or closed

Stream提供了大量的方法進行聚集操作，這些方法既可以是“中間的”(intermediate)，也可以是“末端的”(terminal)

中間方法：中間操作允許流保持打開狀態(tài)，并允許直接調(diào)用后續(xù)方法。map()方法就是中間方法。中間方法的返回值是另外一個流

末端方法：末端方法是對流的最終操作。當(dāng)對某個Stream執(zhí)行末端方法后，該流就會被“消耗”且不再可用。sum()、count()、average()等方法都是末端方法。

流方法的兩個特征

有狀態(tài)的方法：該方法會給流增加一些新的屬性，比如元素的唯一性、元素的最大數(shù)量、保證元素以排序的方式被處理等。有狀態(tài)的方法往往需要更大的性能開銷

短路方法：可以盡早結(jié)束對流的操作，不必檢查所有的元素

常用中間方法

filter(Predicate predicate)：過濾Stream中所有不符合predicate的元素

mapToXxx(ToXxxFunction mapper)：使用ToXxxFunction對流中的元素執(zhí)行一對一的轉(zhuǎn)換，該方法返回的新流中包含了ToXxxFunction轉(zhuǎn)換生成的所有元素

peek(Consumer action)：依次對每個元素執(zhí)行一些操作，該方法返回的流與原有流包含相同的元素。主要用于調(diào)試

distinct()：該方法用于排序流中所有重復(fù)的元素（判斷元素重復(fù)的標(biāo)準(zhǔn)是使用equals()比較返回true）。這是一個有狀態(tài)的方法

sorted()：該方法用于保證流中的元素在后續(xù)的訪問中處于有序狀態(tài)。這是一個有狀態(tài)的方法

limit(long maxSize)：該方法用于保證對該流的后續(xù)訪問中最大允許訪問的元素個數(shù)。這是一個有狀態(tài)的、短路方法

forEach(Consumer action)：遍歷流中所有元素，對每個元素執(zhí)行action

toArray()：將流中所有元素轉(zhuǎn)換為一個數(shù)組

reduce()：該方法有三個重載版本，都用于通過某種操作來合并流中的元素

min()：返回流中所有元素的最小值

max()：返回流中所有元素的最大值

count()：返回流中所有元素的數(shù)量

anyMatch(Predicate predicate)：判斷流中是否至少包含一個元素符合Predicate條件

allMatch(Predicate predicate)：判斷流中是否每個元素都符合Predicate條件

noneMatch(Predicate predicate)：判斷流中是否所有元素都不符合Predicate條件

findFirst()：返回流中的第一個元素

findAny()：返回流中的任意一個元素

Java8允許使用流式API來操作集合，Collection接口提供了一個stream()默認(rèn)方法可返回該集合對應(yīng)的流，接下來即可通過流式API來操作集合元素。Stream可以對集合元素進行整體的聚集操作。

public class CollectionStream 
{
    public static void main(String[] args) 
    {
        Collection player = new HashSet<>();
        player.add(new String("FMVP+MVP勒布朗詹姆斯"));
        player.add(new String("MVP德里克羅斯"));
        player.add(new String("MVP斯蒂芬?guī)炖?));
        player.add(new String("MVP德凱文杜蘭特"));
        player.add(new String("FMVP萊昂納德"));
        player.add(new String("場均三雙狂魔維斯布魯克"));
        
        //統(tǒng)計書名包含“MVP”子串的圖書數(shù)量
        System.out.println(player.stream().
                filter(ele -> ((String)ele).contains("MVP"))
                .count());            // 輸出5
        //統(tǒng)計書名包含“FMVP”子串的圖書數(shù)量
        System.out.println(player.stream().
                filter(ele -> ((String)ele).contains("FMVP"))
                .count());            // 輸出2
        //統(tǒng)計書名字符串長度大于10的圖書數(shù)量
        System.out.println(player.stream().
                filter(ele -> ((String)ele).length() > 10)
                .count());            // 輸出2
        //先調(diào)用Collection對象的stream()方法將集合轉(zhuǎn)換為Stream
        //再調(diào)用Stream的mapToInt()方法獲取原有的Stream對應(yīng)的IntStream
        player.stream().mapToInt(ele -> ((String)ele).length())
        //調(diào)用forEach()方法遍歷IntStream中每個元素
        .forEach(System.out::println);            // 輸出8.14.8.8.9.11
    }
}