* Stream 的三个操作步骤：
 * 1创建Stream
 * 2中间操作
 * 3终止操作
package airycode_java8.nice6;

import airycode_java8.nice1.Employee;

import org.junit.Test;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.stream.Stream;

/**

 * Stream 的三个操作步骤：

 * 1创建Stream

 * 2中间操作

 * 3终止操作

 * Created by admin on 2019/1/3.

 */

public class TestStream {

    @Test

    public void test1(){

        //1.通过Collection集合提供的stream()或者parallelStream()

        List<String> list = new ArrayList<>();

        Stream<String> stream1 = list.stream();

        //2.数组

        Employee[]emps = new Employee[10];

        Stream<Employee> stream2 = Arrays.stream(emps);

        //3.stream中的静态方法

        Stream.of("aa","bb","cc");

        //4.创建无限流

        //迭代

        Stream<Integer> stream = Stream.iterate(0, (x) -> x + 2);

        stream.limit(10).forEach(System.out::println);

        //生成

        Stream.generate(()->Math.random()).limit(5).forEach(System.out::println);

    }

}

　　中间操作：

package airycode_java8.nice6;

import airycode_java8.nice1.Employee;

import org.junit.Test;

import java.util.Arrays;

import java.util.List;

import java.util.stream.Stream;

/**

 * 中间操作

 *

 * Created by admin on 2019/1/3.

 */

public class TestStreamApi2 {

    //准备数据

    static List<Employee> employeeList = Arrays.asList(

            new Employee("张三",18,9999.99, Employee.Status.FREE),

            new Employee("李四",38,5555.55,Employee.Status.BUSY),

            new Employee("王五",50,6666.66,Employee.Status.VOCATION),

            new Employee("赵六",16,3333.33,Employee.Status.FREE),

            new Employee("田七",8,7777.77,Employee.Status.BUSY)

    );

    /***

     * 筛选与切片

     * filter--接收Lambda，从流中排除某些元素。

     * limit--截断流，使其元素不超过给定数量

     * skip(n)--跳过元素，返回扔掉了前n个元素的流，若流中不足n个，则返回一个空流，与limit互补

     * distinct--筛选，通过流所生成的元素的hashcode和equals去除重复元素

     */

    //内部迭代：由StreamAPI提供

    @Test

    public void test1(){

        //中间操作：不会做任何的操作

        Stream<Employee> stream1 = employeeList.stream().filter((e) -> e.getAge() > 35);

        //终止操作：一次性执行全部，就是“惰性求值”

        stream1.forEach(System.out::println);

    }

    @Test

    public void test2(){

        //中间操作：不会做任何的操作

        Stream<Employee> stream1 = employeeList.stream().filter((e) -> e.getAge() > 35).limit(1);

        //终止操作：一次性执行全部，就是“惰性求值”

        stream1.forEach(System.out::println);

    }

    @Test

    public void test3(){

        //中间操作：不会做任何的操作

        Stream<Employee> stream1 = employeeList.stream().filter((e) -> e.getAge() > 35).skip(1);

        //终止操作：一次性执行全部，就是“惰性求值”

        stream1.forEach(System.out::println);

    }

    //去重必须重写hashcode和equals

    @Test

    public void test4(){

        //中间操作：不会做任何的操作

        Stream<Employee> stream1 = employeeList.stream().filter((e) ->e.getSalary()>5000).skip(2).distinct();

        //终止操作：一次性执行全部，就是“惰性求值”

        stream1.forEach(System.out::println);

    }

}

　　中间操作2：

package airycode_java8.nice6;

import airycode_java8.nice1.Employee;

import org.junit.Test;

import java.io.PrintStream;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.stream.Stream;

/**

 * 中间操作

 *

 * Created by admin on 2019/1/3.

 */

public class TestStreamApi3 {

    //准备数据

    static List<Employee> employeeList = Arrays.asList(

            new Employee("张三",18,9999.99, Employee.Status.FREE),

            new Employee("李四",38,5555.55,Employee.Status.BUSY),

            new Employee("王五",50,6666.66,Employee.Status.VOCATION),

            new Employee("赵六",16,3333.33,Employee.Status.FREE),

            new Employee("田七",8,7777.77,Employee.Status.BUSY)

    );

    /***

     * 映射

     * map--接收Lambda，将元素转换成其他形式或提取信息，接收一个函数作为参数，该函数会被应用到每一个元素上，并将其映射成一个新的元素

     * flatMap--接收一个函数作为参数，将流中的，每一个值换成另一个流，然后把所有流链接成一个流

     */

