Java集合

1.集合概述

集合：集合是java中提供的一種容器，可以用來存儲多個數據。

集合與數組的區別：

數組長度固定，集合長度可變
數組只能存儲類型相同的元素，集合存儲對象，對象類型可以不同

集合框架

2.Collection接口

Collection是所有單列集合的根接口，方法可用於操作所有單列集合

Collection接口的主要方法

方法聲明	功能描述
boolean add(Object o)	向集合中添加一個元素
boolean addAll(Collection c)	將集合c中的所有元素添加到該集合中
void clear()	刪除該集合的所有元素
boolean remove(Object o)	刪除該集合中的o
boolean removeAll(Collection c)	刪除該集合中包含集合c中的所有集合
boolean isEmpty()	判斷該集合是否爲空
boolean contains(Object o)	判斷該集合中是否包含元素o
boolean containsAll(Collection c)	判斷該集合是否包含集合c的所有元素
int size()	判斷該集合元素的個數
Iterator iterator()	用於遍歷該集合的所有元素
Stream stream()	將集合源轉換爲有序元素的流對象

3.List接口

List接口簡介

List集合：實現了List接口的對象

List集合特點：

允許出現重複的元素
元素有序

List集合的常用方法

方法聲明	功能描述
void add(int d,Object e)	在該集合位置d插入元素e
boolean addAll(int i,Collection c)	將集合c中的所有元素插入該集合位置i
Object get(int d)	返回該集合位置d的元素
Object remove(int d)	刪除該集合位置d的元素
Object set(int d,Object e)	將該集合位置d的元素替換成e，並返回替換值
int indexOf(Object e)	返回元素e在集合中第一次出現的位置索引
int lastIndexOf(Object e)	返回元素e在集合中最後一次出現的位置索引
List subList(int f，int t)	返回該集合中位置f~t之間所有元素組成的子集合
Object[] toArray()	將集合元素轉換爲數組

ArrayList集合

架構：數組

作用：適用於遍歷查找元素

缺點：不適合對集合元素做大量增刪操作

實例代碼

import java.util.ArrayList;

public class Example{
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("23");
        arrayList.add("23");
        arrayList.add("23");
        arrayList.add("23");
        arrayList.set(3, "1");
        System.out.println(arrayList.size());  //4
        System.out.println(arrayList.get(3));  //1
    }
}

LinkedList集合

架構：雙向循環鏈表

作用：更高效的增加和刪除集合中的元素

LinkedList特有方法

方法聲明	功能描述
void add(int d,E e)	在該集合位置d插入元素e
void addFirst(object o)	在該集合開頭插入元素o
void addLast(object o)	在該集合結尾插入元素o
Object removeFirst()	刪除該集合開頭的元素，並返回該元素
Object removeLast()	刪除該集合結尾的元素，並返回該元素
boolean offerFirst(Object o)	在該集合開頭插入元素o
boolean offer(Object o)	在該集合結尾插入元素o
boolean offerLast(Object o)	在該集合結尾插入元素o
Object peek()	獲取該集合開頭的元素
Object peekLast()	獲取該集合結尾的元素
Object poll()	刪除並返回該集合的開頭元素
Object pollLast()	刪除並返回該集合的結尾元素
void push(Object o)	在該集合開頭插入元素o
Object pop()	刪除並返回該集合的開頭元素

實例代碼

import java.util.LinkedList;

public class Example{
    public static void main(String[] args) {
        LinkedList link = new LinkedList();
        //1.添加元素
        link.add("stu1");
        link.add("stu2");
        System.out.println(link);  //[stu1, stu2]
        link.offer("offer");//在集合結尾添加
        link.push("push");//在集合開頭添加
        System.out.println(link);  //[push, stu1, stu2, offer]
        //2.獲取元素
        Object peek = link.peek();
        System.out.println(peek); //push
        //3.刪除元素
        link.removeFirst();
        link.pollLast();
        System.out.println(link); //[stu1, stu2]
    }
}

4.3種Collection集合遍歷

Iterator遍歷集合

Iterator接口，Iterator對象被稱爲迭代器

作用：遍歷Collection中的元素

遍歷集合過程：

調用集合對象的iterator()方法獲得迭代器對象
使用迭代器對象的hashNext()方法判斷集合是否存在下一個元素
判斷結果爲true，則調用next()方法取出元素，

