JDK8新特性

这里写目录标题

1、Java8
- 1.1、新特性简介
- 1.2、并行和串行
- 1.3、Nashormy引擎
2、Lambda表达式
- 2.1、Lambda表达式的使用案例
- 2.2、Lambda表达式的六种写法
3、函数式（functional）接口
- 3.1、什么是函数式接口
- 3.2、如何理解函数式接口
- 3.3、Java内置的四大核心函数式接口
- 3.4、Java内置的其他函数式接口
4、方法引用与构造器引用
5、强大的Stream API
- 5.1、Stream API的说明
- 5.2、为什么使用StreamAPI
- 5.3、什么是Stream
- 5.4、Stream操作的是哪个步骤
- 5.5、创建Stream的方式
- - 5.5.1、通过集合
  - 5.5.2、通过数组
  - 5.5.3、通过Stream的of()
  - 5.5.4、创建无限流
- 5.6、Stream的中间操作
- - 5.6.1、筛选与切片
  - 5.6.2、映射
  - 5.6.3、排序
- 5.7、Stream的终止操作
- - 5.7.1、匹配与查找
  - 5.7.2、规约
  - 5.7.3、收集
6、Optional类

1、Java8

1.1、新特性简介

1.2、并行和串行

1.3、Nashormy引擎

2、Lambda表达式

* Lambda表达式的使用
 * 1、举例：（o1，o2） -> Integer.compare(o1,o2);
 * 2、格式：
 *      ->:Lambda操作需 或 箭头操作符
 *      ->:左边：Lambda形参列表（起始就是接口中的抽象方法的形参列表）
 *      ->:右边：lambda体（其实就是重写的抽象方法的方法体）
 *
 *  3、Lambda表达式的使用：（分为6中情况介绍）
 *  总结：
 *  -> 左边：lambda形参列表的参数类型可以省略（类型推断）：如果lambda形参列表只有一个参数，其一对（）也可以省略
 *  -> 右边：lambda体应该使用一对{}包括；如果lambda体只有一条执行语句（可能是return语句），省略一对{}和return

2.1、Lambda表达式的使用案例

public class LambdaTest {
     @Test
    public void test02(){
        Comparator comparator = new Comparator() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        int compare = comparator.compare(12, 13);
        System.out.println(compare);

        System.out.println("==============================");
        //Lambda式表达法
        Comparator comparator1 = (o1,o2) -> Integer.compare(o1,o2);
        int compare1 = comparator1.compare(12, 11);
        System.out.println(compare1);

        System.out.println("==============================");
        //方法引用
        Comparator comparator2 = Integer::compareTo;
        int compare2 = comparator2.compare(12, 13);
        System.out.println(compare2);
    }
}

2.2、Lambda表达式的六种写法

Lambda语格式一：无参，无返回值

@Test
public void test1(){
    Runnable r1 = new Runnable() {
        @Override
        public void run() {
            System.out.println("我爱你");
        }
    };
    r1.run();

    System.out.println("=====================");

    Runnable r2 = () -> {
        System.out.println("I Love you");
    };
    r2.run();
}

Lambda语格式二：Lambda一个参数，但是没有无返回值

@Test
public void test02(){
    Consumer consumer = new Consumer() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    consumer.accept("谎言和誓言的区别是什么");

    System.out.println("======================");

    Consumer consumer1 = (String s)->{
        System.out.println(s);
    };
    consumer1.accept("一个是听的人当真了，一个是说的人当真了");
}

Lambda语格式三：数据类型可以省略，因为可由编译器推断得出、称为“类型推断”

@Test
 public void test03(){
     Consumer consumer = new Consumer() {
         @Override
         public void accept(String s) {
             System.out.println(s);
         }
     };
     consumer.accept("谎言和誓言的区别是什么");

     System.out.println("======================");

     Consumer consumer1 = (s)->{
         System.out.println(s);
     };
     consumer1.accept("一个是听的人当真了，一个是说的人当真了");
 }

Lambda语格式四：Lambda若只需要一个参数时，参数的小括号可以省略

@Test
public void test04(){
    Consumer consumer = new Consumer() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    consumer.accept("谎言和誓言的区别是什么");

    System.out.println("======================");

    Consumer consumer1 = s->{
        System.out.println(s);
    };
    consumer1.accept("一个是听的人当真了，一个是说的人当真了");
}

Lambda语格式五：Lambda需要两个以上的参数，多条执行语句，并且可以有返回值

