lambda

lambda

Stream转数组
T[] arr = stream.toArray(T[]::new)
lambda中，被引用的变量值不能被更改，lambda表达式中的变量不是线程安全的

类优先：class Student extends Person implements Named {...}
Student会集成Person中的getName方法

lambda API

stream

1.stream自己不会存储元素，元素被存储在底层的集合中，或根据需要产生出来
2.Stream操作符不会改变源对象，会返回一个持有新对象的Stream
3.Stream是延迟执行的，如果只想要前5个单词，filter会在执行5次匹配后停止执行，甚至可以无限

• 通配符
  参数 ? super U 表示下界为U,表示U以及U的父类方法都能使用
  返回值 ? extends T 上界为T,表示T以及T的子类 那么List<T>则都能接收

• stream 流程

  1. 创建一个stream
  2. 在一个或多个步骤中，指定将初始Stream转换为另一个Stream中间操作
  3. 使用终止符操作产生一个结果，该操作会强制它之前的延迟操作立即执行，在这之后，该Stream不会再使用

• stream创建

  1. Stream<String> words = Stream.of("tudou");
  2. Arrays.stream(array, from, to);
  3. Stream.empty()
  4. Stream.generator(Supplier<T> s); () -> "Echo" 生成相同的属性的流
  5. Stream.generate(Math::random); 随机数字
  6. new Random().ints()/longs()/doubles 随机数字
  7. Stream<T> iterate(final T seed, final UnaryOperator<T> f) 按照种子+规则生成流
     Stream.iterate(BigInteger.ZERO,n->n.add(BigInteger.ONE));
     序列中第一个元素是种子BigInteger.ZERO;第二个值是f(seed),第三个值是f(f(seed))
  8. Stream<String> words = Pattern.compile("[\\P{L}]+").splitAsStream(contents)
  9. Files.lines(path)
try (Stream<String> lines = Files.lines(Paths.get("D:", "2.sql"))) { lines.limit(5).forEach(System.out::println); }catch(IOException e){} try-with-resources 自动关闭流
  10. Stream<int> String.codePoints() code java 9th Edition Volume 3.3.3节
  11. Stream<int> String.chars() 获取UTF-16编码的流

• 打印流
  Stream<T> peek() 返回相同的流,可以判断无限流是否延迟处理
  Stream<T> foreach() 遍历(并行流上会随机)
  Stream<T> forEachOrdered() 按序遍历(并行留上按照顺序(=没有使用并行流))

• filter、map、flatMap
  参数为T 返回值G<U> 的f函数
参数为G<U>返回值U的g函数 可以通过flatMap 先应用f函数,再应用g函数 (monads理论)
例: LambdaDemo01::characterStream String->Stream<Charactor> Stream<charactor> -> Stream<charactor>

---

StreamAPI

调用类	方法	参数	返回值	作用
Stream	generate	Supplier<T>	Stream<T>	返回T类型Stream
Stream	limit	int	Stream<T>	返回指定长度的流
Stream	skip	int	Stream<T>	略过第一个元素
Stream	of	T…	Stream<T>	返回T类型Stream
Stream	concat	Stream<T>...	Stream<T>	合并两个Stream流
Stream	iterate	T seed,UnaryOperator t	Stream<T>	迭代,种子+方法产生一个无限流
Stream	distinct		Stream<T>	去除重
Stream	sort	Comparator<? super T>	Stream<T>	排序,大的在前

调用类	方法	参数	返回值	作用
Comparator<T>	reversed		Comparator<T>	比较结果反转

Comparator.comparing( Function<? super T, ? extends U>) U extends Comparable<? super U>
max((v1, v2) -> v1.compareToIgnoreCase(v2)) ->(缩写) max(String::compareToIgnoreCase)

• 聚合
  filter(Predicate<? super T> predicate) + findFirst() 得到第一个匹配的
  filter(Predicate<? super T> predicate) + findAny() 得到任意一个匹配的(适合并行)
  boolean anyMatch(Predicate<? super T> predicate) 任一匹配
  boolean allMatch(Predicate<? super T> predicate) 全部匹配
  boolean noneMatch(Predicate<? super T> predicate) 全部不匹配
  Optional<T> reduce(BinaryOperator<T> accumulator) 按照vo 聚合 v1 聚合 v2…执行
  T reduce(T identity, BinaryOperator<T> accumulator) 给定一个初始值以及聚合方法进行聚合
  <U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner) 给定一个初始值,以及聚合方法(累加器),最后指定并行时候结果合并的方法

  注:reduce方法需要满足 a op b op c = a op (b op c) 否则无法进行并行操作(减法不能使用并行)

