国产无码综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

<address id="wtboo"><thead id="wtboo"></thead></address>

Java8的Stream流的學(xué)習(xí)

2年前作者：qinxun2008081分類：Toy博客閱讀(25)違法舉報

這篇具有很好參考價值的文章主要介紹了Java8的Stream流的學(xué)習(xí)。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方，請大家不吝賜教，您也可以點(diǎn)擊"舉報違法"按鈕提交疑問。

一.概念理解

Stream可以由數(shù)組或集合創(chuàng)建，對流的操作分為兩種：

中間操作，每次返回一個新的流，可以有多個。
終端操作，每個流只能進(jìn)行一次終端操作，終端操作結(jié)束后流無法再次使用。終端操作會產(chǎn)生一個新的集合或值。

二、Stream的創(chuàng)建

public class StreamDemo {
    public static void main(String[] args) {
        // 集合
        List<Integer> list = Arrays.asList(1, 2, 3);
        // 集合創(chuàng)建一個順序流
        Stream<Integer> stream = list.stream();
        // 集合創(chuàng)建一個并行流
        Stream<Integer> parallelStream = list.parallelStream();


        // 數(shù)組
        int[] array = {1, 3, 5, 6, 8};
        // 數(shù)組創(chuàng)建流方式
        IntStream intStream = Arrays.stream(array);
        
    }
}

stream和parallelStream的簡單區(qū)分：?stream是順序流，由主線程按順序?qū)α鲌?zhí)行操作，而parallelStream是并行流，內(nèi)部以多線程并行執(zhí)行的方式對流進(jìn)行操作，但前提是流中的數(shù)據(jù)處理沒有順序要求

三.方法學(xué)習(xí)

1、遍歷/匹配（foreach/find/match）

