Java 集合 Collection、Iterator

harryhappy 發布于2019-08-14 17:02 / 1868人閱讀

摘要：如果需要創建對象，則必須與一個被迭代的集合。這是一個有狀態的方法該方法用于保證對該流的后續訪問中最大允許訪問的元素個數?？梢詫显剡M行整體的聚集操作。

Java集合分為Set（無序、不可重復）、List（有序、重復）、Queue（隊列）和Map（映射關系）

Java集合概述

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

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

Collection集合體系的繼承樹

Map體系的繼承樹

所有的Map實現類用于保存具有映射關系的數據，Map保存的每項數據都是key-value對。
Map里的key是不可重復的，用于標識集合里的每項數據，如果需要查閱Map中的數據時，總是根據Map的key來獲取

Collection和Iterator接口

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

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

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

void clear()：清除集合里的所有元素，將集合長度變為0

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

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

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

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

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

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

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

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

Object[] toArray()：該方法把集合轉換成一個數組，所有的集合元素變成對應的數組元素

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

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集合的元素個數為：" + collection.size());        //輸出2
        //刪除指定元素
        collection.remove(35);
        System.out.println("collection集合的元素個數為：" + 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集合的元素個數為：2    
collection集合的元素個數為：1
collection集合是否包含"杜蘭特"字符串：true
collection集合的元素：[杜蘭特, 維斯布魯克]
collection集合是否完全包含number集合？false
collection集合的元素：[杜蘭特, 維斯布魯克]
collection集合的元素：[]
number集合的元素：[]

使用Lambda表達式遍歷集合

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

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

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

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

使用Java8增強的Iterator遍歷集合元素

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

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

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

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

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

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

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

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

使用Lambda表達式遍歷Iterator

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

使用foreach循環遍歷集合元素

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

import java.util.*;

public class ForeachTest
{
    public static void main(String[] args)
    {
        // 創建集合、添加元素的代碼與前一個程序相同
        Collection books = new HashSet();
        books.add(new String("輕量級Java EE企業應用實戰"));
        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講義"))
            {
                // 下面代碼會引發ConcurrentModificationException異常
                books.remove(book);     //①
            }
        }
        System.out.println(books);
    }
}

使用Java8新增的Predicate操作集合

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

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

public class PredicateTest2
{
    public static void main(String[] args)
    {
        // 創建books集合、為books集合添加元素的代碼與前一個程序相同。
        Collection books = new HashSet();
        books.add(new String("輕量級Java EE企業應用實戰"));
        books.add(new String("瘋狂Java講義"));
        books.add(new String("瘋狂iOS講義"));
        books.add(new String("瘋狂Ajax講義"));
        books.add(new String("瘋狂Android講義"));
        // 統計書名包含“瘋狂”子串的圖書數量
        System.out.println(calAll(books , ele->((String)ele).contains("瘋狂")));
        // 統計書名包含“Java”子串的圖書數量
        System.out.println(calAll(books , ele->((String)ele).contains("Java")));
        // 統計書名字符串長度大于10的圖書數量
        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;
    }
}

使用Java8新增的Stream操作集合

獨立使用Stream的步驟

使用Stream或XxxStream的builder()類方法創建該Stream對應的Builder

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

調用Builder的build()方法獲取對應的Stream

調用Stream的聚集方法

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

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();
        //下面調用聚集方法的代碼每次只能執行一行
        System.out.println("is所有元素的最大值：" + is.max().getAsInt());
        System.out.println("is所有元素的最小值：" + is.min().getAsInt());
        System.out.println("is所有元素的總和：" + is.sum());
        System.out.println("is所有元素的總數：" + 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);
    }
}

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

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

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

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

流方法的兩個特征

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

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

常用中間方法

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

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

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

distinct()：該方法用于排序流中所有重復的元素（判斷元素重復的標準是使用equals()比較返回true）。這是一個有狀態的方法

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

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

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

toArray()：將流中所有元素轉換為一個數組

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

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

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

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

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

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

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

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

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