• 收集结果
  Object[] stream.toArray()
T[] Stream.toArray(T[]::new)

Collectors

参数:
1.能创建目标类型实例的方法
2.一个将元素添加到目标中的方法,例如add方法
3.一个将两个对象整合到一起的方法,例如addAll方法
隐藏构造4.将最终合并结果转为其他(实现Collectors接口)

• 收集器
  Collectors.toSet()
Collectors.toList()
Collectors.toCollection(TreeSet::new) 自定义转换集合类型(downStream收集器)
  Collectors.joining(CharSequence delimiter) 组装字符串 按照分隔符进行拼接
  Collectors.summaryStatistics(Int|Long|Double) 获取包含总和,平均,最大,最小值的方法
  Collectors.toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper,BinaryOperator<U> mergeFunction) 转换map,生成key,生成value,key相同合并操作
  Collectors.toConcurrentMap 得到并发的map 当使用并行流时,会使用一个并发map,而不是合并map,使用共享的map无法得到有序的结果
  Collectors.partitioningBy(Predicate<T,booelan>) 分成两组
  Collectors.counting() 数量收集器
  Collectors.summing(Int|Long|Double)() 求和收集器
  Collectors.maxBy(Comprator<T>) 最大值收集器
  Collectors.minBy(Comprator<T>) 最小值收集器
  Collectors.groupingBy(Function<? super T, ? extends K> classifier)key + List<>对象列表
  collect(groupingBy(keyColumn,Collectors)) key+按照收集规则组成value
  collect(groupingBy(keyColumn,mapping(valueColumn,Collectors)))key+value取的列,映射器
  collect(groupingBy(keyColumn,mapping(valueColumn,summarizingInt())))key+value取的列,映射器(统计)
  Collector reducing(binaryOperator) 此处identity为null
  Collector reducing(identity,binaryOperator)
Collector reducing(identity,mapper,binaryOperator)
Collector mapping(mapper,downStream)
collect(groupingBy(Function<? super T, ? extends K> classifier,downStream))

原始类型流

IntStream.of(int[]) 数组转流
Arrays.stream(int[],from,to) 数组转流
IntStream.range(0,100) 生成0-100不包含上限流
IntStream.rangeClosed(0,100) 生成0-100流
boxed() 返回封装类的流
toArray() 返回原始类型数组

并行流

从有序集合,范围值,生成器及迭代器,sorted产生的流都是有序的,有序不影响并行,Stream.map(fun),流被分成n片,然后按照顺序结果组合起来
Stream.parallel().unordered().limit();   并行无序提高limit效率
Stream.parallel().unordered().distinct(); 通过共享集合标记重复元素 提高效率(默认distinct保留第一个元素)
Collectors.groupingByConcurrent() 
Stream不会影响原集合,不能在stream中改变原集合时

函数式接口

接口	参数类型	返回类型	描述
Supplier<T>		T	提供一个T类型的值(供应商)
Consumer<T>	T		处理一个T类型的值(消费者)
BiConsumer<T,U>	T,U		处理T和U类型的值
Predicate<T>	T	boolean	计算Boolean值的函数
Runnable			执行一个没有参数和返回值的操作
Function<T,R>	T	R	一个参数类型为T的函数 compose,andThen,identity
BiFunction<T,U,R>	T,U	R	一个参数类型为T和U的函数
UnaryOperator	T	T	对类型T进行一元操作

boolean Predicate<T>(T t) 断言
void Consumer<? super T>(T t) 消费者

Optional

flatMap  s.f().g()     Optinal<T>  f()    +  Optional<U> g(Optional<T> t)
Optional<U> = s.f().flatMap(T::g);
Optional的flatMap类似于Stream的flatMap,相当于长度为0/1flatMap

Excepition

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
流只可以使用一次
`List<String> wordList = Arrays.asList("word", "isisi", "tudou", "ooooooooooooooooooooooooo");
 Stream<String> words = wordList.stream();
 // words这个流只能消费一次
 // Stream<Stream<Character>> streamStream = words.map(LambdaDemo01::characterStream);
 // 展开流
 Stream<Character> characterStream = words.flatMap(LambdaDemo01::characterStream);
 characterStream.forEach(System.out::println);