Java8内置的四大核心函数式接口

Java8内置的四大核心函数式接口

Consumer<T>: 消费型接口 void accept(T t);

Supplier<T>: 供给型接口 T get();

Function<T,R>:函数型接口 R apply(T t);

Predicate<T>: 断言型接口 bollean test(T t);

其他…Bi...相关的子函数接口

 

方法引用：若lambda体中的内容方法已经实现了，我们可以使用”方法引用”（可以理解为方法引用是lambda表达式的另外一种表现形式）

只要有三种语法格式：

对象::实例方法名

类::静态方法名

类::实例方法名

   注意事项1：lambda体中的方法参数列表和返回值和函数式接口中抽象方法的参数列表和返回值类型要保持一致

注意事项2：若lambda 参数列表中的第一个参数是实例方法的调用者，而第二个参数     是实例方法的参数时，可以使用ClassName::method

 

 构造器引用：

  格式： ClassName::new  

  注意：需要调用的构造器的参数列表与函数式中抽象方法的参数列表保持一致

数组引用：

  格式：Type[]::new;

 

强大的StreamAPI

Stream 是java8中处理集合的关键抽象概念，可以指定你希望的集合进行操作，可以执行复杂的查找、过滤和映射数据等操作。简而言之，streamAPI提供了一种高效且易于使用的处理数据的方法。

流(Stream)是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。”集合讲的是数据，流讲的是计算！”。

注意：1.Stream 自己不会存储元素。

       2.stream不会改变源对象，相反，他们会返回一个持有结果的新Stream

1. Stream操作是延迟执行的，这意味着他们会等到需要结果的时候才执行

Stream的操作三个步骤

1.创建Stram 一个数据源（集合、数组）获取一个流

2.中间操作 一个中间操作链，对数据源的数据进行处理

3.终止操作 执行中间操作链，并产生一个结果集合

 

创建流的方式：

1. 可以通过Collection 系列集合提供stream()或parallelStream()并行
2. 通过Arrays数组中静态stram()获取数组流
3. 通过stream类中的静态方法of()获取流
4. 创建无限流  迭代和生成

 

Stream<String> a = Stream.iterate("a", (x) -> x + 2);
Stream.generate(() -> Math.random())
        .limit(2)
        .forEach(System.out::print);

 

Stream.generate(()->Math.random()).limit(2).forEach(System.out::println);

 

多个中间操作可以连接形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为”惰性求值”.

 

中间对象：

筛选与切片

fiter—接收Lambda，从流中排出某些元素

limit—截断流，使其元素不超过给定数量

skip(n)—跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流。与limit(n)互补

distinct—筛选，通过流所生成元素的hashCode()和equals()去除重复元素

映射

map—接收lambda,将元素转换成其他形式或提供信息。加收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素

 

//将元素转化成其他形式
List<String> list = Arrays.asList("aaa", "bbb", "ccc");
list.stream().map((str)->str.toUpperCase()).forEach(System.out::println);

 

 

List<Student> students = new ArrayList<>();
students.add(new Student("1","z5",14));
students.add(new Student("2","z4",12));
students.add(new Student("3","z2",14));
//提供信息
students.stream().map(Student::getAge).forEach(System.out::println);

flatMap—接受一个函数作为参数，将流中每个值都换成另一个流，然后把所有流连接成一个流

排序

 sorted()—自然排序

 sorted(Comparator com)—定制排序(Comparator)

 

/**
 * 定制排序 如果年龄相同就按照姓名排序
 */
