2020年Java集合课堂笔记
生活随笔
收集整理的這篇文章主要介紹了
2020年Java集合课堂笔记
小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.
Java集合
1.集合概述
集合：集合是java中提供的一種容器，可以用來存儲多個數(shù)據(jù)。
集合與數(shù)組的區(qū)別：
- 數(shù)組長度固定，集合長度可變
- 數(shù)組只能存儲類型相同的元素，集合存儲對象，對象類型可以不同
集合框架
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() | 判斷該集合元素的個數(shù) |
| Iterator iterator() | 用于遍歷該集合的所有元素 |
| Stream stream() | 將集合源轉(zhuǎn)換為有序元素的流對象 |
3.List接口
List接口簡介
List集合：實現(xiàn)了List接口的對象
List集合特點：
- 允許出現(xiàn)重復(fù)的元素
- 元素有序
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在集合中第一次出現(xiàn)的位置索引 |
| int lastIndexOf(Object e) | 返回元素e在集合中最后一次出現(xiàn)的位置索引 |
| List subList(int f，int t) | 返回該集合中位置f~t之間所有元素組成的子集合 |
| Object[] toArray() | 將集合元素轉(zhuǎn)換為數(shù)組 |
ArrayList集合
架構(gòu)：數(shù)組
作用：適用于遍歷查找元素
缺點：不適合對集合元素做大量增刪操作
實例代碼
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()); //4System.out.println(arrayList.get(3)); //1} }LinkedList集合
架構(gòu)：雙向循環(huán)鏈表
作用：更高效的增加和刪除集合中的元素
LinkedList特有方法
| void add(int d,E e) | 在該集合位置d插入元素e |
| void addFirst(object o) | 在該集合開頭插入元素o |
| void addLast(object o) | 在該集合結(jié)尾插入元素o |
| Object removeFirst() | 刪除該集合開頭的元素，并返回該元素 |
| Object removeLast() | 刪除該集合結(jié)尾的元素，并返回該元素 |
| boolean offerFirst(Object o) | 在該集合開頭插入元素o |
| boolean offer(Object o) | 在該集合結(jié)尾插入元素o |
| boolean offerLast(Object o) | 在該集合結(jié)尾插入元素o |
| Object peek() | 獲取該集合開頭的元素 |
| Object peekLast() | 獲取該集合結(jié)尾的元素 |
| Object poll() | 刪除并返回該集合的開頭元素 |
| Object pollLast() | 刪除并返回該集合的結(jié)尾元素 |
| 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");//在集合結(jié)尾添加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中的元素
遍歷集合過程：
調(diào)用集合對象的iterator()方法獲得迭代器對象
使用迭代器對象的hashNext()方法判斷集合是否存在下一個元素
判斷結(jié)果為true，則調(diào)用next()方法取出元素，
判斷結(jié)果為false，則遍歷結(jié)束
實例代碼
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循環(huán)是一種更加簡潔的for循環(huán)，也叫加強(qiáng)for循環(huán)
for(容器中元素類型 臨時變量 : 容器變量){//執(zhí)行語句 }注意：foreach循環(huán)過程中，不能對元素的值進(jìn)行修改
實例代碼
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)方法，方法的參數(shù)是一個函數(shù)式接口。
實例代碼
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集合特點：
- 不允許存在重復(fù)元素
- 元素?zé)o序
HashSet集合
Set接口的一個實現(xiàn)類，特點和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集合
架構(gòu)：平衡二叉樹
TreeSet集合的特有方法
| Object first() | 返回該集合的開頭元素 |
| Object last() | 返回該集合的結(jié)尾元素 |
| 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() | 刪除并返回該集合的結(jié)尾元素 |
實例代碼
import java.util.TreeSet;public class Example{public static void main(String[] args) {//創(chuàng)建TreeSet集合TreeSet ts = new TreeSet();ts.add(2);ts.add(31);ts.add(9);ts.add(18);ts.add(9);System.out.println("創(chuàng)建的TreeSet集合："+ts);//獲取首尾元素System.out.println("TreeSet首元素："+ts.first());System.out.println("TreeSet結(jié)尾元素："+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的排序規(guī)則
- TreeSet集合中存儲的元素所在類必須實現(xiàn)Comparable接口，并重寫compareTo()方法
- TreeSet集合會對該類型元素使用compareTo()方法進(jìn)行比較，默認(rèn)升序排序
實例代碼
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;}@Overridepublic String toString() {return name+":"+age;}@Overridepublic 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) {//創(chuàng)建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; //根據(jù)首字母大小寫排序 class MyComparator implements Comparator{@Overridepublic 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) {//創(chuàng)建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，鍵和值對象之間存在一種對應(yīng)關(guān)系，稱為映射。Map的映射關(guān)系是一對一的。
特點：
- Key與Value可以是任意數(shù)據(jù)類型
- 鍵對象Key不可以重復(fù)
Map集合常用方法
| void put(Object k,Object v) | 往集合中添加鍵值對 |
| int size() | 返回鍵值對的個數(shù) |
| Object get(Object k) | 根據(jù)鍵k得到值，沒有則返回null |
| boolean containsKey(Object k) | 判斷集合是否存在鍵k |
| boolean containValue(Object v) | 判斷集合是否存在值v |
| Object remove(Object k) | 刪除并返回鍵k對應(yīng)的鍵值對 |
| void clear() | 清空Map集合 |
| Set keySet() | 將鍵轉(zhuǎn)化為Set集合 |
| Collection values() | 將值轉(zhuǎn)化為Collection集合 |
| Set<Map.Entry<K,V>>entrySet() | 將Map集合轉(zhuǎn)化為存儲類型為Map的Set集合 |
| Object getOrDefault(Object k,Object dv) | 返回鍵k對應(yīng)的值，沒有則返回dv |
| Object putIfAbsent(Object k,Object v) | 添加鍵值對，重復(fù)則返回返回已存在值v |
| boolean remove(Object k,Object v) | 刪除 |
| boolean replace(Object k,Object v) | 將制定鍵k對應(yīng)的值修改為值v |
HashMap集合
架構(gòu)：數(shù)組+鏈表
HashMap集合特點：
- 鍵和值允許為空，但鍵不能重復(fù)
- 集合中的元素是無序的
實例代碼
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));//將鍵轉(zhuǎn)化為Set集合Set set = map.keySet();System.out.println(set);//獲取指定鍵對象映射的值Object o = map.get(2);System.out.println(o);//替換指定鍵對應(yīng)的值map.replace(3,"阿凡");System.out.println(map);//刪除指定鍵映射的鍵值對元素map.remove(1);System.out.println(map);} }Map集合遍歷
Iterator迭代器遍歷Map集合
過程：
實例代碼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接口的內(nèi)部類
使用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的子類，內(nèi)部是雙向鏈表
作用：保證元素取出順序與存入順序一致
實例代碼
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集合
架構(gòu)：二叉樹，用法參考TreeSet集合
實例代碼
import java.util.*;class MyComparator implements Comparator{@Overridepublic 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"); //兩個參數(shù)必須是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進(jìn)行屬性文件讀取操作Properties pps = new Properties();//加載要讀取的文件pps.load(new FileInputStream("test.properties"));//遍歷test.Properties鍵值對信息pps.forEach((key,value)-> System.out.println(key+"="+value));//2.通過Properties進(jìn)行屬性文件讀取操作//指定要寫入操作的文件名稱和位置FileOutputStream out = new FileOutputStream("test.properties");//向properties文件進(jìn)行寫入鍵值對信息pps.setProperty("charset","UTF-8");//將此新添鍵值對寫入配置文件pps.store(out,"新增charset編碼");} }7.泛型
作用：防止程序運(yùn)行時出現(xiàn)類型轉(zhuǎn)換異常
具體格式：
ArrayList<參數(shù)化類型> list = new ArrayList<參數(shù)化類型>()；
8.常用工具類
Collection工具類
作用：集合工具類，提供了大量靜態(tài)方法用于對集合中元素進(jìn)行排序、查找和修改
| staticboolean addAll(Collection<?super T>c,T…e) | 將所有指定元素添加到指定集合c中 |
| static void reverse(List list) | 反轉(zhuǎn)指定List集合中元素的順序 |
| static void shuffle(List list) | 對List集合中的元素隨機(jī)排序 |
| 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("反轉(zhuǎn)后："+list);Collections.sort(list);System.out.println("自然排序后："+list);Collections.shuffle(list);System.out.println("隨機(jī)打亂后："+list);Collections.swap(list,0,list.size()-1);System.out.println("首尾元素位置交換："+list);} }| static int binarySearch(List,Object k) | 二分法搜索指定對象在List集合中的索引（查找的元素必須是有序的） |
| static Object max(Collection col) | 根據(jù)元素的自然順序，返回給定集合中最大的元素 |
| static Object min(Collection col) | 根據(jù)元素的自然順序，返回給定集合中最小的元素 |
| 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工具類
作用：數(shù)組工具類，提供了大量針對數(shù)組操作的靜態(tài)方法。
使用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);} }注意：二分法前提是這是有序數(shù)組
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接口，該接口可以將集合、數(shù)組中的元素轉(zhuǎn)換為Stream流的形式，并結(jié)合Lamabda表達(dá)式的優(yōu)勢來進(jìn)一步簡化集合、數(shù)組中的查找、過濾、轉(zhuǎn)換等操作，這一功能稱為聚合操作。
使用聚合操作的3個步驟：
實例代碼
import java.util.ArrayList; import java.util.stream.Stream;public class Example{public static void main(String[] args) {//創(chuàng)建一個List集合對象ArrayList<String> list = new ArrayList<>();list.add("阿凡");list.add("張三");list.add("李四");list.add("王五");//創(chuàng)建一個Stream流對象Stream<String> stream = list.stream();//鏈?zhǔn)秸{(diào)用stream.filter(i->i.startsWith("張")).limit(2).forEach(j-> System.out.println(j));} }創(chuàng)建Stream流對象的三種方式
-
所有的Collection集合都可以使用stream()靜態(tài)方法獲取Stream流對象
-
Stream接口的of()靜態(tài)方法可以獲取基本類型包裝類數(shù)組、引用類型數(shù)組和單個元素的
Stream流對象
-
Arrays數(shù)組工具類的stream()靜態(tài)方法可以獲取數(shù)組元素的Stream流對象
實例代碼
import java.util.ArrayList; import java.util.Arrays; import java.util.stream.Stream;public class Example{public static void main(String[] args) {//創(chuàng)建一個List集合對象Integer[] arr = {2,3,7,5,0,1};ArrayList<String> list = new ArrayList<>();list.add("阿凡");list.add("張三");list.add("李四");list.add("王五");//創(chuàng)建一個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(函數(shù)式接口) | 將指定流對象中的元素進(jìn)行過濾，并返回一個子流對象 |
| Streammap(Function函數(shù)式接口) | 將流中的元素按規(guī)則映射到另一個流中 |
| Stream distinct() | 刪除流中的重復(fù)元素 |
| Stream sorted() | 將流中的元素按自然順序排序 |
| Stream limit(long max) | 截取流中元素的長度 |
| Stream skip(long n) | 跳過流中的前n個元素 |
| staticStream concat(Stream 1，Stream 2) | 將兩個流合并為一個流 |
| long count() | 統(tǒng)計流中的元素個數(shù) |
| R collect(Collector collector) | 將流中的元素收集到一個容器中（如集合） |
| Object[] toArray() | 將流中的元素收集到一個數(shù)組中 |
| void forEach(Lamabda表達(dá)式) | 將流中的元素進(jìn)行遍歷 |
實例代碼
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));} }作用：終結(jié)操作，把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("轉(zhuǎn)化為集合："+list);//轉(zhuǎn)化為集合：[張三, 張曉明, 張陽]Stream<String> stream2 = Stream.of("張三","李四","張曉明","張陽");String str = stream2.filter(i -> i.startsWith("張")).collect(Collectors.joining("and"));System.out.println("轉(zhuǎn)化為字符串："+str);//轉(zhuǎn)化為字符串：張三and張曉明and張陽} }注意：一個Stream流對象可以有多次中間操作，仍返回一個流對象，
? 一個流對象只能進(jìn)行一次終結(jié)操作，且一旦進(jìn)行，該流對象就不復(fù)存在。
Parallel Stream（并行流）
之前介紹的創(chuàng)建Stream流對象的3種方式都是串行流，即單線程下執(zhí)行聚合操作的流
并行流將源數(shù)據(jù)分為多個子流對象支持多線程操作，最后結(jié)果匯總為一個流對象
創(chuàng)建并行流的兩種方式
實例代碼
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()); //trueStream<String> stream = Stream.of("張三", "李四", "張曉明", "張陽");Stream<String> parallel = stream.parallel();System.out.println(parallel.isParallel()); //true} }總結(jié)
以上是生活随笔為你收集整理的2020年Java集合课堂笔记的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 个人推荐讲的非常好的数据结构免费[速成
- 下一篇： SaaS（软件即服务）的魅力