import java.util.*;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 職工測試類
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        // foreach
        list.forEach(System.out::println);

        System.out.println("----------");

        //find
        Optional<Integer> firstData = list.stream().findFirst();
        System.out.println(firstData.get());

        System.out.println("----------");

        //match: anyMatch有一個匹配就返回true noneMatch沒有任何匹配才返回true allMatch所有匹配才返回true
        System.out.println(list.stream().anyMatch(x -> x > 4));
    }

    /**
     * 初始化職工列表數(shù)據(jù)
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("張三", 8, 3000.0));
        employeeList.add(new Employee("李四", 18, 5000.0));
        employeeList.add(new Employee("王五", 28, 7000.0));
        employeeList.add(new Employee("孫六", 38, 9000.0));
        return employeeList;
    }
}

執(zhí)行程序返回

1
2
3
4
5
----------
1
----------
true

2、按條件匹配filter?

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 職工測試類
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = initEmployee();
        // 篩選年紀(jì)大于18歲的職工
        List<Employee> employees = employeeList.stream().filter(s -> s.getAge() > 18).collect(Collectors.toList());
        System.out.println(employees);
    }

    /**
     * 初始化職工列表數(shù)據(jù)
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("張三", 8, 3000.0));
        employeeList.add(new Employee("李四", 18, 5000.0));
        employeeList.add(new Employee("王五", 28, 7000.0));
        employeeList.add(new Employee("孫六", 38, 9000.0));
        return employeeList;
    }
}

[Employee{name='王五', age=28, salary=7000.0}, Employee{name='孫六', age=38, salary=9000.0}]

3、聚合max、min、count

import java.util.*;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 職工測試類
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = initEmployee();
        // 獲取薪水最高的職工
        Optional<Employee> employeeOptional = employeeList.stream().max(Comparator.comparing(Employee::getSalary, Double::compareTo));
        System.out.println(employeeOptional.get());

        // 獲取年級最小的職工
        Optional<Employee> employeeOptional1 = employeeList.stream().min(Comparator.comparing(Employee::getAge, Integer::compareTo));
        System.out.println(employeeOptional1.get());

        // 獲取年級大于18的職工數(shù)量
        long count = employeeList.stream().filter(s -> s.getAge() > 18).count();
        System.out.println(count);
    }

    /**
     * 初始化職工列表數(shù)據(jù)
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("張三", 8, 3000.0));
        employeeList.add(new Employee("李四", 18, 5000.0));
        employeeList.add(new Employee("王五", 28, 7000.0));
        employeeList.add(new Employee("孫六", 38, 9000.0));
        return employeeList;
    }
}

Employee{name='孫六', age=38, salary=9000.0}
Employee{name='張三', age=8, salary=3000.0}
2

4、map與flatMap

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 職工測試類
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("a","b","c");
        // map中把小寫字母轉(zhuǎn)換成大寫
        List<String> stringList = list.stream().map(String::toUpperCase).collect(Collectors.toList());
        // 輸出[A, B, C]
        System.out.println(stringList);
    }
}

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 職工測試類
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        String[] arr = {"z-h-a-n-g", "s-a-n"};
        List<String> list = Arrays.asList(arr);
        System.out.println(list);
        // 將兩個字符數(shù)組合并成一個新的字符數(shù)組
        List<String> collect = list.stream().flatMap(x -> {
            String[] array = x.split("-");
            return Arrays.stream(array);
        }).collect(Collectors.toList());
        System.out.println(collect);
    }
}

[z-h-a-n-g, s-a-n]
[z, h, a, n, g, s, a, n]

5、規(guī)約reduce?

歸約，也稱縮減，顧名思義，是把一個流縮減成一個值，能實(shí)現(xiàn)對集合求和、求乘積和求最值操作。

import java.util.*;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 職工測試類
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> list = initEmployee();
        // 求所有工資的和
        Double sum = list.stream().map(Employee::getSalary).reduce(0.0, Double::sum);
        System.out.println(sum);

        // 求職工工資最大值
        Optional<Double> max = list.stream().map(Employee::getSalary).reduce((a, b) -> a > b ? a : b);
        System.out.println(max.get());
    }

    /**
     * 初始化職工列表數(shù)據(jù)
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("張三", 8, 3000.0));
        employeeList.add(new Employee("李四", 18, 5000.0));
        employeeList.add(new Employee("王五", 28, 7000.0));
        employeeList.add(new Employee("孫六", 38, 9000.0));
        return employeeList;
    }
}

24000.0
9000.0

6、收集（toList、toSet、toMap）

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 職工測試類
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> list = initEmployee();
        // 返回名字做為key,工資做為value的map數(shù)據(jù)
        Map<String, Double> employeeMap = list.stream().collect(Collectors.toMap(Employee::getName, Employee::getSalary));
        System.out.println(employeeMap);

        // 職工名字集合
        List<String> employeeNameList = list.stream().map(Employee::getName).collect(Collectors.toList());
        System.out.println(employeeNameList);

        // 職工年齡集合
        Set<Integer> ageSet = list.stream().map(s -> s.getAge()).collect(Collectors.toSet());
        System.out.println(ageSet);
    }

    /**
     * 初始化職工列表數(shù)據(jù)
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("張三", 8, 3000.0));
        employeeList.add(new Employee("李四", 18, 5000.0));
        employeeList.add(new Employee("王五", 28, 7000.0));
        employeeList.add(new Employee("孫六", 38, 9000.0));
        return employeeList;
    }
}

{李四=5000.0, 張三=3000.0, 王五=7000.0, 孫六=9000.0}
[張三, 李四, 王五, 孫六]
[18, 38, 8, 28]

7、collect

Collectors提供了一系列用于數(shù)據(jù)統(tǒng)計的靜態(tài)方法：

計數(shù)：count
平均值：averagingInt、averagingLong、averagingDouble
最值：maxBy、minBy
求和：summingInt、summingLong、summingDouble
統(tǒng)計以上所有：summarizingInt、summarizingLong、summarizingDouble

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 職工測試類
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = initEmployee();

        // 統(tǒng)計職工人數(shù)
        Long count = employeeList.stream().collect(Collectors.counting());
        System.out.println(count);

        // 獲取職工最高工資
        Optional<Double> salaryOptional = employeeList.stream().map(Employee::getSalary).collect(Collectors.maxBy((s1, s2) -> s1.compareTo(s2)));
        System.out.println(salaryOptional);

        // 獲取職工平均工資
        Double averageSalary = employeeList.stream().collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(averageSalary);

        //一次性統(tǒng)計職工所有工資信息
        DoubleSummaryStatistics summaryStatistics = employeeList.stream().collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(summaryStatistics);
    }

    /**
     * 初始化職工列表數(shù)據(jù)
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("張三", 8, 3000.0));
        employeeList.add(new Employee("李四", 18, 5000.0));
        employeeList.add(new Employee("王五", 28, 7000.0));
        employeeList.add(new Employee("孫六", 38, 9000.0));
        return employeeList;
    }
}

4
Optional[9000.0]
6000.0
DoubleSummaryStatistics{count=4, sum=24000.000000, min=3000.000000, average=6000.000000, max=9000.000000}

8、分組(partitioningBy/groupingBy)

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 職工測試類
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = initEmployee();

        // 將員工按薪資是否高于7000分組
        Map<Boolean, List<Employee>> map = employeeList.stream().collect(Collectors.partitioningBy(s -> s.getSalary() > 7000));
        System.out.println(map);

        // 將職工按性別分組
        Map<String, List<Employee>> employeeMap = employeeList.stream().collect(Collectors.groupingBy(Employee::getSex));
        System.out.println(employeeMap);
    }

    /**
     * 初始化職工列表數(shù)據(jù)
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("張三", 8, "男", 3000.0));
        employeeList.add(new Employee("李四", 18, "女", 5000.0));
        employeeList.add(new Employee("王五", 28, "男", 7000.0));
        employeeList.add(new Employee("孫六", 38, "女", 9000.0));
        return employeeList;
    }
}

{false=[Employee{name='張三', age=8, salary=3000.0}, Employee{name='李四', age=18, salary=5000.0}, Employee{name='王五', age=28, salary=7000.0}], true=[Employee{name='孫六', age=38, salary=9000.0}]}
{女=[Employee{name='李四', age=18, salary=5000.0}, Employee{name='孫六', age=38, salary=9000.0}], 男=[Employee{name='張三', age=8, salary=3000.0}, Employee{name='王五', age=28, salary=7000.0}]}

9、接合joining?

joining可以將stream中的元素用特定的連接符（沒有的話，則直接連接）連接成一個字符串。文章來源地址http://www.zghlxwxcb.cn/news/detail-471117.html

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 職工測試類
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = initEmployee();

        // 將職工姓名用逗號拼接返回
        String nameData = employeeList.stream().map(Employee::getName).collect(Collectors.joining(","));
        System.out.println(nameData);
    }

    /**
     * 初始化職工列表數(shù)據(jù)
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("張三", 8, "男", 3000.0));
        employeeList.add(new Employee("李四", 18, "女", 5000.0));
        employeeList.add(new Employee("王五", 28, "男", 7000.0));
        employeeList.add(new Employee("孫六", 38, "女", 9000.0));
        return employeeList;
    }
}

張三,李四,王五,孫六

10、排序sorted

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 職工測試類
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        List<Employee> employeeList = initEmployee();

        // 將職工工資升序排序
        List<Employee> employees = employeeList.stream().sorted(Comparator.comparing(Employee::getSalary)).collect(Collectors.toList());
        System.out.println(employees);

        // 將職工工資降序排序
        List<Employee> list = employeeList.stream().sorted(Comparator.comparing(Employee::getSalary).reversed()).collect(Collectors.toList());
        System.out.println(list);
    }

    /**
     * 初始化職工列表數(shù)據(jù)
     */
    private static List<Employee> initEmployee() {
        List<Employee> employeeList = new ArrayList<>();
        employeeList.add(new Employee("張三", 8, "男", 3000.0));
        employeeList.add(new Employee("李四", 18, "女", 5000.0));
        employeeList.add(new Employee("王五", 28, "男", 7000.0));
        employeeList.add(new Employee("孫六", 38, "女", 9000.0));
        return employeeList;
    }
}