    //内部迭代：由StreamAPI提供

    @Test

    public void test1(){

        List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");

        list.stream().map((str)->str.toUpperCase()).forEach(System.out::println);

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

        employeeList.stream().map((employee -> employee.getName())).forEach(System.out::println);

    }

    //map对比flatMap

    @Test

    public void test2(){

        List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");

        Stream<Stream<Character>> charStream = list.stream().map(TestStreamApi3::filterChar);

        charStream.forEach((sm)->{

            sm.forEach(System.out::println);

        });

    }

    //flatMap

    @Test

    public void test3(){

        List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");

        list.stream().flatMap(TestStreamApi3::filterChar).forEach(System.out::println);

    }

    public static Stream<Character> filterChar(String str){

        List<Character> list = new ArrayList<>();

        for (Character c:str.toCharArray()) {

            list.add(c);

        }

        return list.stream();

    }

}

　　中间操作-排序

package airycode_java8.nice6;

import airycode_java8.nice1.Employee;

import org.junit.Test;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.stream.Stream;

/**

 * 中间操作--排序

 *

 * Created by admin on 2019/1/3.

 */

public class TestStreamApi4 {

    //准备数据

    static List<Employee> employeeList = Arrays.asList(

            new Employee("张三",18,9999.99, Employee.Status.FREE),

            new Employee("李四",38,5555.55,Employee.Status.BUSY),

            new Employee("王五",50,6666.66,Employee.Status.VOCATION),

            new Employee("赵六",16,3333.33,Employee.Status.FREE),

            new Employee("田七",8,7777.77,Employee.Status.BUSY)

    );

    /***

     * 排序

     * sorted()-自然排序

     * sorted(Comparator com)--定制排序

     */

    @Test

    public void test1(){

        List<String> list = Arrays.asList("fff","aaa","bbb","ccc","ddd");

        list.stream().sorted().forEach(System.out::println);

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

        employeeList.stream().sorted((e1,e2)->{

            if (e1.getAge() == e2.getAge()) {

                return e1.getName().compareTo(e2.getName());

            } else {

                return -Integer.compare(e1.getAge(),e2.getAge());

            }

        }).forEach(System.out::println);

    }

}

　　终止操作：

package airycode_java8.nice6;

import airycode_java8.nice1.Employee;

import org.junit.Test;

import java.util.Arrays;

import java.util.List;

import java.util.Optional;

/**

 * 终止操作

 *

 * Created by admin on 2019/1/3.

 */

public class TestStreamApi5 {

    //准备数据

    static List<Employee> employeeList = Arrays.asList(

            new Employee("张三",18,9999.99, Employee.Status.FREE),

            new Employee("李四",38,5555.55,Employee.Status.BUSY),

            new Employee("王五",50,6666.66,Employee.Status.VOCATION),

            new Employee("赵六",16,3333.33,Employee.Status.FREE),

            new Employee("田七",8,7777.77,Employee.Status.BUSY)

    );

    /***

     * 终止操作

     * 查找与匹配

     * allMatch--检查是否匹配所有元素

     * anyMatch--检查是否至少匹配一个元素

     * noneMatch--检查是否没有匹配所有元素

     * findFirst--返回第一个元素

     * findAny--返回当前流中的任意一个元素

     * count--返回流中元素总个数

     * max--返回流中最大值

     * min--返回流中最小值

     *

     *

     */

    @Test

    public void test1(){

        boolean allMatch = employeeList.stream().allMatch((employee -> employee.getStatus().equals(Employee.Status.BUSY)));

        System.out.println(allMatch);

        boolean anyMatch = employeeList.stream().anyMatch((employee -> employee.getStatus().equals(Employee.Status.BUSY)));

        System.out.println(anyMatch);

        boolean noneMatch = employeeList.stream().noneMatch((employee -> employee.getStatus().equals(Employee.Status.BUSY)));

        System.out.println(noneMatch);

        Optional<Employee> op = employeeList.stream().sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())).findFirst();

        Employee employee = op.get();

        System.out.println(employee);

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

        Optional<Employee> anyOp = employeeList.stream().filter((e) -> e.getStatus().equals(Employee.Status.FREE)).findAny();

        System.out.println(anyOp.get());

    }

    @Test

    public void test2(){

        long count = employeeList.stream().count();

        System.out.println(count);

        Optional<Employee> max = employeeList.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));

        System.out.println(max.get());

        Optional<Employee> min = employeeList.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));

        System.out.println(min.get());

        Optional<Double> min1 = employeeList.stream().map(Employee::getSalary).min(Double::compare);

        System.out.println(min1.get());

    }

}