@Test
public void test05(){
    Comparator comparator = new Comparator() {
        @Override
        public int compare(Integer o1, Integer o2) {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        }
    };
    System.out.println(comparator.compare(12,13));
    System.out.println("=======================");

    Comparator comparator1 = (o1,o2) -> {
        System.out.println(o1);
        System.out.println(o2);
        return o1.compareTo(o2);
    };
    System.out.println(comparator1.compare(12,6));
}

Lambda语格式六：当Lambda体只有一条语句时，return 与大括号若有，可以省略

@Test
public void test06(){
    Comparator comparator = (o1, o2) -> {
            return o1.compareTo(o2);
    };
    System.out.println(comparator.compare(12,13));

    System.out.println("==============================");

    Comparator comparator1 = (o1, o2) -> o1.compareTo(o2);
    System.out.println(comparator1.compare(1,2));
}

3、函数式（functional）接口

Runable就是一个函数式接口

3.1、什么是函数式接口

3.2、如何理解函数式接口

3.3、Java内置的四大核心函数式接口

消费型接口 Consumer void accept(T t)

@Test
public void test01(){
    happyTime(500, new Consumer() {
        @Override
        public void accept(Double aDouble) {
            System.out.println("学习太累了，去买两瓶矿泉水，价格为"+aDouble);
        }
    });
    System.out.println("===============================");

    happyTime(400, money -> System.out.println("学习太累了，去喝了瓶水，价格为"+money));
}

public void happyTime(double money, Consumer con){
    con.accept(money);
}

断定型接口 Predicate boolean test(T t)

@Test
public void test2(){
   List list = Arrays.asList("北京","南京","天津","东京","普京");
   List filterStr = filterString(list, new Predicate() {
       @Override
       public boolean test(String s) {
           return s.contains("京");
       }
   });
   System.out.println(filterStr);

   System.out.println("===========================");
   List filterStr1 = filterString(list,s->s.contains("京"));
   System.out.println(filterStr1);

}

//根据给定的规则，过滤集合中的字符串。此规则有Predicate方法决定
public List filterString(List list, Predicate pre){
   ArrayList filterList = new ArrayList<>();
   for (String s : list) {
       if(pre.test(s)){
           filterList.add(s);
       }
   }
   return filterList;
}

3.4、Java内置的其他函数式接口

4、方法引用与构造器引用 5、强大的Stream API 5.1、Stream API的说明

5.2、为什么使用StreamAPI

5.3、什么是Stream

5.4、Stream操作的是哪个步骤

5.5、创建Stream的方式 5.5.1、通过集合

5.5.2、通过数组

//创建Stream方式一：通过数组
@Test
public void test02(){
    int[] arr = new int[]{1,2,3,4,5,6};
    //调用Arrays类的static  Stream stream(T[] arrar):返回一个流
    IntStream stream = Arrays.stream(arr);
    
    Employee e1 = new Employee(10001,"TOM",18,4000.00);
    Employee e2 = new Employee(10002,"Jerry",19,5000.00);
    Employee[] arr1 = new Employee[]{e1,e2};
    Stream stream1 = Arrays.stream(arr1);
}

5.5.3、通过Stream的of()

//创建Stream方式三：通过Stream的of()
@Test
public void test03(){
    Stream stream = Stream.of(1,2,3,4,5,6);
}

5.5.4、创建无限流

//创建Stream方式四：创建无限流
@Test
public void test(){
    //迭代
    //public static Stream iterate(final T seed,final UnaryOperator f)
    //遍历前10个偶数
    Stream.iterate(0,t -> t+2).limit(10).forEach(System.out::println);

    //生成
    //public static Stream generate(Supplier s)
    Stream.generate(Math::random).limit(10).forEach(System.out::println);
}

5.6、Stream的中间操作 5.6.1、筛选与切片

//1、筛选与切片
@Test
public void test01(){
    List list = EmployeeData.getEmployees();
    //filter(Predicate p) --接收Lambda ,从流中排除某些元素
    Stream stream = list.stream();
    //练习1：查询员工表中薪资大于7000的员工信息
    stream.filter(e->e.getSalary()>5000).forEach(System.out::println);
    System.out.println();

    //limit(n)-截断流，使其元素不超过给定的数量
    list.stream().limit(3).forEach(System.out::println);
    System.out.println();

    //skip(n)-跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流
    list.stream().skip(3).forEach(System.out::println);
    System.out.println();

    //distinct()-筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
    list.add(new Employee(1010,"张三",50,8000.00));
    list.add(new Employee(1010,"张三",50,8000.00));
    list.stream().distinct().forEach(System.out::println);
}

5.6.2、映射