判斷結果爲false，則遍歷結束

實例代碼

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

public class Example{
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("data1");
        list.add("data2");
        list.add("data3");
        list.add("data4");
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println( iterator.next());
        }
    }
}

forEach遍歷集合

foreach循環是一種更加簡潔的for循環，也叫加強for循環

for(容器中元素類型 臨時變量 : 容器變量){
    //執行語句
}

注意：foreach循環過程中，不能對元素的值進行修改

實例代碼

public class Example{
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("data1");
        list.add("data2");
        list.add("data3");
        list.add("data4");
        for (Object o : list) {
            System.out.println(o);
        }
    }
}

JDK8的forEach遍歷集合

forEach(Consumer action)方法，方法的參數是一個函數式接口。

實例代碼

import java.util.ArrayList;

public class Example{
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("data1");
        list.add("data2");
        list.add("data3");
        list.add("data4");
        list.forEach(obj-> System.out.println("迭代集合元素："+obj));
    }
}

5.Set接口

Set接口簡介

set集合特點：

不允許存在重複元素
元素無序

HashSet集合

Set接口的一個實現類，特點和Set接口一樣

實例代碼

import java.util.Iterator;

public class Example{
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add("stu1");
        hashSet.add("stu2");
        hashSet.add("stu2");
        hashSet.add("stu3");
        System.out.println(hashSet);
        Iterator iterator = hashSet.iterator();
        while(iterator.hasNext()){
            System.out.println("第一種遍歷方式："+iterator.next());
        }
        for (Object i : hashSet) {
            System.out.println("第二種遍歷方式："+i);
        }
        hashSet.forEach(o-> System.out.println("第三種遍歷方式："+o));
    }
}

TreeSet集合

架構：平衡二叉樹

TreeSet集合的特有方法

方法聲明	功能描述
Object first()	返回該集合的開頭元素
Object last()	返回該集合的結尾元素
Object lower(Object o)	返回該集合中小於o的最大元素，沒有返回null
Object floor(Object o)	返回該集合中小於或等於o的最大元素，沒有返回null
Object higher(Object o)	返回該集合中大於o的最小元素，沒有返回null
Object ceiling(Object o)	返回該集合中大於或等於o的最小元素，沒有返回null
Object pollFirst()	刪除並返回該集合的開頭元素
Object pollLast()	刪除並返回該集合的結尾元素

實例代碼

import java.util.TreeSet;

public class Example{
    public static void main(String[] args) {
       //創建TreeSet集合
        TreeSet ts = new TreeSet();
        ts.add(2);
        ts.add(31);
        ts.add(9);
        ts.add(18);
        ts.add(9);
        System.out.println("創建的TreeSet集合："+ts);
        //獲取首尾元素
        System.out.println("TreeSet首元素："+ts.first());
        System.out.println("TreeSet結尾元素："+ts.last());
        //比較並獲取元素
        System.out.println("集合中小於或等於10的最大的一個元素"+ts.floor(10));
        System.out.println("集合中大於10的最小的一個元素"+ts.higher(10));
        System.out.println("集合中大於100的最小的一個元素"+ts.higher(100));
        //刪除元素
        Object o = ts.pollFirst();
        System.out.println("刪除元素："+o);
        System.out.println("刪除元素後的集合："+ts);
    }
}

TreeSet的排序規則

自然排序

TreeSet集合中存儲的元素所在類必須實現Comparable接口，並重寫compareTo()方法
TreeSet集合會對該類型元素使用compareTo()方法進行比較，默認升序排序

實例代碼


import java.util.TreeSet;

class Student implements Comparable{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return name+":"+age;
    }

    @Override
    public int compareTo(Object obj) {
        Student student = (Student) obj;
        if(this.age-student.age>0){
           return 1;
        }else if(this.age-student.age==0){
            return this.name.compareTo(student.name);
        }
        return -1;
    }
}
public class Example{
    public static void main(String[] args) {
       //創建TreeSet集合
        TreeSet ts = new TreeSet();
        ts.add(new Student("阿凡",19));
        ts.add(new Student("阿凡",23));
        ts.add(new Student("阿凡",6));
        ts.add(new Student("阿凡",23));

        System.out.println(ts); //[阿凡:6, 阿凡:19, 阿凡:23]

    }
}

