java8一些语法使用例子
package com.ladeng.jdk8; import com.google.common.collect.Lists;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.LongStream;
import java.util.stream.Stream; public class Jdk8Test {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(11);
list.add(55);
list.add(44);
list.add(33); // myForEach(list);
// myMap(list);
// myfilter(list);
// mySum(list);
// myCount(list);
// myAllMatch(list);
// myAnyMatch(list);
// myNoneMatch(list);
// myLimit(list);
// myOf();
// myPeek(list);
// myMax(list);
// myMin(list);
// myReduce(list);
// myFunction(list);
// myFlatMap();
// myParallelStream(list);
// myConcatStream();
// list2map();
}
/**
* forEach 用法
*/
private static void myForEach(List<Integer> list) {
list.forEach(e -> System.out.println(e));
}
/**
* map用法及 sorted排序用法
*/
private static void myMap(List<Integer> list) {
List<Integer> collect = list.stream().map(e -> e * 2).sorted((o1, o2) -> o2 - o1)
.collect(Collectors.toList());
collect.forEach(System.out::println);
}
/**
* 过滤
*/
private static void myfilter(List<Integer> list) {
List<Integer> collect = list.stream().filter(e -> e > 33).collect(Collectors.toList());
collect.forEach(System.out::println);
}
/**
* 累加
*/
private static void mySum(List<Integer> list) {
int sum = list.stream().mapToInt(e -> e).sum();
System.out.println(sum);
}
/**
* 统计数量
*/
private static void myCount(List<Integer> list) {
long count = list.stream().count();
System.out.println(count);
}
/**
* 是否所有都匹配
*/
private static void myAllMatch(List<Integer> list) {
List<String> strList = new ArrayList<>();
strList.add("aa");
strList.add("aa");
strList.add("aa");
boolean bool = strList.stream().allMatch(e -> "aa".equals(e));
System.out.println(bool); // true
boolean bool2 = list.stream().allMatch(e -> e > 30);
System.out.println(bool2); // false
}
/**
* 匹配其中任意一个即返回true
*/
private static void myAnyMatch(List<Integer> list) {
List<String> strList = new ArrayList<>();
strList.add("aa");
strList.add("aa");
strList.add("aa");
boolean bool = strList.stream().anyMatch(e -> "aa".equals(e));
System.out.println(bool); // true
boolean bool2 = list.stream().anyMatch(e -> e > 30);
System.out.println(bool2); // true
}
/**
* 所有都不匹配则返回true
*/
private static void myNoneMatch(List<Integer> list) {
List<String> strList = new ArrayList<>();
strList.add("aa");
strList.add("aa");
strList.add("aa11");
boolean bool = strList.stream().noneMatch(e -> "aa".equals(e));
System.out.println(bool); // false
boolean bool2 = list.stream().noneMatch(e -> e > 200);
System.out.println(bool2); // true
}
/**
* 截取前面n条数据
*/
private static void myLimit(List<Integer> list) {
list.stream().limit(2).forEach(System.out::println);
}
/**
* Stream.of(T... t); 参数可以是一个数组
*/
private static void myOf() {
Stream.of(1, 2, 5, 4, 3).forEach(e-> System.out.println(e));
}
/**
* peek接收的参数没有返回值, peek会自动返回之前的集合元素
* 和map非常类似，但是map的参数是有返回值得
*/
private static void myPeek(List<Integer> list) {
List<Integer> collect = list.stream().peek(e -> {
if (e > 40) {
System.out.println(e + "\t"); // 55 44
}
}).collect(Collectors.toList());
System.out.println("----------");
collect.forEach(e -> System.out.print(e + "\t")); // 11 55 44 33
}
/**
* 最大值
*/
private static void myMax(List<Integer> list) {
Optional<Integer> opt = list.stream().max((e1, e2) -> e1.compareTo(e2));
if (opt.isPresent()) {
System.out.println(opt.get());
}
}
/**
* 最小值
*/
private static void myMin(List<Integer> list) {
Optional<Integer> opt = list.stream().max((e1, e2) -> e2.compareTo(e1));
if (opt.isPresent()) {
System.out.println(opt.get());
}
}
/**
* 聚焦函数, 集合进行汇总成一个值;可以是累加或累减，累乘，累除等
* T reduce(T identity, BinaryOperator<T> accumulator); 原理: 直接debug看执行过程;
* 得出结论: 先将-1赋值给 e1, 然后将list.get(0) 赋值给e2; e1 = e1 + e2;
list.get(1) 赋值给e2 e1 = e1 + e2; ...
* Integer integer2 = list.stream()
* .reduce(-1, (e1, e2) ->
* e1 + e2
* );
*/
private static void myReduce(List<Integer> list) {
Optional<Integer> reduce = list.stream().reduce(Integer::sum);
Integer integer = reduce.orElse(0);
System.out.println(integer); // 143
Integer integer2 = list.stream()
.reduce(-1
, (e1, e2) ->
e1 + e2 // 此处打一个断点看执行过程
);
System.out.println(integer2); // 142
}
public static void myOptional() {
// Optional.of 的参数必须不为null, 为null会报空指针
Optional<Integer> opt = Optional.of(11);
Optional<Integer> empty = Optional.empty();
// Optional.ofNullable的参数可以为null,当参数为null时返回的是Optional.empty()
Optional<Integer> opt2 = Optional.ofNullable(11);
// Optional值为null时调用get()会报空指针
// Optional的isPresent() 方法判断Optional如果不为空返回true
if (opt.isPresent()) {
Integer integer1 = opt.get();
}
if (opt2.isPresent()) {
Integer integer = opt2.get();
}
}
// 模拟jdk1.8自带的Function, 传递一个T类型值返回R类型值;
// 常用的自带的函数类型供给型, 预言型, 消费型, Function等类型
public static void myFunction(List<Integer> list) {
// 打印结果 12 56 45 34
list.stream().map(e-> s((e2) -> e2 + 1, e)).collect(Collectors.toList())
.forEach(e -> System.out.print(e + "\t"));
}
public static Integer s(InterfaceDemo1<Integer, Integer> i, Integer x) {
Integer i1 = i.med2(x);
return i1;
}
/**
扁平化, 将多个流汇聚成一个流
*/
public static void myFlatMap() {
List<String> list1 = Lists.newArrayList("a", "b", "c");
List<String> list2 = Lists.newArrayList("a1", "b1", "c1");
List<String> list3 = Lists.newArrayList("a2", "b2", "c2");
List<List<String>> list = Lists.newArrayList(list1, list2, list3);
// [a, b, c] [a1, b1, c1] [a2, b2, c2]
list.stream().forEach(e -> System.out.print(e + "\t"));
// a b c a1 b1 c1 a2 b2 c2
List<String> collect = list.stream()
.flatMap(e -> e.stream())
.collect(Collectors.toList());
collect.forEach(e -> System.out.print(e + "\t"));
}
/**
* 并行流是先将这个任务拆分成细粒度最小的多个任务, 然后进行多线程同时处理，处理完后结果进行汇聚;
* 使用并行流有些局限性; 数据量少不宜使用, 并行流效果还跟cpu有关
数据结果是否易于分解，比如ArrayList比LinkedList易于分解，range创建的原始流也易于分解；
Stream.iterate不宜使用
iterate生成的是Stream<Long>对象，需要拆箱才能求和；
iterate很难分割成独立的小块，因为每次应用这个函数都需要前一次应用的结果
，也就是说它其实是顺序执行的，这样反而在并行时增加了分配线程的开销
尽量使用IntStream, LongStream，和DoubleStream来避免装箱拆箱;
LongStream.rangeClosed直接产生原始类型的long数字，没有拆箱与装箱的开销
LongStream.rangeClosed产生一个数字范围，很容易拆分成多个小块
有些操作在并行流上性能很差，比如limit,findFirst等依赖顺序的操作。
unordered方法可以把有序流转为无序流,使用findAny等好很多,在无序流上用limit也好很多
*/
public static void myParallelStream(List<Integer> list) {
long start0 = System.currentTimeMillis();
long sum3 = LongStream.rangeClosed(0, 1000000000L).reduce(0, Long::sum);// 1670
long end0 = System.currentTimeMillis();
System.out.println(end0 - start0); long start = System.currentTimeMillis();
long sum1 = LongStream
.rangeClosed(0, 1000000000L)
.parallel()
.reduce(0, Long::sum);// 408
long end = System.currentTimeMillis();
System.out.println(end - start); long start1 = System.currentTimeMillis();
long sum2 = LongStream.rangeClosed(0, 1000000000L).reduce(0, Long::sum);// 13251
long end1 = System.currentTimeMillis();
System.out.println(end1 - start1);
}
/**
2个流合并成一个流
*/
public static void myConcatStream() {
Stream<Integer> s1 = Stream.of(1, 2, 3);
Stream<Integer> s2 = Stream.of(11, 22, 33);
Stream<Integer> s3 = Stream.of(111, 222, 333);
Stream<Integer> concat = Stream.concat(Stream.concat(s1, s2), s3);
// 1 2 3 11 22 33 111 222 333
concat.forEach(e -> System.out.print(e + "\t"));
}
/*
list转map
*/
public static void list2map() {
A a1 = new A(1L, "zqd1");
A a2 = new A(2L, "zqd2");
List<A> ls = new ArrayList<>();
ls.add(a1);
ls.add(a2); Map<Long, A> map1 = ls.stream().collect(Collectors.toMap(A::getId, e -> e));
System.out.println(map1); // {1=[A{id=1, name='zqd1'}], 2=[A{id=2, name='zqd2'}]} Map<Long, List<A>> map2 = ls.stream().collect(Collectors.groupingBy(e -> e.getId()));
System.out.println(map2); // {1=[A{id=1, name='zqd1'}], 2=[A{id=2, name='zqd2'}]}
}
}
java8一些语法使用例子的更多相关文章
- Atitit.jdk java8的语法特性详解 attilax 总结
Atitit.jdk java8的语法特性详解 attilax 总结 1.1. 类型推断这个特别有趣的.鲜为人知的特性1 2. Lambda1 2.1. 内部迭代意味着改由Java类库来进行迭代,而不 ...
- java8新语法
Lambda表达式和函数接口(Functional Interface) // lambda expressions public static void DemoLambda() { // 不使用l ...
- Java8 Stream语法详解 2
1. Stream初体验 我们先来看看Java里面是怎么定义Stream的: A sequence of elements supporting sequential and parallel agg ...
- 如何在cmd命令行中查看、修改、删除与添加环境变量，语法格式例子：set path；echo %APPDATA%
如何在cmd命令行中查看.修改.删除与添加环境变量 首先明确一点: 所有的在cmd命令行下对环境变量的修改只对当前窗口有效,不是永久性的修改.也就是说当关闭此cmd命令行窗口后,将不再起作用.永久性修 ...
- java8 stream lambda 一个例子
import java.io.File; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Pa ...
- java8函数式接口小例子
// Function<T, R> -T作为输入,返回的R作为输出 Function<String,String> function = (x) -> {System.o ...
- java8 函数接口 Predicate例子
import java.util.HashSet; import java.util.Collection; import java.util.function.Predicate; public c ...
- java8 运算语法集
1.分组并进行求和组合运算 示例主要代码: List<String> items = Arrays.asList("apple", "apple", ...
- java8 常用语法小结
// 判空 // 排序 //映射 //序列化
随机推荐
- 关于Xpath
1.xPath简介 XPath是一门在XML和HTML文档中查找信息的语言,可以用来在XML和HTML文档中对元素和属性进行遍历 XPath的安装 Chrome插件XPath Helper 点Chro ...
- Python语法规则
Python基本语法 Python的语法相对比C,C++,Java更加简洁,比较符合人的正常思维.本篇介绍Python的基本语法,通过本篇文章你可以学到以下内容. 掌握Python的基本语法 识别Py ...
- MySql数据库之数据库基础命令
继续上篇博客所说到的,使用命令玩转MySql数据库. 在连接数据库时,我们需要确定数据库所在的服务器IP,用户名以及密码.当然,我们一般练习都会使用本地数据库,那么本地数据库的连接命令如下: mysq ...
- Oracle - exp实战
一.概述 exp/imp是oracle中的一个逻辑导出和导入工具,假想一个场景,当我们使用exp命令在对用户进行导出的时候,如果该用户中的某些表的数据有修改,或表结构进行了修改,或者表被删除,那么我们 ...
- spring单元测试下模拟rabbitmq
gradle添加引用 compile 'org.springframework.boot:spring-boot-starter-amqp' testCompile 'com.github.fridu ...
- MySql报错(持续更新)
目录 MySql报错 1. 重复键报错1062- duplicate entry '0' for key 'xxx' 1.1 报错场景 1.2 报错原因 1.3 解决方法 1.4 具体举例 2. VS ...
- CSRF漏洞原理浅谈
CSRF漏洞原理浅谈 By : Mirror王宇阳 E-mail : mirrorwangyuyang@gmail.com 笔者并未深挖过CSRF,内容居多是参考<Web安全深度剖析>.& ...
- Linux(Centos7)下Mysql的安装
1.1 查看mysql的安装路径: [root@bogon ~]# whereis mysql mysql: /usr/bin/mysql /usr/lib/mysql /usr/share/mysq ...
- [20191127]表 full Hash Value的计算.txt
[20191127]表 full Hash Value的计算.txt --//曾经做过表full Hash Value的计算,当时我是通过建立简单的schema以及表名的形式,使用hashcat破解o ...
- C编程小结1
1. ‘\0’表示字符串结束符 2. 变量之间互相赋值一定要考虑他们的数据类型,要强制转换匹配上了或者进行一些处理才能赋值,同时读程序的时候也要注意这一点,否则可能看不懂.如: sData[0]=wD ...