Lambda 是一个匿名函数，我们可以将lambda可以理解为一段可以传递的代码。使用它可以写出更简洁更灵活的代码。作为一种更紧凑的代码风格，是java的语言表达能力得到了提升。
Stream
package com.tu.stream;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
* @author william
* @create 2020-12-11 7:20
*/
/*
* Stream api
* 1.
* stream 关注的是运算，和cpu打交道
* 集合关注的是数据，和内存打交道
* 2.
* stream自己不会存储元素
* stream不会改变源对象，但会返回一个持有结果的新的stream
* stream操作是延迟执行，这意味着他们会等到需要结果的时候才执行
*
* 3.
* stream执行流程
* stream实例化
* 一系列的中间操作(过滤，映射,...)
* 终止操作
*
* 4.说明
* 一个中间操作链，对数据源的数据进行处理
* 一旦执行终止操作，就执行中间操作链，并产生结果，之后，不会再被使用
*
*
*
* */
public class StreamTest {
/*
* 创建stream流的方式
* 1.通过集合创建stream
* */
@Test
public void test1(){
List<String> list = new ArrayList<>();
list.add("ack");
list.add("vvv");
list.add("rrr");
Stream<String> stream1 = list.stream();
Stream<String> parallelStream = list.parallelStream();
}
/*
* 创建stream流的方式
* 2.通过数组创建stream
* */
@Test
public void test2(){
String[] arr = new String[]{"aa","bb","cc"};
Stream<String> stream = Arrays.stream(arr);
}
/*
* 创建stream流的方式
* 3.stream的of方法创建stream
* */
@Test
public void test3(){
Stream<Integer> integerStream = Stream.of(1, 3, 3, 4);
}
/*
* 创建stream流的方式
* 4.创建无限流
* */
@Test
public void test4(){
Stream.iterate(0,t->t+2).limit(10).forEach(System.out::println);
Stream.generate(Math::random).limit(10).forEach(System.out::println);
}
}
过滤
package com.tu.stream;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
* @author william
* @create 2020-12-11 7:20
*/
public class StreamAPITest {
/*
* filter
* */
@Test
public void test1(){
List<Employ> employs = EmployData.getData();
Stream<Employ> stream = employs.stream();
//filter 过滤
// stream.filter((e)->e.getSaray()>5000).forEach(System.out::println);
//limit 截断流
// stream.limit(3).forEach(System.out::println);
//skip 跳过元素
// stream.skip(3).forEach(System.out::println);
//distinct
stream.distinct().forEach(System.out::println);
}
@Test
public void test2(){
List<String> list = Arrays.asList("aa","bb","ee","bbbb");
// list.stream().map((a)->"intalent-"+a).forEach(System.out::println);
//获取员工姓名长度大于3的员工姓名
// List<Employ> employs = EmployData.getData();
// Stream<String> nameStream = employs.stream().map((e) -> e.getName());
// nameStream.filter((e)->e.length()>3).forEach((name)->System.out.println(name));
//flatmap 遍历集合嵌套集合
Stream<Character> characterStream = list.stream().flatMap(StreamAPITest::stringToStream);
characterStream.forEach(System.out::println);
}
public static Stream<Character> stringToStream(String str){
List<Character> list = new ArrayList<>();
for (Character c: str.toCharArray()) {
list.add(c);
}
return list.stream();
}
/*
*
* 排序
* */
@Test
public void test3(){
//sorted
List<Integer> list = Arrays.asList(12,33,2,5,67,21);
// list.stream().sorted().forEach(System.out::println);
//sorted(Conparator c)
/*list.stream().sorted((e1,e2)->{
int intvalue = Integer.compare(e1,e2);
return intvalue;
}).forEach(System.out::println);*/
List<Employ> data = EmployData.getData();
data.stream().sorted((a,b)->{
int value = (int) (a.getSaray()-b.getSaray());
if(value==0){
return (a.getId()-b.getId());
}else {
return value;
}
}).forEach(System.out::println);
}
}
匹配与查找
package com.tu.stream;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* @author william
* @create 2020-12-11 7:20
*/
/*
* 匹配与查找
* */
public class StreamAPITest2 {
/*
*
* stream 终止操作
* */
@Test
public void test(){
List<Employ> data = EmployData.getData();
//是否所有员工的年龄都大于25
boolean allMatch = data.stream().allMatch((e) -> e.getAge() > 25);
System.out.println(allMatch);
//是否存在员工工资大于5000
boolean anyMatch = data.stream().anyMatch(e -> e.getSaray() > 5000);
System.out.println(anyMatch);
//是否存在员工姓张
boolean noneMatch = data.stream().noneMatch(e -> e.getName().startsWith("张"));
System.out.println(noneMatch);
//返回第一个元素
Optional<Employ> first = data.stream().findFirst();
System.out.println(first);
//返回当前流中的任意元素
Optional<Employ> any = data.stream().findAny();
System.out.println(any);
//返回元素流中的总个数
long count = data.stream().filter(e->e.getAge()>34).count();
System.out.println(count);
//返回流中最大值
Optional<Employ> max = data.stream().max((x,y)->(int)(x.getSaray()-y.getSaray()));
System.out.println(max);
//返回流中的最小值
Optional<Employ> min = data.stream().min((x, y) -> (int) (x.getSaray() - y.getSaray()));
System.out.println(min);
//foreach
System.out.println();
data.stream().forEach(System.out::println);
}
/*
*归约
* */
@Test
public void test1(){
List<Employ> data = EmployData.getData();
//计算公式所有员工的工资总和
Stream<Double> doubleStream = data.stream().map(Employ::getSaray);
Double reduce = doubleStream.reduce(Double.valueOf("1"), Double::sum);
System.out.println(reduce);
//计算1-10的和
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Integer sum = list.stream().reduce(0, Integer::sum);
System.out.println(sum);
}
/*
*收集
* */
@Test
public void test2(){
List<Employ> data = EmployData.getData();
List<Employ> employList = data.stream().filter(e -> e.getSaray() > 8000).collect(Collectors.toList());
employList.forEach(System.out::println);
System.out.println();
Set<Employ> employSet = data.stream().filter(e -> e.getSaray() > 9000).collect(Collectors.toSet());
employSet.forEach(System.out::println);
}
}
Optional