//2、映射
@Test
public  void test(){
    //map(Function f)-接收一个喊出作为参数，经元素转换成其泰兴市或提取信息
    List list = Arrays.asList("aa","bb","cc","dd","ee");
    list.stream().map(str->str.toUpperCase()).forEach(System.out::println);

    //练习：获取员工姓名长度大于3的员工的姓名
    List employees = EmployeeData.getEmployees();
    Stream namesStream = employees.stream().map(Employee::getName);
    namesStream.filter(name -> name.length() > 3).forEach(System.out::println);

    //flatMap(Function f):接收一个函数作为参数，将流中的每个值都转换成另一个流，然后把所有流连接成一个流
    Stream characterStream = list.stream().flatMap(StreamOption::fromStringToStream);
    characterStream.forEach(System.out::println);
}

//将字符串中多个字符构成的集合转换为对应的Stream的实例
public static Stream fromStringToStream(String str){
    ArrayList list = new ArrayList<>();
    for(Character c : str.toCharArray()){
        list.add(c);
    }
    return list.stream();
}

5.6.3、排序

//3、排序
@Test
public void test04(){
    //sorted()--自然排序
    List list = Arrays.asList(12,34,5,67,87,887,3);
    list.stream().sorted().forEach(System.out::println);

    //sorted(Comparator com)--定制排序
    List employees = EmployeeData.getEmployees();
    employees.stream().sorted((e1,e2)->{

        int ageValue = Integer.compare(e1.getAge(), e2.getAge());
        if(ageValue != 0){
            return ageValue;
        }else {//年龄一致时，按照薪水升序排序
            return Double.compare(e1.getSalary(),e2.getSalary());
        }

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

5.7、Stream的终止操作 5.7.1、匹配与查找

//1、匹配与查找
@Test
public void test01(){
    List employees = EmployeeData.getEmployees();
    //allMatch(Predicate p)--检查是否匹配所有元素
    //练习：是否存在员的年龄都大于18
    boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
    System.out.println(allMatch);

    //anyMatch(Predicate p)--检查是否至少匹配一个元素
    //练习：是否存在员的工资大于10000
    boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 100000.00);
    System.out.println(anyMatch);

    //noneMatch(Predicate p)-检查是否没有匹配的元素
    //练习：是否存在员姓“雷"
    boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
    System.out.println(noneMatch);

    //findFirst--返回第一个元素
    Optional employee = employees.stream().findFirst();
    System.out.println(employee);

    //findAny---返回任意的元素
    Optional employee1 = employees.parallelStream().findAny();
    System.out.println(employee1);
}

@Test
public void test02(){
    List employees = EmployeeData.getEmployees();
    //count--返回流中元素的总个数
    long count = employees.stream().filter(e -> e.getSalary() > 5000.00).count();
    System.out.println(count);

    //max(Comparator c)--返回流中最大值
    //练习：返回员工最高工资
    Stream salaryStream = employees.stream().map(e -> e.getSalary());
    Optional maxSalary = salaryStream.max(Double::compare);
    System.out.println(maxSalary);

    //min(Comparator c)--返回流中最小值
    //练习：返回员工最低工资
    Optional employee = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
    System.out.println(employee);
    System.out.println();
    //forEach(Consumer c)--内部迭代
    employees.stream().forEach(System.out::println);
}

5.7.2、规约

//规约
@Test
public void tets03(){
   //reduce(T identity, BinaryOperator)--可以将流中的元素反复结合起来其，得到一个值。返回T
   List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
   Integer sum = list.stream().reduce(0, Integer::sum);
   System.out.println(sum);

   //reduce(BinaryOperator)--可以将流中元素反复结合起来，得到一个值。返回Optional
   //练习2：计算公司员所有工资的总和
   List employees = EmployeeData.getEmployees();
   Stream salaryStream = employees.stream().map(Employee::getSalary);
//        Optional sumMoney = salaryStream.reduce(Double::sum);
   Optional sumMoney = salaryStream.reduce((d1,d2)->d1+d2);
   System.out.println(sumMoney);
}

5.7.3、收集

//3、收集
@Test
public void test(){
   //collect(Collector c)-将流准换成为其他形式，接收一个Collector接口的实例
   //练习1：查找工资大于6000的员工，结果返回一个List或Set
   List employees = EmployeeData.getEmployees();
   List employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
   employeeList.forEach(System.out::println);
   System.out.println();
   List employee = EmployeeData.getEmployees();
   Set employeeSet = employee.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
   employeeSet.forEach(System.out::println);
}

6、Optional类

JDK8新特性

Java相关栏目本月热门文章