Java8允許使用流式API來操作集合，Collection接口提供了一個stream()默認方法可返回該集合對應的流，接下來即可通過流式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斯蒂芬庫里"));
        player.add(new String("MVP德凱文杜蘭特"));
        player.add(new String("FMVP萊昂納德"));
        player.add(new String("場均三雙狂魔維斯布魯克"));
        
        //統計書名包含“MVP”子串的圖書數量
        System.out.println(player.stream().
                filter(ele -> ((String)ele).contains("MVP"))
                .count());            // 輸出5
        //統計書名包含“FMVP”子串的圖書數量
        System.out.println(player.stream().
                filter(ele -> ((String)ele).contains("FMVP"))
                .count());            // 輸出2
        //統計書名字符串長度大于10的圖書數量
        System.out.println(player.stream().
                filter(ele -> ((String)ele).length() > 10)
                .count());            // 輸出2
        //先調用Collection對象的stream()方法將集合轉換為Stream
        //再調用Stream的mapToInt()方法獲取原有的Stream對應的IntStream
        player.stream().mapToInt(ele -> ((String)ele).length())
        //調用forEach()方法遍歷IntStream中每個元素
        .forEach(System.out::println);            // 輸出8.14.8.8.9.11
    }
}

云服務器 GPU云服務器 Iterator Collection java 集合 java 安全集合

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/66383.html

java集合

摘要：主要用于遍歷集合中的元素，對象也被稱為迭代器。使用迭代過程中，不可修改集合元素迭代器采用快速失敗機制。一旦迭代過程中檢測到該集合已經被修改，程序立即出發異常，而不是顯示修改后的結果，避免了共享資源而引發的潛在問題。集合類和數組不一樣，數組元素既可以是基本類型的值，也可以是對象(實際上保存的是對象的引用變量);而集合里只能保存對象(實際上只是保存對象的引用變量，但通常習慣上認為集...

JinB 2019-08-15 15:54 評論0 收藏0
集合概要學習---粗略

摘要：集合框架的基本接口類層次結構其中表示接口，表示實現類和在實際開發中，需要將使用的對象存儲于特定數據結構的容器中。實例是迭代器，擁有兩個方法方法迭代器用于遍歷集合元素。返回值則是轉換后的數組，該數組會保存集合中的所有元素。 Java Collections Framework是Java提供的對集合進行定義，操作，和管理的包含一組接口，類的體系結構。 Java集合框架的基本接口/類層次結構...

DesGemini 2019-08-19 10:52 評論0 收藏0
java集合--Collection接口

摘要：集合的元素個數為輸出集合的元素個數為在本代碼中，新建一個局部變量保存的成員方法返回的值，輸出得到因為只有一個元素。注若遍歷集合的同時改變集合，將引發異常。 ????在概述里面也說過：Collection是java集合兩大接口之一，旗下有三大子接口：Set（元素不能重復，且無序）、Queue、List（元素可重復，且有序）。????Collection來源于java.util包，主要方法...

k00baa 2019-08-16 17:09 評論0 收藏0
Java集合遍歷

摘要：集合的遍歷使用主要用于遍歷集合中的元素，因此創建的對象是一個迭代器。提供的四個方法如果迭代器的集合還沒有被遍歷完，返回。集合的遍歷使用Iterator Iterator主要用于遍歷集合中的Collection元素，因此Iterator創建的對象是一個迭代器。 Iterator提供的四個方法 boolean hasNext(): 如果迭代器的集合還沒有被遍歷完，返回ture。 Ob...

MadPecker 2019-08-15 14:02 評論0 收藏0
java的集合和泛型的知識點歸納1

摘要：接口也是集合中的一員，但它與接口有所不同，接口與接口主要用于存儲元素，而主要用于迭代訪問即遍歷中的元素，因此對象也被稱為迭代器。迭代器的實現原理我們在之前案例已經完成了遍歷集合的整個過程。【Collection、泛型】主要內容 Collection集合迭代器增強for 泛型教學目標 [ ] 能夠說出集合與數組的區別 [ ] 說出Collection集合的常用功能 [ ]...

daryl 2019-08-16 18:25 評論0 收藏0