JDK8的新特性

文章目录

• 1. lambda表达式
• 2. 函数式接口。
• 3. 方法引用。
• 4. Stream流
• 5. 日期时间类

---

一.lambda表达式

概念:

 语法:

注意:

         函数式接口:接口中只有一个抽象方法。

        (参数1，参数2): 抽象方法的参数

        ->: 分隔符

        {}：表示抽象方法的实现

package com.zsb.demo01;

public class Test {
    public static void main(String[] args) {
        My my = new My();
        Thread t1 = new Thread(my);
        t1.start();

        //
        Runnable task2 = new Runnable() {
            @Override
            public void run() {
                System.out.println("这时匿名内部类方式的任务对象");
            }
        };
        Thread t2 = new Thread(task2);
        t2.start();

    }
}
class My implements Runnable{

    @Override
    public void run() {
        System.out.println("自定义任务接口类");
    }
}

---

分析代码:

• Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心

• 为了指定 run 的方法体，不得不需要 Runnable 接口的实现类

• 为了省去定义一个 Runnable 实现类的麻烦，不得不使用匿名内部类

• 必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错

• 而实际上，似乎只有方法体才是关键所在。

这时可以使用lambda表示完成上面的要求。

前提:必须是函数式接口。

简化匿名内部类的使用，语法更加简单。

 //lambda表达式
        Runnable task3 = () -> {
            System.out.println("这是使用Lambda表达式完成的");
        };
        Thread t3 = new Thread(task3);
        t3.start();

二、无参无返回值

package com.zsb.demo01;

public class Test02 {
    public static void main(String[] args) {

        //匿名内部类
        Swimmable swimmable=new Swimmable() {
            @Override
            public void swimming() {
                System.out.println("这时使用匿名内部类的方式");
            }
        };
        fun(swimmable);

        //lambda表达式
//        Swimmable swimmable1=()->{
//            System.out.println("使用lambda表达式");
//        };
        fun(()->{System.out.println("使用lambda表达式");});
    }

    public static void fun(Swimmable w){
        w.swimming();
    }
}
//函数式接口
interface Swimmable{
    public void swimming();
}

三、 练习有参数有返回值的Lambda

下面举例演示 java.util.Comparator 接口的使用场景代码，其中的抽象方法定义为：

• public abstract int compare(T o1, T o2);

当需要对一个对象集合进行排序时， Collections.sort 方法需要一个 Comparator 接口实例来指定排序的规则。

package com.zsb.demo02;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Test02 {
    public static void main(String[] args) {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("张三",19,180));
        personList.add(new Person("李四",89,170));
        personList.add(new Person("王五",23,195));
        personList.add(new Person("七七",694,140));

        Comparator<Person> comparator = new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o2.getAge()- o1.getAge();
            }
        };
        Collections.sort(personList,comparator);

        for (Person p:personList){
            System.out.println(p);
        }
        System.out.println("+++++++++lambda++++++++++++++=");

        Comparator<Person> comparator1 = (Person o1, Person o2)->{
            return o1.getAge()- o2.getAge();
        };
        Collections.sort(personList,comparator1);

        for (Person p:personList){
            System.out.println(p);
        }
    }
}
class Person {
    private String name;
    private int age;
    private int height;

    public Person() {
    }

    public Person(String name, int age, int height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }
}

四、详细介绍lambda表达式

五、函数式接口

 内置函数式接口的由来

package com.zsb.demo03;

public class Test03 {

    public static void main(String[] args) {
        Operater o=arr -> {
             int sum=0;
             for(int n:arr){
                 sum+=n;
             }
            System.out.println("数组的和为:"+sum);
        };

        fun(o);
    }

    public static void fun(Operater operater){
         int[] arr={2,3,4,5,6,7,11};
         operater.getSum(arr);
    }

}
@FunctionalInterface
interface Operater{
    //求数组的和
    public abstract void getSum(int[] arr);
}

分析

我们知道使用Lambda表达式的前提是需要有函数式接口。而Lambda使用时不关心接口名，抽象方法名，只关心抽 象方法的参数列表和返回值类型。因此为了让我们使用Lambda方便，JDK提供了大量常用的函数式接口。

常见得函数式接口

java.util.function保存

