溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹“Java8中Stream的使用方式是什么”，在日常操作中，相信很多人在Java8中Stream的使用方式是什么問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Java8中Stream的使用方式是什么”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！
性能優勢，(大數據量)相較于迭代器，速度更快
支持串行與并行處理，并行處理更能充分利用CPU的資源
Stream 是一種計算數據的流，它本身不會存儲數據
支持函數式編程
代碼優雅，讓代碼更高效，干凈，簡潔
三步操作：
創建Stream
中間操作
終止操作
Stream 的 創建都會依賴于數據源，通常是容器或者數組 Stream 流的創建大致分為4中，最為常用的就是通過集合創建
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class CreateStreamDemo {
public static void main(String[] args) {
// 1 通過集合創建Stream也是用的最多的一種形式
List<String> strList = new ArrayList<>();
strList.add("a");
strList.add("b");
strList.add("c");
// 創建串行操作流
Stream<String> stream = strList.stream();
// 創建并行操作流
Stream<String> parallelStream = strList.parallelStream();
// 2 通過數組創建Stream
int[] arr = new int[]{1,2,3};
IntStream intStream = Arrays.stream(arr);
// 3 通過Stream.of
Stream<Integer> integerStream = Stream.of(1,2,3);
Stream<String> stringStream = Stream.of("a","b","c");
// 4 無限流
// 每隔五個數取一個
Stream.iterate(0, t -> t + 5).forEach(System.out::println); // 迭代
Stream.generate(Math::random).forEach(System.out::println); // 生成
}
}Stream 中間操作，我們最為常用的就是過濾，去重，排序 本章包含我們開發最常用的對對象的去重，和更據對象中的對個屬性組合排序
import com.zhj.java8.bean.Student;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
import java.util.stream.Stream;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toCollection;
public class MiddleStreamDemo {
public static void main(String[] args) {
List<Student> students = new ArrayList<>();
students.add(new Student(1,"小華",23,1));
students.add(new Student(1,"小華",23,2));
students.add(new Student(2,"小米",20,2));
students.add(new Student(3,"小果",30,3));
students.add(new Student(4,"小維",18,2));
// 過濾
students.stream().filter(stu -> stu.getAge() > 20).forEach(System.out::println);
// 去重
// 對對象去重是根據引用去重，內容重復并不會去重，除非重寫equals和hashCode方法
System.out.println("----------去重----------");
System.out.println("去重1----------");
students.stream().distinct().forEach(System.out::println);
// 對集合中對象某些屬性去重，不重寫equals和hashCode方法，只能借助其他數據結構來輔助去重
// 單個屬性可以stu -> stu.getId()
// 多個屬性可以stu -> stu.getId() + ";" + stu.getName()
System.out.println("去重2----------");
ArrayList<Student> distinctList = students.stream().collect(
collectingAndThen(toCollection(() -> new TreeSet<>(Comparator.comparing(stu -> stu.getId() + ";" + stu.getName()))), ArrayList::new)
);
distinctList.stream().forEach(System.out::println);
// 排序 支持定義排序方式
// sorted 默認使用 自然序排序， 其中的元素必須實現Comparable 接口
System.out.println("----------排序----------");
System.out.println("排序1----------");
students.stream().sorted().forEach(System.out::println);
// sorted(Comparator<? super T> comparator) ：我們可以使用lambada 來創建一個Comparator 實例。可以按照升序或著降序來排序元素。
System.out.println("排序2----------");
students.stream()
.sorted(Comparator.comparing(Student::getAge,Comparator.reverseOrder())) // ,Comparator.reverseOrder() 逆序
.forEach(System.out::println);
// 創建比較器，通過對比較器內容的定義實現對多個屬性進行排序，類似sql中連續的orderBy
System.out.println("排序3----------");
students.stream().sorted(
(s1,s2) -> {
if (s1.getAge() == s2.getAge()) {
return s1.getSex().compareTo(s2.getSex());
} else {
return -s1.getAge().compareTo(s2.getAge());
}
}
).forEach(System.out::println);
System.out.println("排序4----------");
Comparator<Student> studentComparator = (s1,s2) -> {
Integer age1 = s1.getAge();
Integer age2 = s2.getAge();
if (age1 != age2) return age1 - age2;
Integer sex1 = s1.getSex();
Integer sex2 = s2.getSex();
if (sex1 != sex2) return sex2 - sex1;
return 0;
};
students.stream().sorted(studentComparator).forEach(System.out::println);
// 截取 截取前三個元素
System.out.println("----------截取----------");
students.stream().limit(3).forEach(System.out::println);
// 跳過 跳過前3個元素
System.out.println("----------跳過----------");
students.stream().skip(3).forEach(System.out::println);
// 映射
System.out.println("----------映射----------");
System.out.println("映射Map----------");
// map接收Lambda,將元素轉換其他形式，或者是提取信息，并將其映射成一個新的元素
Stream<Stream<Student>> streamStream1 = students.stream().map(str -> filterStudent(str));
streamStream1.forEach(sm -> sm.forEach(System.out::println));
System.out.println("映射flatMap----------");
// map接收Lambda,將流中的每一個元素轉換成另一個流，然后把所有流連成一個流 扁平化映射
Stream<Student> studentStream2 = students.stream().flatMap(str -> filterStudent(str));
studentStream2.forEach(System.out::println);
// 消費
System.out.println("----------消費----------");
students.stream().peek(stu -> stu.setAge(100)).forEach(System.out::println);
}
public static Stream<Student> filterStudent(Student student) {
student = new Student();
return Stream.of(student);
}
}Student
public class Student implements Comparable<Student> {
private Integer id;
private String name;
private Integer age;
private Integer sex;
public Student() {
}
public Student(Integer id, String name, Integer age, Integer sex) {
this.id = id;
this.name = name;
this.age = age;
this.sex = sex;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Integer getSex() {
return sex;
}
public void setSex(Integer sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Student{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", age='" + age + '\'' +
", sex=" + sex +
'}';
}
@Override
public int compareTo(Student o) {
return this.getAge() - o.getAge();
}
}Stream 的終止操作，最常用的就是講處理過的數據收集到新的容器中，同時可以實現向Sql聚合函數，分組的一些效果
package com.zhj.java8.stream;
import com.zhj.java8.bean.Student;
import java.util.*;
import java.util.stream.Collectors;
public class TerminationStreamDemo {
public static void main(String[] args) {
List<Student> students = new ArrayList<>();
students.add(new Student(1,"小華",23,1));
students.add(new Student(2,"小米",20,2));
students.add(new Student(3,"小果",30,3));
students.add(new Student(4,"小維",18,2));
students.add(new Student(5,"小華",23,2));
System.out.println("--------------------匹配聚合操作--------------------");
// allMatch：接收一個 Predicate 函數，當流中每個元素都符合該斷言時才返回true，否則返回false
boolean allMatch = students.stream().allMatch(stu -> stu.getAge() > 10);
System.out.println("全部符合大于10歲條件：" + allMatch);
// noneMatch：接收一個 Predicate 函數，當流中每個元素都不符合該斷言時才返回true，否則返回false
boolean noneMatch = students.stream().noneMatch(stu -> stu.getAge() > 10);
System.out.println("全部不符合大于10歲條件：" + noneMatch);
// anyMatch：接收一個 Predicate 函數，只要流中有一個元素滿足該斷言則返回true，否則返回false
boolean anyMatch = students.stream().anyMatch(stu -> stu.getAge() > 20);
System.out.println("含有任意符合大于20歲條件：" + anyMatch);
// findFirst：返回流中第一個元素
Student findFirst = students.stream().findFirst().get();
System.out.println("第一個學生：" + findFirst);
// findAny：返回流中的任意元素
Student findAny = students.stream().findAny().get();
System.out.println("任意一個學生：" + findAny);
// count：返回流中元素的總個數
long count = students.stream().count();
System.out.println("學生總數：" + count);
// max：返回流中元素最大值
Student max = students.stream().max(Student::compareTo).get();
System.out.println("年齡最大學生：" + max);
// max：返回流中元素最大值
Student min = students.stream().min(Student::compareTo).get();
System.out.println("年齡最小學生：" + min);
System.out.println("--------------------規約操作--------------------");
System.out.println("學生年齡總和：" + students.stream().map(Student::getAge).reduce(Integer::sum));
System.out.println("學生年齡最大：" + students.stream().map(Student::getAge).reduce(Integer::max));
System.out.println("--------------------收集操作--------------------");
List<Student> list = students.stream().collect(Collectors.toList());
Set<Student> set = students.stream().collect(Collectors.toSet());
Map<Integer, String> map = students.stream().collect(Collectors.toMap(Student::getId, Student::getName));
String joinName = students.stream().map(Student::getName).collect(Collectors.joining(",", "(", ")"));
// 總數
students.stream().collect(Collectors.counting());
// 最大年齡
students.stream().map(Student::getAge).collect(Collectors.maxBy(Integer::compare)).get();
// 年齡和
students.stream().collect(Collectors.summingInt(Student::getAge));
// 平均年齡
students.stream().collect(Collectors.averagingDouble(Student::getAge));
// 信息合集
DoubleSummaryStatistics statistics = students.stream().collect(Collectors.summarizingDouble(Student::getAge));
System.out.println("count:" + statistics.getCount() + ",max:" + statistics.getMax() + ",sum:" + statistics.getSum() + ",average:" + statistics.getAverage());
// 分組
Map<Integer, List<Student>> collect = students.stream().collect(Collectors.groupingBy(Student::getSex));
System.out.println(collect);
//多重分組,先根據性別分再根據年齡分
Map<Integer, Map<Integer, List<Student>>> typeAgeMap = list.stream().collect(Collectors.groupingBy(Student::getSex, Collectors.groupingBy(Student::getAge)));
//分區
//分成兩部分，一部分大于20歲，一部分小于等于20歲
Map<Boolean, List<Student>> partMap = list.stream().collect(Collectors.partitioningBy(v -> v.getAge() > 20));
//規約
Integer allAge = list.stream().map(Student::getAge).collect(Collectors.reducing(Integer::sum)).get();
System.out.println(allAge);
}
}中間操作惰性執行
多個中間操作的話，不會多次循環，多個轉換操作只會在終止操作的時候融合起來，一次循環完成。
內部迭代
找到符合條件的數據后邊的迭代不會進行
流的末端操作只有一次
異常：stream has already been operated upon or closed
意思是流已經被關閉了，這是因為當我們使用末端操作之后，流就被關閉了，無法再次被調用，如果我們想重復調用，只能重新打開一個新的流。
到此，關于“Java8中Stream的使用方式是什么”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