　　终止操作：规约

package airycode_java8.nice6;

import airycode_java8.nice1.Employee;

import org.junit.Test;

import java.util.*;

import java.util.stream.Collectors;

/**

 * 终止操作

 *

 * Created by admin on 2019/1/3.

 */

public class TestStreamApi6 {

    //准备数据

    static List<Employee> employeeList = Arrays.asList(

            new Employee("张三",18,9999.99, Employee.Status.FREE),

            new Employee("李四",38,5555.55,Employee.Status.BUSY),

            new Employee("王五",50,6666.66,Employee.Status.VOCATION),

            new Employee("赵六",16,3333.33,Employee.Status.FREE),

            new Employee("田七",8,7777.77,Employee.Status.BUSY)

    );

    /***

     * 规约

     * reduce(T identity,BinaryOperator)--可以将流中元素反复结合起来，得到一个值

     *

     *

     */

    @Test

    public void test1(){

        List<Integer> list = Arrays.asList(1,2,3,4,5);

        Integer sum = list.stream().reduce(0, (x, y) -> x + y);

        System.out.println(sum);

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

        Optional<Double> reduceOp = employeeList.stream().map(Employee::getSalary).reduce(Double::sum);

        System.out.println(reduceOp.get());

    }

    /***

     * 收集

     * collect--将流转化为其他的形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法

     */

    @Test

    public void test2(){

        List<String> names = employeeList.stream().map(Employee::getName).collect(Collectors.toList());

        names.forEach(System.out::println);

        Set<String> disNames = employeeList.stream().map(Employee::getName).collect(Collectors.toSet());

        disNames.forEach(System.out::println);

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

        HashSet<String> hashNames = employeeList.stream().map(Employee::getName).collect(Collectors.toCollection(HashSet::new));

        hashNames.forEach(System.out::println);

    }

    @Test

    public void test3(){

        //总数

        Long count = employeeList.stream().collect(Collectors.counting());

        System.out.println(count);

        //平均数

        Double avg = employeeList.stream().collect(Collectors.averagingDouble(Employee::getSalary));

        System.out.println(avg);

        //总和

        Double sum = employeeList.stream().collect(Collectors.summingDouble(Employee::getSalary));

        System.out.println(sum);

        //最大值员工

        Optional<Employee> employeeMax = employeeList.stream().collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));

        System.out.println(employeeMax.get());

        //最小值

        Optional<Double> val = employeeList.stream().map(Employee::getSalary).collect(Collectors.minBy(Double::compare));

        System.out.println(val.get());

    }

    //分组

    @Test

    public void test4(){

        Map<Employee.Status, List<Employee>> statusListMap = employeeList.stream().collect(Collectors.groupingBy(Employee::getStatus));

        System.out.println(statusListMap);

    }

    //多级分组

    @Test

    public void test5(){

        Map<Employee.Status, Map<String, List<Employee>>> map = employeeList.stream().collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((employee) -> {

            if (employee.getAge() <= 35) {

                return "青年";

            } else if (employee.getAge() <= 50) {

                return "中年";

            } else {

                return "老年";

            }

        })));

        System.out.println(map);

    }

    //分区

    @Test

    public void test6(){

        Map<Boolean, List<Employee>> booleanListMap = employeeList.stream().collect(Collectors.partitioningBy((e) -> e.getSalary() > 8000));

        System.out.println(booleanListMap);

    }

    //获取最大值，求和，最小值，另一种方式

    @Test

    public void test7(){

        DoubleSummaryStatistics dss = employeeList.stream().collect(Collectors.summarizingDouble(Employee::getSalary));

        System.out.println(dss.getSum());

        System.out.println(dss.getAverage());

        System.out.println(dss.getCount());

        System.out.println(dss.getMax());

        System.out.println(dss.getMin());

    }

    //连接字符换

    @Test

    public void test8(){

        String str = employeeList.stream().map(Employee::getName).collect(Collectors.joining("-"));

        System.out.println(str);

    }

}

　　