定製排序

作用：自定義一個比較器

實例代碼

import java.util.Comparator;
import java.util.TreeSet;
//根據首字母大小寫排序
class MyComparator implements Comparator{
    @Override
    public int compare(Object o1, Object o2) {
        String name1 = (String) o1;
        String name2 = (String) o2;
        StringBuffer sb1 = new StringBuffer(name1);
        StringBuffer sb2 = new StringBuffer(name2);
        int temp = (int)sb1.charAt(0) - (int)sb2.charAt(0);
        return temp; //由低到高排序

    }
}
public class Example{
    public static void main(String[] args) {
       //創建TreeSet集合
        TreeSet ts = new TreeSet(new MyComparator());
        ts.add("Jack");
        ts.add("Tom");
        ts.add("Nancy");
        ts.add("Afan");
        System.out.println(ts); //[Afan, Jack, Nancy, Tom]
    }
}

6.Map接口

Map接口簡介

Map接口是一種雙列集合，它的每個元素都包含一個鍵對象Key和值對象Value，鍵和值對象之間存在一種對應關係，稱爲映射。Map的映射關係是一對一的。

特點：

Key與Value可以是任意數據類型
鍵對象Key不可以重複

Map集合常用方法

方法聲明	功能描述
void put(Object k,Object v)	往集合中添加鍵值對
int size()	返回鍵值對的個數
Object get(Object k)	根據鍵k得到值，沒有則返回null
boolean containsKey(Object k)	判斷集合是否存在鍵k
boolean containValue(Object v)	判斷集合是否存在值v
Object remove(Object k)	刪除並返回鍵k對應的鍵值對
void clear()	清空Map集合
Set keySet()	將鍵轉化爲Set集合
Collection values()	將值轉化爲Collection集合
Set<Map.Entry<K,V>>entrySet()	將Map集合轉化爲存儲類型爲Map的Set集合
Object getOrDefault(Object k,Object dv)	返回鍵k對應的值，沒有則返回dv
Object putIfAbsent(Object k,Object v)	添加鍵值對，重複則返回返回已存在值v
boolean remove(Object k,Object v)	刪除
boolean replace(Object k,Object v)	將制定鍵k對應的值修改爲值v

HashMap集合

架構：數組+鏈表

HashMap集合特點：

鍵和值允許爲空，但鍵不能重複
集合中的元素是無序的

實例代碼

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Example{
    public static void main(String[] args) {
        Map map = new HashMap();
        //向Map存儲鍵值對
        map.put(1,"Tom");
        map.put(2,"Afan");
        map.put(3,"Nancy");
        map.put(4,"Li");
        map.put(1,"Jack");
        System.out.println(map);
        //查看鍵對象是否存在
        System.out.println(map.containsKey(5));
        //將鍵轉化爲Set集合
        Set set = map.keySet();
        System.out.println(set);
        //獲取指定鍵對象映射的值
        Object o = map.get(2);
        System.out.println(o);
        //替換指定鍵對應的值
        map.replace(3,"阿凡");
        System.out.println(map);
        //刪除指定鍵映射的鍵值對元素
        map.remove(1);
        System.out.println(map);
    }
}

Map集合遍歷

Iterator迭代器遍歷Map集合

過程：

將Map集合轉化爲Iterator接口對象
兩種方式遍歷集合（KeySet()方法和entrySet()方法）

實例代碼1

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class Example{
    public static void main(String[] args) {
        Map map = new HashMap();
        //向Map存儲鍵值對
        map.put(1,"Tom");
        map.put(2,"Afan");
        map.put(3,"Nancy");
        map.put(4,"Li");
        map.put(5,"Jack");
        //keySet()方法
        Iterator iterator = map.keySet().iterator();
        while(iterator.hasNext()){
            Object key = iterator.next();
            Object value = map.get(key);
            System.out.println(key+":"+value);
        }
    }
}

實例代碼2

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Example{
    public static void main(String[] args) {
        Map map = new HashMap();
        //向Map存儲鍵值對
        map.put(1,"Tom");
        map.put(2,"Afan");
        map.put(3,"Nancy");
        map.put(4,"Li");
        map.put(5,"Jack");
        //entrySet()方法
        Set set = map.entrySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            Map.Entry next = (Map.Entry) iterator.next();
            Object key = next.getKey();
            Object value = next.getValue();
            System.out.println(key+":"+value);
        }
    }
}

