java1.8的新特性

一、lambda表达式与函数式接口

（1）lambda表达式：lambda表达式本质上是一段匿名内部类即接口使用匿名方式创建对象，也可以是一段可以传递的代码

  //匿名内部类
  Comparator<Integer> cpt = new Comparator<Integer>() {
      @Override
      public int compare(Integer o1, Integer o2) {
          return Integer.compare(o1,o2);
      }
  };
  TreeSet<Integer> set = new TreeSet<>(cpt);

  //使用lambda表达式
  Comparator<Integer> cpt1 = (x,y) -> Integer.compare(x,y);
  Comparator<Integer> cpt2 = (x,y) -> {
      x=x-y;
      return x-y;
  };
  TreeSet<Integer> set2 = new TreeSet<>(cpt2);

　1、当一个接口中存在多个抽象方法时，如果使用lambda表达式，并不能智能匹配对应的抽象方法，因此引入了函数式接口的概念

　2、为什么Comparator接口有两个抽象方法compare和equals，Comparator还是一个函数式接口？

　　答：如果一个接口中声明的抽象方法是重写了超类Object类中任意一个public方法，那么这些抽象方法并不会算入接口的抽象方法数量中。因为任何接口的实现都会从其父类Object或其它地方获得这些方法的实现。

　3、Lmabda表达式的语法总结： () -> ();

      

（2）函数式接口

　　1、有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为 lambda 表达式。

　　2、lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致

二、StreamAPI

　　Stream专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。

（1）Stream操作的三个步骤：创建，中间操作（过滤，map等），终止

　　1、Stream的创建

//通过Collection 系列集合提供的stream()或者paralleStream()
    List<String> list = new ArrayList<>();
    Strean<String> stream1 = list.stream();

//通过Arrays的静态方法stream()获取数组流
Stream<String> stream2 = Arrays.stream(new String[10]);

//通过Stream类中的静态方法of
Stream<String> stream3 = Stream.of("aa","bb","cc");

//创建无限流
Stream<Integer> stream4 = Stream.iterate(0,(x) -> x+2);
Stream.generate(() ->Math.random());

　　2、Stream的中间操作：

// 筛选 过滤  去重
emps.stream()
          .filter(e -> e.getAge() > 10)
          .limit(4)
          .skip(4)
          // 需要流中的元素重写hashCode和equals方法
          .distinct()
          .forEach(System.out::println);

//自然排序  定制排序
emps.stream()
          .sorted((e1 ,e2) -> {
              if (e1.getAge().equals(e2.getAge())){
                  return e1.getName().compareTo(e2.getName());
              } else{
                  return e1.getAge().compareTo(e2.getAge());
              }
          })
          .forEach(System.out::println);

　　3、Stream的终止操作：

/*
count-返回流中元素的总个数
max-返回流中最大值
min-返回流中最小值
*/
long count = emps.stream()
                .count();
        System.out.println(count);

        Optional<Employee> max = emps.stream()
                .max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(max.get());

        Optional<Employee> min = emps.stream()
                .min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(min.get());

　　4、reduce和collect操作

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

//collect
List<Integer> ageList = emps.stream()
                .map(Employee::getAge)
                .collect(Collectors.toList());
ageList.stream().forEach(System.out::println);

List<Integer> intList = new ArrayList<>();

intList.stream().map(s->String.valueOf(s)).collect(Collectors.toList()) .forEach(s-> System.out.println(s));