六、Consumer<T>

package com.zsb.demo03;

import java.util.Random;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class Test04 {
    public static void main(String[] args) {
        Consumer<Double> c = t->{
            System.out.println("花了"+t+"元");
        };
        fun(c,1000);
    }
    public static void fun(Consumer<Double> consumer,double money){
        consumer.accept(money);
    }
}

七、 Supplier<T>供给型函数式接口

T:表示返回结果的泛型

无参，想有返回结果的函数式接口时

T get();

package com.zsb.demo04;

import java.util.Random;
import java.util.function.Supplier;

public class Test {
    public static void main(String[] args) {
        fun(() -> new Random().nextInt(10));
    }
    public static void fun(Supplier<Integer> supplier){
        Integer result = supplier.get();
        System.out.println("内容"+result);
    }
}

八、Function<T,R> 函数型函数式接口

T: 参数类型的泛型

R: 函数返回结果的泛型

有参，有返回 值时。

例子: 传入一个字符串把小写转换为大写。

package com.zsb.demo04;

import java.util.function.Function;

public class Test01 {
    public static void main(String[] args) {
        fun((t)->{
            return t.toUpperCase();
        },"hello word");
    }
    public static void fun(Function<String,String> function,String msg){
        String s = function.apply(msg);
        System.out.println("结果为:"+s);
    }
}

九、Predicated<T>

T: 参数的泛型

boolean test(T t);

当传入一个参数时，需要对该参数进行判断时，则需要这种函数。

package com.zsb.demo04;

import java.util.function.Predicate;

public class Test02 {
    public static void main(String[] args) {
        fun(n->{
            return n.length()>5?true:false;
        },"阿斯托洛吉斯·莫娜·梅姬斯图斯");
    }
    public static void fun(Predicate<String> predicate,String name){
        boolean b = predicate.test(name);
        System.out.println("该名称的长度是否长"+b);
    }
}

十、 方法引用。

lambda表达式的冗余

package com.zsb.demo05;

import java.util.function.Consumer;
import java.util.function.Function;

public class Test {
    public static void main(String[] args) {
//      Consumer<Integer[]> c=arr->{
//          int sum=0;
//          for (int b:arr){
//              sum+=b;
//          }
//          System.out.println("和为:"+sum);
//      };
//      fun(c);
        Consumer<Integer[]> c=Test::sum;
        fun(c);
    }

    public static void fun(Consumer<Integer[]> consumer){
        Integer[] arr = {1,2,3,4,5};
        consumer.accept(arr);
    }
    public static void sum(Integer[] arr){
        int sum=0;
        for (int b:arr){
            sum+=b;
        }
        System.out.println("数组的和为:"+sum);
    }
}

请注意其中的双冒号 :: 写法，这被称为“方法引用”

十一、什么是方法引用

方法引用是Lambda表达式的一种简写形式。如果Lambda表达式方法体中只是调用一个特定的已经存在的方法,则可以使用方法引用。

常见形式.

        对象::实例方法.

        类::静态方法

        类::实例方法

        类::new

 方法引用的分类

十二、实例方法引用

实例方法引用，顾名思义就是调用已经存在的实例的方法，与静态方法引用不同的是类要先实例化，静态方法引用类无需实例化，直接用类名去调用。

package com.zsb.demo05;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class Test02 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(9);
        list.add(6);
        list.add(4);
        list.add(3);

        Comparator<Integer> c=((o1, o2) -> Integer.compare(o1,o2));
        list.sort(c);
        System.out.println(list);
    }
}

package com.zsb.demo05;

import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Supplier;

public class Test03 {
    public static void main(String[] args) {
//        People[] ps={new People("张三",12),new People("李四",56),new People("王五",8)};
//
//        Comparator<People> c = People::compareTo;
//        Arrays.sort(ps,c);


          People p = new People("李四",25);
//        Supplier<String> s=()->p.getName();

        Supplier<String> s=p::getName;
        fun(s);
    }
    public static void fun(Supplier<String> supplier){
        String s = supplier.get();
        System.out.println("结果:"+s);
    }
}
class People{
    private String name;
    private int age;

    public People() {
    }

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static int compareTo(People p1, People p2){
        return p1.getAge()-p2.getAge();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}