package com.fly.stream;
import java.security.SecureRandom;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* Stream极大的简化了集合的操作,相比较Collection Stream用于处理集合之间的计算,是面向于CPU的,通过 * CPU实现计算,而Collection是一种静态的内存数据结构,它主要是面向内存的。Stream具有如下特性
* (1).Stream不会存储数据。
* (2).Stream不会改变源对象,相反,他们会返回一个持有结果的新Stream
* (3).Stream的操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
* (4).Stream一旦被关闭就无法再使用。Stream还有一个中间状态,例如用于对源数据的处理,例如分组、过滤等等操作
*/
public class Test01 {
static List<Emp> empList=new ArrayList<>();
static Random random=new SecureRandom();
static {
empList.add(new Emp(1001,"刘强东",230,7000.0));
empList.add(new Emp(1002,"马云",20,3000.0));
empList.add(new Emp(1003,"马化腾",50,4500.0));
empList.add(new Emp(1004,"马超",10,10000.0));
empList.add(new Emp(1005,"张一鸣",30,12000.0));
empList.add(new Emp(1005,"张一鸣",30,12000.0));
empList.add(new Emp(1006,"张三鸣",90,12000.0));
empList.add(new Emp(1007,"司马大圣",111,100000.0));
empList.add(new Emp(1008,"欧阳神奇",880,20000.0));
}
public static void main(String[] args) {
method01();
method02();
}
/**
* 创建Stream
*/
public static void method01(){
/**
* 方式1:通过集合创建Stream,列举了List、Set、Map数据结构创建Stream
*/
//获取一个Stream顺序流,在读取数据时会顺序读取
Stream<String> stream01 = new ArrayList<String>().stream();
//获取一个Stream并行流,在读取数据时会像多线程并行读取,在处理大量数据时能提供处理效率
Stream<String> stream02 = new ArrayList<String>().parallelStream();
Stream<String> stream03=new HashSet<String>().stream();
Stream<Map.Entry<String, String>> stream04=new HashMap<String,String>().entrySet().stream();
/**
* 方式2:通过数组创建Stream,本质上通过Arrays类进行转换
*/
Stream<String> stream05=Arrays.stream(new String[]{"1","2"});
/**
* 方式3:通过Stream的静态方法创建Stream
* of(T t):of方法可以将参数转为Stream,本质上还是Arrays.stream(values)。
* empty():创建一个空的Stream。
* generate(Supplier<T> s):生成流数据。
* iterate(final T seed, final UnaryOperator<T> f):通过迭代生出流数据。
* concat(Stream<? extends T> a, Stream<? extends T> b):连接2个Stream
*/
Stream<String> stream06=Stream.of();
Stream<String> stream07=Stream.empty();
Stream<Integer> stream08 = Stream.generate(new SecureRandom()::nextInt);
Stream<Integer> stream09=Stream.iterate(0,t->t+2);
Stream<Integer> stream10=Stream.concat(Stream.empty(),Stream.empty());
}
/**
* Stream Api
* filter(Predicate<? super T> predicate):根据布尔值表达式过滤数据。
* forEach(Consumer<? super T> action):遍历Stream处理的数据。
* limit(long maxSize):limit用于截断数据,maxSize为截断的最大长度,limit(3)表示截断Stream中前三个元素。
* skip(long n):跳过元素,此方法会返回n条之后的数据,不包含第n条。
* distinct():排除Stream中重复的数据。
* map(Function<? super T, ? extends R> mapper):遍历数据,并根据表达式返回给Stream。
* count():获取Stream中剩余数据的长度。
* sorted(Comparator<? super T> comparator):根据comparator表达式进行排序。
* max(Comparator<? super T> comparator):根据表达式获取Stream值最大的元素,返回一个Optional对象。
* min(Comparator<? super T> comparator):根据表达式获取Stream值最小的元素,返回一个Optional对象。
* findFirst():返回Stream第一个数据。
* findAny():返回Stream任意一个数据。
* allMatch(Predicate<? super T> predicate):根据表达式判断Stream中所有的元素是否匹配,全部匹配返回true,否则返回false。
* anyMatch(Predicate<? super T> predicate):根据表达式判断Stream中匹配元素,只要有一个元素匹配成功就返回true,否则返回false。
* noneMatch(Predicate<? super T> predicate):根据表达式判断Stream中所有的元素是否都不匹配,全部都不匹配返回true,否则返回false。
* reduce(T identity, BinaryOperator<T> accumulator):可以将流中的元素反复结合起来,得到一个值并返回元素累加之后的值。
* flatMap:将多维数据拍平
* collect:collect允许将流转换为其他形式。
*/
public static void method02(){
System.out.println("--------------filter------------------------");
//过滤工资大于7000的员工
empList.stream().filter(emp->emp.getSalary() > 7000)
.forEach(System.out::println);
System.out.println("--------------forEach------------------------");
empList.stream().forEach(emp->{
System.out.println("id:"+emp.getId()+",name:"+emp.getName());
});
System.out.println("--------------limit------------------------");
//截取Stream中前三个元素
empList.stream().limit(3).forEach(System.out::println);
System.out.println("--------------skip------------------------");
//跳过前三条元素,返回第三条之后所有的数据,不含第三条
empList.stream().skip(3).forEach(System.out::println);
System.out.println("--------------distinct------------------------");
empList.stream().distinct().forEach(System.out::println);
System.out.println("--------------map------------------------");
//遍历Stream根据数据项的名称,返回一个新的Stream,然后过滤map返回的Stream中名字长度大于3的员工
empList.stream().map(emp->emp.getName()).
filter(s->s.length()>3).
forEach(System.out::println);
System.out.println("--------------count()------------------------");
long count=empList.stream().filter(emp->emp.getSalary()>7000).count();
System.out.println("Stream的长度:"+count);
System.out.println("--------------sorted()------------------------");
//根据员工的工资进行降序
empList.stream().sorted((emp1,emp2)->Double.compare(emp2.getSalary(),emp1.getSalary()))
.forEach(System.out::println);
System.out.println("--------------max()------------------------");
//查找员工集合中工资最高的
Optional<Emp> max = empList.stream().max(Comparator.comparingDouble(Emp::getSalary));
System.out.println(max);
System.out.println("--------------min()------------------------");
//查找员工集合中工资最低的
Optional<Emp> min = empList.stream().min(Comparator.comparingDouble(Emp::getSalary));
System.out.println(min);
System.out.println("--------------findFirst()------------------------");
Optional<Emp> first = empList.stream().findFirst();
System.out.println(first);
System.out.println("--------------findAny()------------------------");
Optional<Emp> findAny = empList.stream().findAny();
System.out.println(findAny);
System.out.println("--------------allMatch()------------------------");
//判断员工集合中所有人的工资是否都大于7000
boolean bool1 = empList.stream().allMatch(emp -> emp.getSalary() > 7000);
System.out.println(bool1);
System.out.println("--------------anyMatch()------------------------");
//判断员工集合中任意一个人的工资是否大于7000
boolean bool2 = empList.stream().anyMatch(emp -> emp.getSalary() > 7000);
System.out.println(bool2);//true
System.out.println("--------------noneMatch()------------------------");
//判断员工集合中所有人的工资是否都小于7000000,与allMatch相反。
boolean bool3 = empList.stream().noneMatch(emp -> emp.getSalary() > 7000000);
System.out.println(bool3);//false
System.out.println("--------------reduce()------------------------");
//计算员工工资之和,0.0为遍历项的初识值
Double salarySum01 = empList.stream().map(Emp::getSalary).reduce(0.0, (emp1, emp2) -> emp1 + emp2);
System.out.println(salarySum01);
//计算员工工资之和简写
Double salarySum02 = empList.stream().map(Emp::getSalary).reduce(0.0, Double::sum);
System.out.println(salarySum02);
System.out.println("--------------flatMap()------------------------");
List<String> fun1 = Arrays.asList("one", "two", "three");
List<String> fun2 = Arrays.asList("four", "five", "six");
List<List<String>> nestedList = Arrays.asList(fun1, fun2);
nestedList.stream().flatMap(x -> x.stream()).map(x->x.toUpperCase()).forEach(System.out::println);
System.out.println("--------------collect()------------------------");
//Stream转List
List<Emp> collectList = empList.stream().collect(Collectors.toList());
//Stream转Set
Set<Emp> collectSet = empList.stream().collect(Collectors.toSet());
//Stream转Map,如果有相同的id就会转换失败,这里加了个随机数
Map<Integer, String> collectMap = empList.stream().collect(Collectors.
toMap(e->e.getId()+random.nextInt(), Emp::getName));
System.out.println(collectList);
System.out.println(collectSet);
System.out.println(collectMap);
}
}
package com.fly.stream;
import java.util.Objects;
public class Emp {
private Integer id;
private String name;
private Integer age;
private Double salary;
public Emp(Integer id, String name, Integer age, Double salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
@Override
public String toString() {
return "Emp{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
'}';
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Double getSalary() {
return salary;
}
public void setSalary(Double salary) {
this.salary = salary;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Emp emp = (Emp) o;
return id.equals(emp.id) &&
name.equals(emp.name) &&
age.equals(emp.age) &&
salary.equals(emp.salary);
}
@Override
public int hashCode() {
return Objects.hash(id, name, age, salary);
}
}
执行结果:
--------------filter------------------------
Emp{id=1004, name='马超', age=10, salary=10000.0}
Emp{id=1005, name='张一鸣', age=30, salary=12000.0}
Emp{id=1005, name='张一鸣', age=30, salary=12000.0}
Emp{id=1006, name='张三鸣', age=90, salary=12000.0}
Emp{id=1007, name='司马大圣', age=111, salary=100000.0}
Emp{id=1008, name='欧阳神奇', age=880, salary=20000.0}
--------------forEach------------------------
id:1001,name:刘强东
id:1002,name:马云
id:1003,name:马化腾
id:1004,name:马超
id:1005,name:张一鸣
id:1005,name:张一鸣
id:1006,name:张三鸣
id:1007,name:司马大圣
id:1008,name:欧阳神奇
--------------limit------------------------
Emp{id=1001, name='刘强东', age=230, salary=7000.0}
Emp{id=1002, name='马云', age=20, salary=3000.0}
Emp{id=1003, name='马化腾', age=50, salary=4500.0}
--------------skip------------------------
Emp{id=1004, name='马超', age=10, salary=10000.0}
Emp{id=1005, name='张一鸣', age=30, salary=12000.0}
Emp{id=1005, name='张一鸣', age=30, salary=12000.0}
Emp{id=1006, name='张三鸣', age=90, salary=12000.0}
Emp{id=1007, name='司马大圣', age=111, salary=100000.0}
Emp{id=1008, name='欧阳神奇', age=880, salary=20000.0}
--------------distinct------------------------
Emp{id=1001, name='刘强东', age=230, salary=7000.0}
Emp{id=1002, name='马云', age=20, salary=3000.0}
Emp{id=1003, name='马化腾', age=50, salary=4500.0}
Emp{id=1004, name='马超', age=10, salary=10000.0}
Emp{id=1005, name='张一鸣', age=30, salary=12000.0}
Emp{id=1006, name='张三鸣', age=90, salary=12000.0}
Emp{id=1007, name='司马大圣', age=111, salary=100000.0}
Emp{id=1008, name='欧阳神奇', age=880, salary=20000.0}
--------------map------------------------
司马大圣
欧阳神奇
--------------count()------------------------
Stream的长度:6
--------------sorted()------------------------
Emp{id=1007, name='司马大圣', age=111, salary=100000.0}
Emp{id=1008, name='欧阳神奇', age=880, salary=20000.0}
Emp{id=1005, name='张一鸣', age=30, salary=12000.0}
Emp{id=1005, name='张一鸣', age=30, salary=12000.0}
Emp{id=1006, name='张三鸣', age=90, salary=12000.0}
Emp{id=1004, name='马超', age=10, salary=10000.0}
Emp{id=1001, name='刘强东', age=230, salary=7000.0}
Emp{id=1003, name='马化腾', age=50, salary=4500.0}
Emp{id=1002, name='马云', age=20, salary=3000.0}
--------------max()------------------------
Optional[Emp{id=1007, name='司马大圣', age=111, salary=100000.0}]
--------------min()------------------------
Optional[Emp{id=1002, name='马云', age=20, salary=3000.0}]
--------------findFirst()------------------------
Optional[Emp{id=1001, name='刘强东', age=230, salary=7000.0}]
--------------findAny()------------------------
Optional[Emp{id=1001, name='刘强东', age=230, salary=7000.0}]
--------------allMatch()------------------------
false
--------------anyMatch()------------------------
true
--------------noneMatch()------------------------
true
--------------reduce()------------------------
180500.0
180500.0
--------------flatMap()------------------------
ONE
TWO
THREE
FOUR
FIVE
SIX
--------------collect()------------------------
[Emp{id=1001, name='刘强东', age=230, salary=7000.0}, Emp{id=1002, name='马云', age=20, salary=3000.0}, Emp{id=1003, name='马化腾', age=50, salary=4500.0}, Emp{id=1004, name='马超', age=10, salary=10000.0}, Emp{id=1005, name='张一鸣', age=30, salary=12000.0}, Emp{id=1005, name='张一鸣', age=30, salary=12000.0}, Emp{id=1006, name='张三鸣', age=90, salary=12000.0}, Emp{id=1007, name='司马大圣', age=111, salary=100000.0}, Emp{id=1008, name='欧阳神奇', age=880, salary=20000.0}]
[Emp{id=1003, name='马化腾', age=50, salary=4500.0}, Emp{id=1007, name='司马大圣', age=111, salary=100000.0}, Emp{id=1001, name='刘强东', age=230, salary=7000.0}, Emp{id=1008, name='欧阳神奇', age=880, salary=20000.0}, Emp{id=1006, name='张三鸣', age=90, salary=12000.0}, Emp{id=1005, name='张一鸣', age=30, salary=12000.0}, Emp{id=1004, name='马超', age=10, salary=10000.0}, Emp{id=1002, name='马云', age=20, salary=3000.0}]
{961248248=张一鸣, 572791696=司马大圣, 1924575248=欧阳神奇, 1467755674=张一鸣, 1536218504=马云, 422561622=马化腾, 1763656883=张三鸣, -1076432150=刘强东, -1822377697=马超}