JAVA8流操作的更多相关文章

  1. java8 流操作

    0  创建流 public void test1(){ List<String> list = new ArrayList<>(); Stream<String> ...

  2. java8 流操作 好文网址

    api 各方法详解(很不错!) http://blog.51cto.com/turnsole/2093185 api 各方法 简介: https://www.cnblogs.com/guguli/p/ ...

  3. 【java多线程】java8的流操作api和fork/join框架

    原文:https://blog.csdn.net/u011001723/article/details/52794455/ 一.测试一个案例,说明java8的流操作是并行操作 1.代码 package ...

  4. Java8中的流操作-基本使用&性能测试

    为获得更好的阅读体验,请访问原文:传送门 一.流(Stream)简介 流是 Java8 中 API 的新成员,它允许你以声明式的方式处理数据集合(通过查询语句来表达,而不是临时编写一个实现).这有点儿 ...

  5. Java 8-Lambda表达式、方法引用、标准函数接口与流操作、管道操作之间的关系

    1.Lambda表达式与接口之间的关系 只要Lambda表达式的声明形式与接口相一致,在很多情况下都可以替换接口.见如下代码 Thread t1 = new Thread(new Runnable() ...

  6. 公子奇带你进入Java8流的世界（二）

    在上一篇中我们带领大家简单的了解流的概念及使用场景,本节我们就来好好的介绍流的常见用法. 一.筛选和切片 对于一串流,我们有时需要取出我们需要的流中某些元素,主要是通过谓词筛选.看代码: 首先定义一个 ...

  7. 侠说java8--Stream流操作学习笔记，都在这里了

    前言 首次接触到Stream的时候以为它是和InputStream.OutputStream这样的输入输出流的统称. 流和集合的前世今生 概念的差异 在开发中,我们使用最多的类库之一就是集合.集合是一 ...

  8. 全面吃透JAVA Stream流操作，让代码更加的优雅

    全面吃透JAVA Stream流操作,让代码更加的优雅 在JAVA中,涉及到对数组.Collection等集合类中的元素进行操作的时候,通常会通过循环的方式进行逐个处理,或者使用Stream的方式进行 ...

  9. Node学习笔记（一）：stream流操作

    NodeJs中谈及较多的可能就是Stream模块了,先写一个简单的ajax回调 $.post("index.php",{data:'aaa',order:'ccc'},functi ...

随机推荐

  1. window.onresize监听事件

    window.onresize监听事件 onresize 事件会在窗口或框架被调整大小时发生. 支持onresize的标签:<a>, <address>, <b>, ...

  2. c#加"\n\r"不换行,变成字符串

    质检模块,本想将每个错误分行, 比如:lyrerrormess += lyrname + "图层" + "缺少" + xmlFieldName + " ...

  3. wpf数据绑定：xml数据绑定

    wpf中可以通过XmlDataProvider,来实现xml数据的绑定.它通过XmlDataProvider来绑定外部资源,需要命名一个 x:Key 值,以便数据绑定目标可对其进行引用,Source设 ...

  4. spark学习笔记3

    Spark 支持在集群范围内将数据集缓存至每一个节点的内存中,可避免数据传输,当数据需要重复访问时这个特征非常有用,例如查询体积小的“热”数据集,或是运行如 PageRank 的迭代算法.调用 cac ...

  5. kmeans笔记

    1.算法过程 a.随机选取k个初始点作为中心点 b.依次计算剩余所有点分别与哪个初始点距离较近,则该点属于哪个簇 c.移动中心点到现在的簇的中心 d.重复b,c两步,直到中心点不再变化算法结束 2.优 ...

  6. sed命令 windows与linux换行

    Linux的Bash命令中有一个sed操作,SSD的create_list.sh中有用到这个操作: 结合着下面这个解释: 也就是删除所有行里面的以VOC2007/Annotations/(这里的\代表 ...

  7. css权重计算规则

    1.第一等:代表内联样式,如 style=" ",权值为1000: 2.第二等:代表ID选择器,如 #content,权值为0100: 3.第三等:代表类,伪类和属性选择器,如 . ...

  8. .NET Core 使用 Kestrel

    Kestrel介绍 Kestrel是一个基于libuv的跨平台web服务器 在.net core项目中就可以不一定要发布在iis下面了 Kestrel体验 可以使用useUrls来设置一个请求的地址 ...

  9. sql server误删数据恢复delete（低效版）

    关键词:sql server误删数据恢复,mssql误删数据恢复,delete --切换数据库 use master --构建函数 Create PROCEDURE Recover_Deleted_D ...

  10. Laravel删除产品-CRUD之delete(destroy)

    上一篇讲了Laravel编辑产品-CRUD之edit和update,现在我们讲一下删除产品,方法和前面的几篇文章类似,照着ytkah来操作吧 1,controller的function destroy ...