注意：Entry是Map接口的內部類

使用forEach()方法遍歷集合

實例代碼

import java.util.HashMap;
import java.util.Map;
public class Example{
    public static void main(String[] args) {
        Map map = new HashMap();
        //向Map存儲鍵值對
        map.put(1,"Tom");
        map.put(2,"Afan");
        map.put(3,"Nancy");
        map.put(4,"Li");
        map.put(5,"Jack");

        map.forEach((key,value)-> System.out.println(key+":"+value));
    }
}

LinkedHashMap集合

LinkedHashMap類是HashMap的子類，內部是雙向鏈表

作用：保證元素取出順序與存入順序一致

實例代碼

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
public class Example{
    public static void main(String[] args) {
        Map map = new HashMap();
        //向Map存儲鍵值對
        map.put(4,"Tom");
        map.put(3,"Afan");
        map.put(2,"Nancy");
        map.put(1,"Li");
        System.out.println(map);
        System.out.println("-------兩者比較---------");
        LinkedHashMap map2 = new LinkedHashMap();
        map2.put(4,"Tom");
        map2.put(3,"Afan");
        map2.put(2,"Nancy");
        map2.put(1,"Li");
        System.out.println(map2);
    }
}

TreeMap集合

架構：二叉樹，用法參考TreeSet集合

實例代碼

import java.util.*;

class MyComparator implements Comparator{

    @Override
    public int compare(Object o1, Object o2) {
        String key1 = (String)o1;
        String key2 = (String)o2;
        return key1.compareTo(key2);
    }
}
public class Example{
    public static void main(String[] args) {
        Map map = new TreeMap(new MyComparator());
        map.put("2","Li");
        map.put("1","Afan");
        map.put("3","Tom"); //兩個參數必須是String類型，否則異常
        System.out.println(map);
    }
}

Properties集合

Properties類是Hashtable類的子類

實例代碼

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;

public class Example{
    public static void main(String[] args) throws Exception {
        //1.通過Properties進行屬性文件讀取操作
        Properties pps = new Properties();
        //加載要讀取的文件
        pps.load(new FileInputStream("test.properties"));
        //遍歷test.Properties鍵值對信息
        pps.forEach((key,value)-> System.out.println(key+"="+value));
        //2.通過Properties進行屬性文件讀取操作
        //指定要寫入操作的文件名稱和位置
        FileOutputStream out = new FileOutputStream("test.properties");
        //向properties文件進行寫入鍵值對信息
        pps.setProperty("charset","UTF-8");
        //將此新添鍵值對寫入配置文件
        pps.store(out,"新增charset編碼");
    }
}

7.泛型

作用：防止程序運行時出現類型轉換異常

具體格式：

ArrayList<參數化類型> list = new ArrayList<參數化類型>()；

8.常用工具類

Collection工具類

作用：集合工具類，提供了大量靜態方法用於對集合中元素進行排序、查找和修改

添加、排序操作

方法聲明	功能描述
staticboolean addAll(Collection<?super T>c,T…e)	將所有指定元素添加到指定集合c中
static void reverse(List list)	反轉指定List集合中元素的順序
static void shuffle(List list)	對List集合中的元素隨機排序
static void sort(List list)	對List集合中的元素自然排序
static void swap(List list,int i,int j)	將指定List集合第i和j處的元素交換

實例代碼

import java.util.ArrayList;
import java.util.Collections;

public class Example{
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"c","z","a","w");
        System.out.println("排序前："+list);
        Collections.reverse(list);
        System.out.println("反轉後："+list);
        Collections.sort(list);
        System.out.println("自然排序後："+list);
        Collections.shuffle(list);
        System.out.println("隨機打亂後："+list);
        Collections.swap(list,0,list.size()-1);
        System.out.println("首尾元素位置交換："+list);
    }
}

查找、替換操作

方法聲明	功能描述
static int binarySearch(List,Object k)	二分法搜索指定對象在List集合中的索引（查找的元素必須是有序的）
static Object max(Collection col)	根據元素的自然順序，返回給定集合中最大的元素
static Object min(Collection col)	根據元素的自然順序，返回給定集合中最小的元素
static boolean replaceAll(List list,Object o,Object n)	用n替換集合list裏所有的o