[Employee{name='張三', age=8, salary=3000.0}, Employee{name='李四', age=18, salary=5000.0}, Employee{name='王五', age=28, salary=7000.0}, Employee{name='孫六', age=38, salary=9000.0}]
[Employee{name='孫六', age=38, salary=9000.0}, Employee{name='王五', age=28, salary=7000.0}, Employee{name='李四', age=18, salary=5000.0}, Employee{name='張三', age=8, salary=3000.0}]

11、提取/組合

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

/**
 * @author qinxun
 * @date 2023-06-02
 * @Descripion: 職工測試類
 */
public class EmployeeDemo {
    public static void main(String[] args) {
        String[] arr1 = {"a", "b", "c", "d"};
        String[] arr2 = {"d", "e", "f", "g"};
        Stream<String> stream1 = Stream.of(arr1);
        Stream<String> stream2 = Stream.of(arr2);

        // 合并流
        List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
        System.out.println(newList);

        // 限制從流中獲得前1個數(shù)據(jù)
        System.out.println(Stream.of(arr1).limit(1).collect(Collectors.toList()));

        // 跳過前2個數(shù)據(jù)
        System.out.println(Stream.of(arr1).skip(2).collect(Collectors.toList()));
    }
}

[a, b, c, d, e, f, g]
[a]
[c, d]

到了這里，關(guān)于Java8的Stream流的學(xué)習(xí)的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！

本文來自互聯(lián)網(wǎng)用戶投稿，該文觀點(diǎn)僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務(wù)，不擁有所有權(quán)，不承擔(dān)相關(guān)法律責(zé)任。如若轉(zhuǎn)載，請注明出處：如若內(nèi)容造成侵權(quán)/違法違規(guī)/事實(shí)不符，請點(diǎn)擊違法舉報進(jìn)行投訴反饋，一經(jīng)查實(shí)，立即刪除！

分享到：

領(lǐng)支付寶紅包贊助服務(wù)器費(fèi)用

