六、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 类：该类提供了三种
格式化方法：
预定义的标准格式
语言环境相关的格式
自定义的格式