實例代碼

import java.util.ArrayList;
import java.util.Collections;

public class Example{
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,9,0,4,2,1,0,6);
        System.out.println("集合中的元素："+list);
        System.out.println("集合中最大元素"+ Collections.max(list));
        System.out.println("集合中最小元素"+ Collections.min(list));
        Collections.replaceAll(list,8,0);
        System.out.println("替換後的集合："+list);
        Collections.sort(list);
        int index = Collections.binarySearch(list, 2);
        System.out.println("集合通過二分查找法查找元素2的索引："+index);

    }
}

Arrays工具類

作用：數組工具類，提供了大量針對數組操作的靜態方法。

使用sort()方法排序

實例代碼

import java.util.Arrays;

public class Example{
    public static void main(String[] args) {
       int[] arr = {2,5,2,4,1,6,8};
        System.out.println("排序前：");
        printArray(arr);
        Arrays.sort(arr);
        System.out.println("排序後：");
        printArray(arr);
    }
    public static void printArray(int[] arr){
        for (int i : arr) {
            System.out.print(i+" ");
        }
        System.out.println();
    }
}

使用binarySearch(Object[] a,Object key)方法查找元素

實例代碼

import java.util.Arrays;

public class Example{
    public static void main(String[] args) {
      int[] arr = {9,3,8,2,1};
      Arrays.sort(arr);
      int index = Arrays.binarySearch(arr, 1);
      System.out.println("元素1的索引："+index);
    }
}

注意：二分法前提是這是有序數組

copyOfRange(int[] original,int from,int to)方法拷貝元素

實例代碼

import java.util.Arrays;

public class Example{
    public static void main(String[] args) {
        int[] arr = {9,3,8,2,1};
        int[] copied = Arrays.copyOfRange(arr,2,8);
        for (int i = 0; i < copied.length; i++) {
            System.out.print(copied[i]+" "); //8 2 1 0 0 0 
        }
    }
}

使用fill(Object[] a,Object val)方法替換元素

實例代碼

import java.util.Arrays;

public class Example{
    public static void main(String[] args) {
       int arr[] = {1,2,3,4};
       Arrays.fill(arr,8);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" "); //8 8 8 8 
        }
    }
}

9.聚合操作

聚合操作簡介

JDK8增加了一個Stream接口，該接口可以將集合、數組中的元素轉換爲Stream流的形式，並結合Lamabda表達式的優勢來進一步簡化集合、數組中的查找、過濾、轉換等操作，這一功能稱爲聚合操作。

使用聚合操作的3個步驟：

將原始集合或數組對象轉換爲Stream流對象。
對Stream流對象中的元素進行一系列的過濾、查找等中間操作，然後仍返回一個Stream流對象。
對Stream流進行遍歷、統計、收集等終結操作，獲取想要的結果。

實例代碼

import java.util.ArrayList;
import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        //創建一個List集合對象
        ArrayList<String> list = new ArrayList<>();
        list.add("阿凡");
        list.add("張三");
        list.add("李四");
        list.add("王五");
        //創建一個Stream流對象
        Stream<String> stream = list.stream();
        //鏈式調用
        stream.filter(i->i.startsWith("張")).limit(2)
                .forEach(j-> System.out.println(j));
    }
}

創建Stream流對象的三種方式

所有的Collection集合都可以使用stream()靜態方法獲取Stream流對象
Stream接口的of()靜態方法可以獲取基本類型包裝類數組、引用類型數組和單個元素的

Stream流對象
Arrays數組工具類的stream()靜態方法可以獲取數組元素的Stream流對象

實例代碼

import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        //創建一個List集合對象
        Integer[] arr = {2,3,7,5,0,1};
        ArrayList<String> list = new ArrayList<>();
        list.add("阿凡");
        list.add("張三");
        list.add("李四");
        list.add("王五");
        //創建一個Stream流對象
        Stream<String> stream1= list.stream();
        stream1.forEach(o-> System.out.print(o+" "));
        System.out.println();
        Stream<Integer> stream2 = Stream.of(arr);
        stream2.forEach(o-> System.out.print(o+" "));
        System.out.println();
        Stream<Integer> stream3 = Arrays.stream(arr);
        stream3.forEach(o-> System.out.print(o+" "));
        System.out.println();
    }
}

