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
}
}
678
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
