java8新特性学习2
六、Stream API
Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API(java.util.stream.*)。Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式
流(Stream) 到底是什么呢？
是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，流讲的是计算！”
注意：
①Stream 自己不会存储元素。
②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。（也就是中间操作不会立即执行）
Stream操作分为三个步骤
1、创建 Stream一个数据源（如：集合、数组），获取一个流
2、中间操作一个中间操作链，对数据源的数据进行处理
3、终止操作(终端操作)一个终止操作，执行中间操作链，并产生结果
步骤一：创建Stream的四种方式
package com.bjsxt.stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
* stream的三个步骤
* 1、创建stream
* 2、中间操作
* 3、终止操作（终端操作）
*/
public class TestStream01 {
public static void main(String[] args){
test01();
}
/**
* 创建stream的四种方式
*/
public static void test01(){
// 1、可以通过Collection系列集合提供的stream()或parallelStream()
List<String> list=new ArrayList<String>();
Stream<String> stream=list.stream();
// 2、可以通过Arrays中的静态方法stream()获取数据流
String[] strArr=new String[10];
Stream<String> stream2=Arrays.stream(strArr);
// 3、通过Stream类中的静态方法of()
Stream<String> stream3=Stream.of("aa","bb","cc");
// 4、创建无限流
//方式一：迭代,使用Stream.iterate()方法
Stream<Integer> stream4=Stream.iterate(0,(x)->x+2);
//方式二：生成,使用Stream.generate()方法
Stream<Double> stream5=Stream.generate(()->Math.random());
stream5.forEach(System.out::println); //这个forEach()方法是终端操作，打印用
}
}
步骤二：中间操作
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。
中间操作有很多种，主要有三种
1、筛选与切片
package com.bjsxt.stream;
import com.bjsxt.Person;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
* stream
* 中间操作
*/
public class TestStream02 {
public static List<Person> list= Arrays.asList(
new Person(1,"段然涛",18),
new Person(2,"李飞宇",34),
new Person(3,"卢晓倩",25),
new Person(4,"李小静",67),
new Person(4,"李小静",67),
new Person(4,"李小静",67),
new Person(5,"罗泽成",12)
);
public static void main(String[] args){
}
/**
* filter()方法
*/
public static void tesst01(){
Stream<Person> stream=list.stream(); //获取流
stream.filter((per)->per.age>18) //filter()接收 Lambda ， 从流中排除某些元素，会进行隐式迭代
.forEach(System.out::println); //这个是终端操作，这里使用只是方便打印
}
/**
* limit()方法
*/
public static void tesst02(){
Stream<Person> stream=list.stream(); //获取流
stream.filter((per)->per.age>18) //filter()接收 Lambda ， 从流中排除某些元素
.limit(2) //截断流，使其元素不超过给定数量。也就是只要筛选出来的前两个，这里操作类似于短路（&&），当筛选出来两个后，后面的就不再迭代，提高效率
.forEach(System.out::println); //这个是终端操作，这里使用只是方便打印
}
/**
* skip()方法
*/
public static void tesst03(){
Stream<Person> stream=list.stream(); //获取流
stream.filter((per)->per.age>18) //filter()接收 Lambda ， 从流中排除某些元素
.skip(2) //跳过前两个元素，跟limit刚好相反
.forEach(System.out::println); //这个是终端操作，这里使用只是方便打印
}
/**
*distinct()方法
*/
public static void tesst04(){
Stream<Person> stream=list.stream(); //获取流
stream.filter((per)->per.age>18) //filter()接收 Lambda ， 从流中排除某些元素
.distinct() //筛选，通过流所生成元素的 hashCode() 和 equals() 去 除重复元素
.forEach(System.out::println); //这个是终端操作，这里使用只是方便打印
}
}
2、映射
package com.bjsxt.stream;
import com.bjsxt.Person;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
* stream
* 中间操作
*/
public class TestStream03 {
public static List<Person> list= Arrays.asList(
new Person(1,"段然涛",18),
new Person(2,"李飞宇",34),
new Person(3,"卢晓倩",25),
new Person(4,"李小静",67),
new Person(4,"李小静",67),
new Person(4,"李小静",67),
new Person(5,"罗泽成",12)
);
public static void main(String[] args){
tesst02();
}
/**
* map()方法
*/
public static void tesst01(){
Stream<Person> stream=list.stream(); //获取流
stream.map((person -> person.getName())) //接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素
.forEach(System.out::println);
System.out.println("-----------------------------------------------------------------------------");
List<String> list=Arrays.asList("aa","bb","cc");
list.stream().map(str->str.toUpperCase())
.forEach(System.out::println);
}
/**
* flatMap()方法
*/
public static void tesst02(){
List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
Stream<Stream<Character>> stream=strList.stream().map(TestStream03::splitString);
stream.forEach(sm->sm.forEach(System.out::println)); //如果使用map需要这样遍历
System.out.println("------------------------------");
/**
* map和flatMap的区别就如集合中add(集合)和addAll(集合)的区别
*/
Stream<Character> stream2 = strList.stream()
.flatMap(TestStream03::splitString); //接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
stream2.forEach(System.out::println);
}
public static Stream<Character> splitString(String str){
List<Character> list=new ArrayList<Character>();
for(Character c:str.toCharArray()){
list.add(c);
}
return list.stream();
}
}
3、排序
package com.bjsxt.stream;
import com.bjsxt.Person;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
/**
* stream
* 中间操作
*/
public class TestStream04 {
public static List<Person> list= Arrays.asList(
new Person(1,"段然涛",18),
new Person(2,"李飞宇",34),
new Person(3,"卢晓倩",25),
new Person(4,"李小静",67),
new Person(4,"李小静",67),
new Person(4,"李小静",67),
new Person(5,"罗泽成",12)
);
public static void main(String[] args){
tesst02();
}
/**
* sorted()方法,按照自然顺序排序
*/
public static void tesst01(){
List<String> list=Arrays.asList("bb","aa","dd","ee");
list.stream()
.sorted()
.forEach(System.out::println);
}
/**
* sorted(Comparator<? super T> comparator)方法,需要传一个比较器过去，按照指定的比较器进行排序
*/
public static void tesst02(){
list.stream().sorted((e1,e2)->{
if(e1.age==e2.age){
return e1.name.compareTo(e2.name);
}else{
return e1.age.compareTo(e2.age);
}
}).forEach(System.out::println);
}
}
步骤三：终止操作
终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void，终止操作也有多种
1、查找与匹配
package com.bjsxt.stream;
import com.bjsxt.Person;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
/**
* stream
* 终止操作
*/
public class TestStream05 {
public static List<Person> list= Arrays.asList(
new Person(1,"段然涛",18),
new Person(2,"李飞宇",34),
new Person(3,"卢晓倩",25),
new Person(4,"李小静",67),
new Person(4,"李小静",67),
new Person(4,"李小静",67),
new Person(5,"罗泽成",12)
);
public static void main(String[] args){
tesst01();
}
/**
* 终止操作
* allMatch——检查是否匹配所有元素
* anyMatch——检查是否至少匹配一个元素
* noneMatch——检查是否没有匹配的元素
* findFirst——返回第一个元素
* findAny——返回当前流中的任意元素
* count——返回流中元素的总个数
* max——返回流中最大值
* min——返回流中最小值
*/
public static void tesst01(){
boolean b1=list.stream().allMatch(person -> person.getAge()>10); //是否所有人的年龄大于10
System.out.println(b1);
boolean b2=list.stream().anyMatch(person -> person.getAge()>100); //是否至少一个人的年龄大于100
System.out.println(b2);
boolean b3=list.stream().noneMatch(person -> person.getAge()>100); //没有一个人的年龄大于100
System.out.println(b3);
Optional<Person> optional=list.stream() //Optional是一个容器。java8新出的，防止空指针异常
.findFirst(); //取第一个
Person person=optional.get();
System.out.println(person);
Optional<Person> optiona2=list.stream()
.findAny(); //取任何一个
Person person2=optional.get();
System.out.println(person2);
Long ll=list.stream().count(); //个数
System.out.println(ll);
Optional<Person> optiona3=list.stream().max((e1,e2)->{ // 取最大值，根据指定比较器
if(e1.age==e2.age){
return e1.name.compareTo(e2.name);
}else{
return e1.age.compareTo(e2.age);
}
});
System.out.println(optiona3.get());
Optional<Person> optiona4=list.stream().min((e1,e2)->{ // 取最小值，根据指定比较器
if(e1.age==e2.age){
return e1.name.compareTo(e2.name);
}else{
return e1.age.compareTo(e2.age);
}
});
System.out.println(optiona4.get());
}
}
2、归约
package com.bjsxt.stream;
import com.bjsxt.Person;
import java.util.*;
import java.util.function.BinaryOperator;
import java.util.stream.Collector;
import java.util.stream.Collectors;
/**
* stream
* 终止操作
*/
public class TestStream06 {
public static List<Person> list= Arrays.asList(
new Person(1,"段然涛",18),
new Person(2,"李飞宇",34),
new Person(3,"卢晓倩",25),
new Person(4,"李小静",67),
new Person(4,"李小静",18),
new Person(4,"李小静",67),
new Person(5,"罗泽成",12)
);
public static void main(String[] args){
tesst01();
}
/**
*reduce()规约 可以将流中元素反复结合起来，得到一个值。返回 T
*/
public static void tesst01(){
List<Integer> list1=Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Integer integer=list1.stream().reduce(0, (x,y)->x+y); //0是起始值。然后0+1+2+3+4+5+...
System.out.println(integer);
System.out.println("---------------------------------------------");
Optional<Integer> optional=list.stream()
.map(Person::getAge)
.reduce(Integer::sum);
System.out.println(optional.get());
}
｝
3、收集
package com.bjsxt.stream;
import com.bjsxt.Person;
import java.util.*;
import java.util.function.BinaryOperator;
import java.util.stream.Collector;
import java.util.stream.Collectors;
/**
* stream
* 终止操作
*/
public class TestStream06 {
public static List<Person> list= Arrays.asList(
new Person(1,"段然涛",18),
new Person(2,"李飞宇",34),
new Person(3,"卢晓倩",25),
new Person(4,"李小静",67),
new Person(4,"李小静",18),
new Person(4,"李小静",67),
new Person(5,"罗泽成",12)
);
public static void main(String[] args){
tesst02();
}/**
* collect(Collector c)方法
* 将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
* Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。
* 但是Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例
*/
public static void tesst02(){
//收集姓名放入list
List<String> list2=list.stream()
.map(Person::getName)
.collect(Collectors.toList());
list2.forEach(System.out::println);
System.out.println("--------------------------------------------");
//收集姓名放入set
Set<String> set=list.stream()
.map(Person::getName)
.collect(Collectors.toSet());
set.forEach(System.out::println);
System.out.println("--------------------------------------------");
//收集姓名放入指定的集合
LinkedHashSet<String> linkedHashSet=list.stream()
.map(Person::getName)
.collect(Collectors.toCollection(LinkedHashSet::new));
linkedHashSet.forEach(System.out::println);
System.out.println("--------------------------------------------");
//收集总个数
Long count=list.stream()
.collect(Collectors.counting());
System.out.println(count);
System.out.println("--------------------------------------------");
//收集平均值
Double integer=list.stream()
.collect(Collectors.averagingDouble(Person::getAge));
System.out.println(integer);
System.out.println("--------------------------------------------");
//收集总和
Integer sum=list.stream()
.collect(Collectors.summingInt(Person::getAge));
System.out.println(sum);
System.out.println("--------------------------------------------");
//收集最大值
Optional<Person> optional=list.stream()
.collect(Collectors.maxBy((p1,p2)->Integer.compare(p1.getAge(),p2.getAge())));
System.out.println(optional.get());
System.out.println("--------------------------------------------");
//收集最小值
Optional<Person> optional2=list.stream()
.collect(Collectors.maxBy((p1,p2)->-Integer.compare(p1.getAge(),p2.getAge())));
System.out.println(optional2.get());
System.out.println("--------------------------------------------");
//分组,名字相同的分为一组
Map<String,List<Person>> map=list.stream()
.collect(Collectors.groupingBy(Person::getName));
System.out.println(map);
System.out.println("--------------------------------------------");
//分组,名字相同的分为一组,名字相同再根据年龄分组
Map<String,Map<String,List<Person>>> map1=list.stream()
.collect(Collectors.groupingBy(Person::getName,Collectors.groupingBy((p)->{
if(p.getAge()>20){
return "青年";
}else{
return "老年";
}
})));
System.out.println(map1);
System.out.println("--------------------------------------------");
//分区，只能分为两个区，true和false两个区,根据年龄40分为两个区
Map<Boolean,List<Person>> map2=list.stream()
.collect(Collectors.partitioningBy((e)->e.getAge()>40));
System.out.println(map2);
System.out.println("--------------------------------------------");
//求总和。平均值。总数、最大值、最小值等等
DoubleSummaryStatistics dss= list.stream()
.collect(Collectors.summarizingDouble(Person::getAge));
System.out.println(dss.getSum());
System.out.println(dss.getAverage());
System.out.println(dss.getCount());
System.out.println("--------------------------------------------");
//把姓名按照“，”分割
String str=list.stream()
.map(Person::getName)
.collect(Collectors.joining(","));
System.out.println(str);
System.out.println("--------------------------------------------");
}
}
七：并行流和串行流
并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。java8中的并行流底层就是采用的java的Fork/Join 框架
package com.bjsxt.forkJoin; import java.time.Duration; import java.time.Instant; import java.util.concurrent.ForkJoinPool; import java.util.stream.LongStream; /** * Created by Administrator on 2019/3/7. */ public class TestForkJoin { public static void main(String[] args){ test02(); } public static void test02(){ long start = System.currentTimeMillis(); Long sum = LongStream.rangeClosed(0L, 10000000000L) .parallel() //切换到并行流 .sum(); System.out.println(sum); long end = System.currentTimeMillis(); System.out.println("耗费的时间为: " + (end - start)); } }
这里有必要简单介绍下Fork/Join框架
Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总
Fork/Join 框架与传统线程池的区别
采用 “工作窃取”模式（work-stealing）：
当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中,如果一个线程正在执行的任务由于某些原因无法继续运行,那么该线程会处于等待状态.而在fork/join框架实现中,如果某个子问题由于等待另外一个子问题的完成而无法继续运行.那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程的等待时间,提高了性能
案例：计算start与end之间的值的总和
package com.bjsxt.forkJoin; import java.util.concurrent.RecursiveTask; /** * 计算start与end之间的值的总和 */ public class ForkJoinCalculate extends RecursiveTask<Long> { private long start; private long end; private static final long THRESHOLD = 100000L; //临界值 public ForkJoinCalculate(long start, long end) { this.start = start; this.end = end; } /** * * @return */ @Override protected Long compute() { long length=end-start; if(length<THRESHOLD){ //已经小于临界值 long sum=0; for(long i=start;i<=end;i++){ sum+=sum+i; } return sum; }else{ //没到临界值，需要继续分割任务 long middle=(start+end)/2; ForkJoinCalculate left=new ForkJoinCalculate(start,middle); left.fork(); ForkJoinCalculate right=new ForkJoinCalculate(middle+1,end); right.fork(); return left.join()+right.join(); } } }
package com.bjsxt.forkJoin; import java.time.Duration; import java.time.Instant; import java.util.concurrent.ForkJoinPool; import java.util.stream.LongStream; /** * Created by Administrator on 2019/3/7. */ public class TestForkJoin { public static void main(String[] args){ test01(); } public static void test01(){ Instant strat=Instant.now(); ForkJoinPool forkJoinPool=new ForkJoinPool(); ForkJoinCalculate forkJoinCalculate=new ForkJoinCalculate(0,100000000000L); long sum=forkJoinPool.invoke(forkJoinCalculate); System.out.println(sum); Instant end=Instant.now(); System.out.println("计算耗时:"+ Duration.between(strat,end).toMillis()); } }
八、Optional 类
Optional<T> 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常
package com.bjsxt.optiona; import com.bjsxt.Person; import java.util.Optional; /** * 一、Optional 容器类：用于尽量避免空指针异常 * Optional.of(T t) : 创建一个 Optional 实例 * Optional.empty() : 创建一个空的 Optional 实例 * Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例 * isPresent() : 判断是否包含值 * orElse(T t) : 如果调用对象包含值，返回该值，否则返回t * orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值 * map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty() * flatMap(Function mapper):与 map 类似，要求返回值必须是Optional */ public class TestOptiona { public static void main(String[] args){ test01(); } public static void test01(){ Optional<Person> optional=Optional.of(new Person()); //如果of()方法里面的值为null,下面一句会发生空指针异常 Person p=optional.get(); //获取Optional容器中的值 System.out.println(p); } public static void test02(){ Optional<Person> optional=Optional.empty(); //创建一个空的 Optional 实例 Optional<Person> optiona2=Optional.ofNullable(new Person());//若 参数 不为 null,创建 Optional 实例,否则创建空实例 } public static void test03(){ Optional<Person> optiona2=Optional.ofNullable(new Person());//若 参数 不为 null,创建 Optional 实例,否则创建空实例 if(optiona2.isPresent()){ //判断Optional容器中是否包含值 System.out.println("有值。。。"); } Person p1 = optiona2.orElse(new Person(1,"张三",23)); //如果容器值为空，则值为orElse()方法的参数 System.out.println(p1); Person p2 = optiona2.orElseGet(() -> new Person()); //同orElse()，只不过参数是一个函数式接口 System.out.println(p2); } public void test04(){ Optional<Person> op = Optional.of(new Person(1,"张三",23)); Optional<String> op2 = op.map(Person::getName); System.out.println(op2.get()); Optional<String> op3 = op.flatMap((e) -> Optional.of(e.getName())); System.out.println(op3.get()); } }
9、新的时间与日期API
java之前的时间对象是可变的对象，存在线程安全问题，java8引入了全新的时间类
LocalDate、LocalTime、LocalDateTime 类的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间信息。也不包含与时区相关的信息。
Instant 时间戳，用于“时间戳”的运算。它是以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运算
Duration:用于计算两个“时间”间隔
Period:用于计算两个“日期”间隔
TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。
TemporalAdjusters : 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。
java.time.format.DateTimeFormatter 类：该类提供了三种
格式化方法：
预定义的标准格式
语言环境相关的格式
自定义的格式
