java8 流操作_JAVA8流操作

* 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 list = new ArrayList<>();

Stream stream1 = list.stream();

//2.数组

Employee[]emps = new Employee[10];

Stream stream2 = Arrays.stream(emps);

//3.stream中的静态方法

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

//4.创建无限流

//迭代

Stream 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 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 stream1 = employeeList.stream().filter((e) -> e.getAge() > 35);

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

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

}

@Test

public void test2(){

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

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

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

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

}

@Test

public void test3(){

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

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

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

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

}

//去重必须重写hashcode和equals

@Test

public void test4(){

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

Stream 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 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 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 list = Arrays.asList("aaa","bbb","ccc","ddd");

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

charStream.forEach((sm)->{

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

});

}

//flatMap

@Test

public void test3(){

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

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

}

public static Stream filterChar(String str){

List 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 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 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 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 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 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 max = employeeList.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));

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

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

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

Optional 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 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 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 reduceOp = employeeList.stream().map(Employee::getSalary).reduce(Double::sum);

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

}

/***

* 收集

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

*/

@Test

public void test2(){

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

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

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

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

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

HashSet 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 employeeMax = employeeList.stream().collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));

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

//最小值

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

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

}

//分组

@Test

public void test4(){

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

System.out.println(statusListMap);

}

//多级分组

@Test

public void test5(){

Map>> 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> 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);

}

}