JDK1.8-Stream流

JDK1.8——Stream流

获取流的三种方式

第一种是通过Collection接口的stream方法获取

//创建一个List集合对象
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream();
123

第二种是通过Collection接口的parallelStream方法获取一个并发流

//创建一个list集合
List<String> list = new ArrayList<>();
Stream<String> parallelStream = list.parallelStream();
123

第三种是通过Stream接口里的of方法获取数组对应的流

 Stream<Object> of = Stream.of(); //直接用Stream接口调用自身的of方法
1

of方法有两个参数，一个是根据泛型传参，一个是可变长参数类型

List<String> list = new ArrayList<>();
Stream<Object> of1 = Stream.of(list); //传入一个list集合，也可以是其它类型

Stream<Integer> of2 = Stream.of(1, 2, 3); //根据可变参数传值，可以是任意长度
1234

常用方法

forEach

forEach参数是名为Consumer的接口（Java8的一个函数式接口，这个参数没有返回值，后面也不能再接其它的流方法，其参数语法为 类名 :: 方法名，一般用System类调用print或println方法。

filter

filter是过滤器的意思，顾名思义就是用来过滤集合元素然后再将其结果打印输出

map

这个方法可以把流中初始的元素转换成新的流元素，例如泛型中数据类型的转换

reduce

reduce主要作用于把Stream流中的元素组合起来做四则运算

它有两种用法：

一种是通过函数式接口用lambda表达式做运算，返回Optional类； 还有一种是通过一个初始值做运算

例题

/*1. 找出2011年发生的所有交易， 并按交易额排序（从低到高）
2. 交易员都在哪些不同的城市工作过？
3. 查找所有来自剑桥的交易员，并按姓名排序
4. 返回所有交易员的姓名字符串，按字母顺序排序
5. 有没有交易员是在米兰工作的？
6. 打印生活在剑桥的交易员的所有交易额
7. 所有交易中，最高的交易额是多少
8. 找到交易额最小的交易*/
public class Mytest8 {
    public static void main(String[] args) {
        //创建出一些交易员对象,添加到集合中,然后用StreamAPI 完成下面的作业
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario", "Milan");
        Trader alan = new Trader("Alan", "Cambridge");
        Trader brian = new Trader("Brian", "Cambridge");
        List<Transaction> list = Arrays.asList(
                new Transaction(brian, 2011, 300),
                new Transaction(raoul, 2012, 1000),
                new Transaction(raoul, 2011, 400),
                new Transaction(mario, 2012, 710),
                new Transaction(mario, 2012, 700),
                new Transaction(alan, 2012, 950)
        );
        //找出2011年发生的所有交易， 并按交易额排序（从低到高）
        list.stream().filter(transaction -> transaction.getYear() == 2011).sorted((a,b)->a.getValue()-b.getValue()).forEach(System.out::println);
        //交易员都在哪些不同的城市工作过？
        Stream<Trader> stream = list.stream().distinct().map(transaction -> transaction.getTrader());
        stream.distinct().forEach(trader -> System.out.println(trader.getCity()));
        //查找所有来自剑桥的交易员，并按姓名排序
        Stream<Trader> stream2 = list.stream().distinct().map(transaction -> transaction.getTrader());
        Stream<Trader> sorted = stream2.distinct().filter(trader -> trader.getCity() == "Cambridge").sorted((a, b) -> a.getName().length()- b.getName().length());
        sorted.forEach(System.out::println);
        System.out.println("----------------------------------");
        //返回所有交易员的姓名字符串，按字母顺序排序
        Stream<Trader> stream3 = list.stream().distinct().map(transaction -> transaction.getTrader());
        System.out.println(stream3.map(trader -> trader.getName()).distinct().sorted((a,b)->a.compareTo(b)).collect(Collectors.joining("  ")));
        //有没有交易员是在米兰工作的？
        System.out.println("========================================");
        Stream<Trader> stream4 = list.stream().distinct().map(transaction -> transaction.getTrader());
        System.out.println(stream4.distinct().map(trader -> trader.getCity()).anyMatch(s -> "Milan".equals(s)));
        //打印生活在剑桥的交易员的所有交易额
        Optional<Integer> optional = list.stream().filter(e -> e.getTrader().getCity().equals("Cambridge")).map(Transaction::getValue).reduce(Integer::sum);
        System.out.println(optional);
        // 所有交易中，最高的交易额是多少
        Optional<Integer> reduce = list.stream().map(transaction -> transaction.getValue()).reduce(Integer::max);
        System.out.println(reduce);
        //8. 找到交易额最小的交易*/
        Optional<Integer> reduce2 = list.stream().map(transaction -> transaction.getValue()).reduce(Integer::min);
        System.out.println(reduce2);
    }
}