List<Student> students = new ArrayList<>();
students.add(new Student("1","z5",14));
students.add(new Student("2","z4",12));
students.add(new Student("3","z2",14));
students.stream().sorted((x,y)->{
   if(x.getAge().equals(y.getAge())){
       return x.getName().compareTo(y.getName());
   }else{
       return x.getAge().compareTo(y.getAge());
   }

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

终止操作

查找与匹配

allMatch—检查是否匹配所有元素

anyMath--检查是否匹配一个元素

noneMath—检查是否没有匹配所有元素

findFirst—返回一个元素

findAny—返回当前流中的任意元素

count—返回流中元素的总个数

max—返回流中最大值

min—返回流中最小值

归约

reduce(T identtity,BinaryOperator)/reduce(BinaryOperator)—可以将流中元素反复结合起来，得到一个值

 

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer sum = integers.stream().reduce(0, (x, y) -> x + y);
System.out.println(sum);

//计算年龄总和
List<Student> students = new ArrayList<>();
students.add(new Student("1","z5",14));
students.add(new Student("2","z4",12));
students.add(new Student("3","z2",14));
Optional<Integer> sum = students.stream().map(Student::getAge).reduce(Integer::sum);
System.out.println(sum.get());

map和reduce的连接通常称为map-reduce模式 因Google用它来进行网络搜索而出名

收集

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

 

List<Student> students = new ArrayList<>();
students.add(new Student("1","z5",14));
students.add(new Student("2","z4",12));
students.add(new Student("3","z2",14));

List<String> collect = students.stream().map(Student::getName).collect(Collectors.toList());
collect.forEach(System.out::println);

收集到实现类集合中

 

List<Student> students = new ArrayList<>();
students.add(new Student("1","z5",14));
students.add(new Student("2","z4",12));
students.add(new Student("3","z2",14));
HashSet<String> collect = students.stream().map(Student::getName).collect(Collectors.toCollection(HashSet::new));
collect.forEach(System.out::println);

Fork/join框架

就是在必要的情况下，将一个大任务，进行拆分（fork）成若干个小任务（拆到不可再拆时），再讲一个个小任务运算的结果进行join汇总

原理：工作窃取模式

当执行新的任务时他可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。

相对于一般的线程池实现，fork/join框架的优势体现在对其包含的任务处理方式上，如果

一个线程正在执行的任务由于某些原因无法继续运行。那么该线程会处于等待状态，而在fork/join框架实现中，如果某个子问题由于等待另外一个子问题的完成而无法继续运行，那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行，这种方式减少了线程的等待时间，提高性能。

并行流与顺序流

并行流：就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

Java8中将并行进行了优化，我们可以人容易的对数据进行并行操作。StreamAPI可以声明性地通过parallel()与sequential()在并行流与顺序流中间进行且切换。

Optional类

Optional<T>类（java.util.Optional）是一个容器类，代表一个值存在或者不存在，原来用null表示一个值不存在，现在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，否则返回Optonal.empty()

flatMap(Function mapper):与map类似，要求返回值必须是Optional

 

接口中的默认方法与静态方法

接口中的默认方法：“类优先”原则

若一个接口中定义了一个默认方法，而另一个父类或接口中又定义了一个同名的方法时

1. 选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
2. 接口冲突。如果有一个父类接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖方法来解决冲突问题

 

public interface MyFunction {
   
    default String getName(){
        return "hyl";
    }
    public static void eat(){
        System.out.println("韩玉林");
    }
}

新时间日期API

LocalDate、LocalTime、LocalDateTime类的实例是不可变的对象，分别表示使用ISO-8601

日历系统的日期、时间、日期和时间。他们提供了简单的日期或时间，并不包括当前的时间信息。也不包含与时区相关的信息。

 

//当前当前时间
LocalDateTime now = LocalDateTime.now();
System.out.println(now);
LocalDateTime dateTime1 = now.plusDays(2);//加2天
now.minusMonths(2);//减2月
now.getYear();//年
now.getMonth();//月
System.out.println(dateTime1);
LocalDateTime dateTime = LocalDateTime.of(1234, 12, 12, 12, 12, 12);
//System.out.println(dateTime);

Instant:时间戳(Unix 元年：1970年1月1日00:00:00到某个时间的毫秒值)

 

Instant now = Instant.now();//默认获取UTC时区
System.out.println(now);//2018-04-06T14:04:38.094Z 时间相差8个小时
OffsetDateTime dateTime = now.atOffset(ZoneOffset.ofHours(8));
System.out.println(dateTime);//2018-04-06T22:04:38.094+08:00
//加一分钟
Instant instant = Instant.ofEpochSecond(60);

Duration:计算两个“时间“之间的间隔

Period: 计算两个”日期”之间的间隔

 

Instant now = Instant.now();
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {

}
Instant now1 = Instant.now();

Duration duration = Duration.between(now, now1);
System.out.println(duration.toMillis());//毫秒

LocalDate localDate = LocalDate.of(2015, 1, 1);
LocalDate now2 = LocalDate.now();
Period period = Period.between(localDate, now2);
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());

时间的操作

TemporalAdjuster:时间校正器。有时我们可能需要获取列如“下个周日”等操作。

TemporalAdjusters:该类通过静态方法提供大量的常用TemporalAdjuster的实现。

 

LocalDateTime now = LocalDateTime.now();
LocalDateTime dateTime = now.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
System.out.println(dateTime);
//自定义 下一个工作日
now.with((l)->{
   LocalDateTime ldt4=(LocalDateTime)l;
    DayOfWeek dow = ldt4.getDayOfWeek();
   
    if(dow.equals(DayOfWeek.FRIDAY)){
        return ldt4.plusDays(3);
    }else if( dow.equals(DayOfWeek.SATURDAY)){
        return ldt4.plusDays(2);
    }else{
        return ldt4.plusDays(1);
    }
});

时间格式化

DateTimeFormatter:格式化时间/日期

时区的处理

Java8中加入了对时区的支持，带时区的时间分别为：

ZoneDate、ZoneTime、ZoneDateTime

其中每个时区都对应着ID，地区ID都为“{区域}/{城市}”的格式

例如：Asia/Shanghai等

ZoneId:该类中包含了所有的时区信息

  getAvailableZoneIds():可以获取所有时区信息

  of(id):用指定的时区信息获取ZoneId对象

 

//支持的时区信息
Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
for (String availableZoneId : availableZoneIds) {
    System.out.println(availableZoneId);
}

//支持的时区信息
Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
for (String availableZoneId : availableZoneIds) {
    System.out.println(availableZoneId);
}
LocalDateTime now = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
ZonedDateTime zdt = now.atZone(ZoneId.of("Asia/Shanghai"));
System.out.println(zdt);//带有时区的时间

重复注解与类型注解

JAVA8对注解处理提供两点改进：可重复的注解以及可用于类型的注解。