Stream流的常用方法

Stream流的常用方法

方法聲明	功能描述
Stream filer(函數式接口)	將指定流對象中的元素進行過濾，並返回一個子流對象
Streammap(Function函數式接口)	將流中的元素按規則映射到另一個流中
Stream distinct()	刪除流中的重複元素
Stream sorted()	將流中的元素按自然順序排序
Stream limit(long max)	截取流中元素的長度
Stream skip(long n)	跳過流中的前n個元素
staticStream concat(Stream 1，Stream 2)	將兩個流合併爲一個流
long count()	統計流中的元素個數
R collect(Collector collector)	將流中的元素收集到一個容器中（如集合）
Object[] toArray()	將流中的元素收集到一個數組中
void forEach(Lamabda表達式)	將流中的元素進行遍歷

遍歷

實例代碼

import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("張三", "李四", "阿凡", "張曉明");
        stream.forEach(o-> System.out.println(o));
    }
}

過濾

實例代碼

public class Example{
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("張三", "李四", "阿凡", "張曉明");
        stream.filter(i->i.startsWith("張"))
                .filter(i->i.length()>2)
                .forEach(System.out::println);
    }
}

映射

實例代碼

import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("a1","a2","b1","c1","c2");
        stream.filter(s->s.startsWith("c"))
                .map((String s)->s.toUpperCase() )
                .sorted()
                .forEach(i-> System.out.println(i));

    }
}

截取

實例代碼

import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("張三","李四","張曉明","張陽");
        stream.skip(1)  
                .limit(2)
                .forEach(i-> System.out.println(i));
        
    }
}

收集

作用：終結操作，把Stream元素保存爲集合、字符串等。

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("張三","李四","張曉明","張陽");
        List<String> list = stream.filter(i -> i.startsWith("張"))
                .collect(Collectors.toList());
        System.out.println("轉化爲集合："+list);
        //轉化爲集合：[張三, 張曉明, 張陽]
        Stream<String> stream2 = Stream.of("張三","李四","張曉明","張陽");
        String str = stream2.filter(i -> i.startsWith("張"))
                .collect(Collectors.joining("and"));
        System.out.println("轉化爲字符串："+str);
        //轉化爲字符串：張三and張曉明and張陽
    }
}

注意：一個Stream流對象可以有多次中間操作，仍返回一個流對象，

一個流對象只能進行一次終結操作，且一旦進行，該流對象就不復存在。

Parallel Stream（並行流）

之前介紹的創建Stream流對象的3種方式都是串行流，即單線程下執行聚合操作的流

並行流將源數據分爲多個子流對象支持多線程操作，最後結果彙總爲一個流對象

創建並行流的兩種方式

通過Collection集合接口的parallelStream()方法直接將集合類型的源數據轉變爲Stream並行流
BaseStream接口的parallel()方法將Stream串行流轉變爲Stream並行流，還有一個isParallel()方法用於判斷當前Stream流對象是否是並行流。

實例代碼

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Example{
    public static void main(String[] args) {
        List<String> list = Arrays.asList("張三", "李四", "張曉明", "張陽");
        Stream<String> parallelStream = list.parallelStream();
        System.out.println(parallelStream.isParallel());  //true
        Stream<String> stream = Stream.of("張三", "李四", "張曉明", "張陽");
        Stream<String> parallel = stream.parallel();
        System.out.println(parallel.isParallel());  //true

    }
}

2020年Java集合課堂筆記

Java集合

1.集合概述

2.Collection接口

3.List接口

List接口簡介

ArrayList集合

LinkedList集合

4.3種Collection集合遍歷

Iterator遍歷集合

forEach遍歷集合

JDK8的forEach遍歷集合

5.Set接口

Set接口簡介

HashSet集合

TreeSet集合

6.Map接口

Map接口簡介

HashMap集合

Map集合遍歷

LinkedHashMap集合

TreeMap集合

Properties集合

7.泛型

8.常用工具類

Collection工具類

Arrays工具類

9.聚合操作

聚合操作簡介

創建Stream流對象的三種方式

Stream流的常用方法

Parallel Stream（並行流）

2020年java面向對象編程oop課堂筆記

2020年java流程控制課堂筆記

2020年Java集合課堂筆記

初學者用java實現基礎單鏈表

2020年Filter&Listener課堂筆記

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結