Java——Stream流的peek方法
Java Stream中的peek()方法也是用于查看每個元素，但不改變流的操作的方法。它接收一個Consumer類型的參數(shù)，該參數(shù)用于針對每個元素執(zhí)行副作用操作。該方法返回一個與原始流相同的新流，因此可以進(jìn)行鏈?zhǔn)讲僮鳌?使用peek()方法可以方便地在流處理過程中調(diào)試或記錄某些數(shù)據(jù)
2024年01月20日
瀏覽(31)
Java中stream流的常見用法
這篇文章主要是記錄stream流的用法，因?yàn)閟tream流比較常用，并且一些操作較復(fù)雜，記錄在此，以后參考。 1、filter用法主要是用來過濾集合中的元素，較常用。 2、peek用法主要是用來修改元素的狀態(tài)，比如其中對象的字段等 3、map用法主要是用來替換集合中的元素 4、flatma
2024年02月12日
瀏覽(30)
Java，SpringBoot中對Stream流的運(yùn)用
詳細(xì)參考：java 1.8 stream 應(yīng)用-22種案例_java1.8 流案例-CSDN博客 1. 遍歷 ?2. 匯總
2024年02月22日
瀏覽(25)
Java8中Stream詳細(xì)用法大全
Java 8 是一個非常成功的版本，這個版本新增的Stream，配合同版本出現(xiàn)的Lambda ，給我們操作集合（Collection）提供了極大的便利。Stream流是JDK8新增的成員，允許以聲明性方式處理數(shù)據(jù)集合，可以把Stream流看作是遍歷數(shù)據(jù)集合的一個高級迭代器。Stream 是 Java8 中處理集合的關(guān)鍵抽
2023年04月08日
瀏覽(31)
Java8 函數(shù)式編程stream流
Java 8 中新增的特性旨在幫助程序員寫出更好的代碼，其中對核心類庫的改進(jìn)是很關(guān)鍵的一部分，也是本章的主要內(nèi)容。對核心類庫的改進(jìn)主要包括集合類的 API 和新引入的流（Stream），流使程序員得以站在更高的抽象層次上對集合進(jìn)行操作。下面將介紹stream流的用法。 ?場景
2024年02月15日
瀏覽(20)
Java8 Stream 之groupingBy 分組講解
本文主要講解：Java 8 Stream之Collectors.groupingBy()分組示例 Collectors.groupingBy() 分組之常見用法功能代碼: /** ?? ? * 使用java8 stream groupingBy操作,按城市分組list ?? ? */ ?? ?public void groupingByCity() { ?? ??? ?MapString, ListEmployee map = employees.stream().collect(Collectors.groupingBy(Employee::getCi
2024年02月13日
瀏覽(25)
Java8 Stream流處理樹形結(jié)構(gòu)數(shù)據(jù)
參考資料 Java8新特性-使用Stream流遞歸實(shí)現(xiàn)遍歷樹形結(jié)構(gòu) ID為2，6，11的Menu 是 ID為1的Menu子節(jié)點(diǎn) ID為3，4，5的Menu 是 ID為2的Menu子節(jié)點(diǎn) ?? 注意是下面這種寫法的一種更簡單的寫法
2024年02月01日
瀏覽(21)
Java8的stream之groupingBy()分組排序
groupingBy()是Stream API中最強(qiáng)大的收集器Collector之一，提供與SQL的GROUP BY子句類似的功能。需要指定一個屬性才能使用，通過該屬性執(zhí)行分組。我們通過提供功能接口的實(shí)現(xiàn)來實(shí)現(xiàn)這一點(diǎn) - 通常通過傳遞lambda表達(dá)式。 TreeMap默認(rèn)按照key升序排序,collectPlan.descendingMap()可以進(jìn)行降序排
2024年02月12日
瀏覽(24)
java8 Stream流常用方法（持續(xù)更新中...）
操作對象模擬數(shù)據(jù) 操作打印結(jié)果打印結(jié)果注意：異常自己捕捉，就比如這里String轉(zhuǎn)Intger就可能出現(xiàn)NumberFormatException異常打印結(jié)果打印結(jié)果斷點(diǎn)查看打印結(jié)果斷點(diǎn)查看持續(xù)更新中…
2024年04月28日
瀏覽(28)
Java8 Stream流常見操作--持續(xù)更新中
Java8 Stream流是一種處理數(shù)據(jù)集合的方式，它可以對集合進(jìn)行一系列的操作，包括過濾、映射、排序等，從而實(shí)現(xiàn)對集合中元素的處理和轉(zhuǎn)換。Stream流是一種惰性求值的方式，只有在需要返回結(jié)果時才會執(zhí)行實(shí)際操作，這種方式可以提高程序的性能。延遲執(zhí)行：Stream流中的操作
2024年02月11日
瀏覽(42)

<del id="goo7i"><b id="goo7i"></b></del>