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<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
//2.数组
Employee[]emps = new Employee[10];
Stream<Employee> stream2 = Arrays.stream(emps);
//3.stream中的静态方法
Stream.of("aa","bb","cc"); //4.创建无限流
//迭代
Stream<Integer> 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<Employee> 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<Employee> stream1 = employeeList.stream().filter((e) -> e.getAge() > 35);
//终止操作:一次性执行全部,就是“惰性求值”
stream1.forEach(System.out::println);
} @Test
public void test2(){
//中间操作:不会做任何的操作
Stream<Employee> stream1 = employeeList.stream().filter((e) -> e.getAge() > 35).limit(1);
//终止操作:一次性执行全部,就是“惰性求值”
stream1.forEach(System.out::println);
} @Test
public void test3(){
//中间操作:不会做任何的操作
Stream<Employee> stream1 = employeeList.stream().filter((e) -> e.getAge() > 35).skip(1);
//终止操作:一次性执行全部,就是“惰性求值”
stream1.forEach(System.out::println);
} //去重必须重写hashcode和equals
@Test
public void test4(){
//中间操作:不会做任何的操作
Stream<Employee> 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<Employee> 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<String> 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<String> list = Arrays.asList("aaa","bbb","ccc","ddd");
Stream<Stream<Character>> charStream = list.stream().map(TestStreamApi3::filterChar);
charStream.forEach((sm)->{
sm.forEach(System.out::println);
}); } //flatMap
@Test
public void test3(){
List<String> list = Arrays.asList("aaa","bbb","ccc","ddd");
list.stream().flatMap(TestStreamApi3::filterChar).forEach(System.out::println); } public static Stream<Character> filterChar(String str){
List<Character> 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<Employee> 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<String> 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<Employee> 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<Employee> 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<Employee> 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<Employee> max = employeeList.stream().max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
System.out.println(max.get());
Optional<Employee> min = employeeList.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
System.out.println(min.get()); Optional<Double> 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<Employee> 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<Integer> 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<Double> reduceOp = employeeList.stream().map(Employee::getSalary).reduce(Double::sum);
System.out.println(reduceOp.get());
} /***
* 收集
* collect--将流转化为其他的形式,接收一个Collector接口的实现,用于给Stream中元素做汇总的方法
*/ @Test
public void test2(){
List<String> names = employeeList.stream().map(Employee::getName).collect(Collectors.toList());
names.forEach(System.out::println); Set<String> disNames = employeeList.stream().map(Employee::getName).collect(Collectors.toSet());
disNames.forEach(System.out::println); System.out.println("----------------");
HashSet<String> 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<Employee> employeeMax = employeeList.stream().collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
System.out.println(employeeMax.get()); //最小值
Optional<Double> val = employeeList.stream().map(Employee::getSalary).collect(Collectors.minBy(Double::compare));
System.out.println(val.get());
} //分组
@Test
public void test4(){
Map<Employee.Status, List<Employee>> statusListMap = employeeList.stream().collect(Collectors.groupingBy(Employee::getStatus));
System.out.println(statusListMap);
} //多级分组
@Test
public void test5(){
Map<Employee.Status, Map<String, List<Employee>>> 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<Boolean, List<Employee>> 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);
} }
JAVA8流操作的更多相关文章
- java8 流操作
0 创建流 public void test1(){ List<String> list = new ArrayList<>(); Stream<String> ...
- java8 流操作 好文网址
api 各方法详解(很不错!) http://blog.51cto.com/turnsole/2093185 api 各方法 简介: https://www.cnblogs.com/guguli/p/ ...
- 【java多线程】java8的流操作api和fork/join框架
原文:https://blog.csdn.net/u011001723/article/details/52794455/ 一.测试一个案例,说明java8的流操作是并行操作 1.代码 package ...
- Java8中的流操作-基本使用&性能测试
为获得更好的阅读体验,请访问原文:传送门 一.流(Stream)简介 流是 Java8 中 API 的新成员,它允许你以声明式的方式处理数据集合(通过查询语句来表达,而不是临时编写一个实现).这有点儿 ...
- Java 8-Lambda表达式、方法引用、标准函数接口与流操作、管道操作之间的关系
1.Lambda表达式与接口之间的关系 只要Lambda表达式的声明形式与接口相一致,在很多情况下都可以替换接口.见如下代码 Thread t1 = new Thread(new Runnable() ...
- 公子奇带你进入Java8流的世界(二)
在上一篇中我们带领大家简单的了解流的概念及使用场景,本节我们就来好好的介绍流的常见用法. 一.筛选和切片 对于一串流,我们有时需要取出我们需要的流中某些元素,主要是通过谓词筛选.看代码: 首先定义一个 ...
- 侠说java8--Stream流操作学习笔记,都在这里了
前言 首次接触到Stream的时候以为它是和InputStream.OutputStream这样的输入输出流的统称. 流和集合的前世今生 概念的差异 在开发中,我们使用最多的类库之一就是集合.集合是一 ...
- 全面吃透JAVA Stream流操作,让代码更加的优雅
全面吃透JAVA Stream流操作,让代码更加的优雅 在JAVA中,涉及到对数组.Collection等集合类中的元素进行操作的时候,通常会通过循环的方式进行逐个处理,或者使用Stream的方式进行 ...
- Node学习笔记(一):stream流操作
NodeJs中谈及较多的可能就是Stream模块了,先写一个简单的ajax回调 $.post("index.php",{data:'aaa',order:'ccc'},functi ...
随机推荐
- python与pycharm安装
1.python install 1.1 下载安装包 - https://www.python.org/downloads 1.2 installl 1.2.1 双击exe安装文件 1.3 如果安装 ...
- vue中的provide/inject的学习
在 Vue.js 的 2.2.0+ 版本中添加加了 provide 和 inject 选项.用于父级组件向下传递数据.provide/inject:简单的来说就是在父组件(或者曾祖父组件)中通过pro ...
- 网关 整理 fastcgi wsgi
https://www.cnblogs.com/hzhtracy/p/4365938.html 网关协议学习:CGI.FastCGI.WSGI.uWSGI 一直对这四者的概念和区别很模糊,现在就特 ...
- 没有文件扩展js的脚本引擎
没有文件扩展js的脚本引擎 没有文件扩展js的脚本引擎怎么解决_百度经验 https://jingyan.baidu.com/article/ff42efa93a7ad9c19e2202f0.html
- MySQL5.7免安装版配置详细教程
MySQL5.7免安装版配置详细教程 一. 软件下载 Mysql是一个比较流行且很好用的一款数据库软件,如下记录了我学习总结的mysql免安装版的配置经验,要安装的朋友可以当做参考哦 mysql5.7 ...
- C#查找字符串位置
int i=zifuchuan.IndexOf(","); int n=(zifuchuan.SubString(i+1)).IndexOf(","); int ...
- 转:jsp内置对象中page与pageContext与el内置对象pageScope与pageContext区别
原文地址:jsp内置对象中page与pageContext与el内置对象pageScope与pageContext区别 首先说明一下jsp9大内置对象 (1)HttpSession类的session对 ...
- python武器库
1,开发库You-GetYouTube/Youku/Niconico视频下载器Zipline一个Pythonic的交易算法库docopt为Python程序创造一个优雅的命令行界面PDFMinerPyt ...
- mysql拼接sql的语法concat()用法
之前写了oracle拼接sql是用“||”,那么mysql也有自己的拼接的语法concat() concat()的基本语法是如下: 括号内的拼接内容语法和python中拼接显示字符串和变量.常量时一样 ...
- 实践-通过matlab操作sqlite数据库
1.下载sqlite-jdbc连接数据库地址 https://bitbucket.org/xerial/sqlite-jdbc/downloads/ 2.将该jar包的绝对路径写入matlab的cla ...