JDK1.8新特性

目录

一.序言

二.JDK1.8新特性

3.1Lambda表达式

3.2Functional表达式

3.3方法引用和构造器引用

构造器引用

3.4.Stream API

3.5.Optional类

---

一.序言

Java8（又称为jdk1.8）是Java语言开发的一个主要版本。
Java8是oracle公司2014年3月发布，可以看成是自Java5以来最具革命性的更新 。Java8为java语言，编译器，类库，，开发工具与jvm带来了大量新特性。

二.JDK1.8新特性

1.Lambda表达式

2.Functional表达式

3.方法引用和构造器引用

4.Stream API

5.Optional类

3.1Lambda表达式

1.举例：（o1,o2）-> Integer.compare(o1,o2);

2.格式：lambda形参列表  lambda操作符 lambda体

3.Lambda表达式的使用（6种）

这些抽象类或者接口都只有一个抽象方法

语法一：无参，无返回值

 @Test
public void test1(){
  Runnable r2 = () -> {System.out.println("韩金龙");}；
  r2.run();
}

语法二：有一个参数，没有返回值

@Test
    public void test2(){
 Consumer<String> con1 = (String s) -> {System.out.println(s);};
        con1.accept("韩金龙");
}

语法三：数据类型可以省略，因为可以有编译器推断而出，称为“类型推断”

@Test
    public void test3(){
        Consumer<String> con1 = ( s) -> {System.out.println(s);};
        con1.accept("韩金龙");

    }

语法四：如果只有一个参数，小括号可以省略

@Test
    public void test3(){
        Consumer<String> con1 =  s -> {System.out.println(s);};
        con1.accept("韩金龙");

    }

语法五：Lambda有两个或两个以上的参数，多条执行语句，并且有返回值

 @Test
    public void test4(){
Comparator<Integer> com1 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        com1.compare(6,9);
        System.out.println(com1.compare(6,9));
}

语法六：如果Lambda体只有一条语句时，return与大括号都可以省略（必须一起省略）

 @Test
    public void test5(){

        Comparator<Integer> com = (o1, o2) -> o1.compareTo(o2);
        System.out.println(com.compare(7,8));
                
    }

总结：->左边的形参列表的参数类型可以省略（类型推断），如果只有一个形参，括号也可以省略

           ->右边：lambda体要用{}包裹。如果只有一句执行语句，可以省略return和{}

4.Lambda的实质：作为接口的实例

3.2Functional表达式

只含有一个抽象方法的接口称为函数式接口

所有函数式接口都可以用Lambda来表示

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

public class FunctionalTest {
    @Test
    public void test(){
        List<String> list = Arrays.asList("北京","天津","南京","东京");
        List<String> list1 =testList(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println(list1);

        List<String> list2 = testList(list,s ->  s.contains("京"));
        System.out.println(list2);

    }

    public ArrayList<String> testList(List<String> list, Predicate<String> pre){
        ArrayList<String> al = new ArrayList<>();
        for (String s:list) {
            if (pre.test(s)){
                al.add(s);
            }
        }
        return al;
    }
}

3.3方法引用和构造器引用

使用情景：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用

方法引用本质上是就是Lambda表达式，而Lambda表达式作为函数接口的实例，所以方法引用也是函数式接口的实例

使用格式： 类（对象）：：方法名

具体有三种情况：

1.对象：：非静态方法

2.类：：静态方法

3：类：：非静态方法

情况一：对象：：实例方法

@Test
    public void test(){
        Consumer<String> con = str -> System.out.println(str);
        con.accept("芜湖起飞");
        System.out.println("=============================");
        PrintStream ps = System.out;
        Consumer<String> con1 = System.out::println;
        con1.accept("韩金龙");

    }

情况二：类：：静态方法

@Test
    public void test1(){
        Comparator<Integer> com = Integer::compare;
        System.out.println(com.compare(10,15));
    }

情况三：类：：非静态方法

 @Test
    public void test2(){
        Comparator<String> com = String::compareTo;
        System.out.println(com.compare("a","b"));
    }

构造器引用

和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致，抽象方法的返回值即为构造器所属的类的类型。

public void test(){
 Supplier<Employee> sup = Employee::new;
System.out.println(sup.get())
}

3.4.Stream API

1.Stream关注的是对数据的原酸，与cpu有关

集合关注的是数据的存储，与内存有关

2.Stream自己不会存储数据

Stream不会改变源对象。相反，它会返回一个持有结果的新Stream

Stream是有延迟的，只有需要结果时才执行

3.Stream的三个操作步骤

1.创建Stream

通过集合

通过数组

通过Stream的of（）

创建无限流：iterate（迭代）和generate（生成）

2.中间操作（过滤,映射····）

筛选与切片：filter(predicate p)-----接收Lambda，从流中排除某些元素

limit（n）-----截断流，使其元素不超过n

skip（n）------跳过元素，返回一个扔掉了前n个元素的流，若流中元素不满足n个，则返回一个空流。

distinct()------筛选，通过流生成的元素的hashCode（）和equals（）方法去重

映射：

排序

3.终止操作：一旦执行终止操作，就会执行中间操作链，并产生结果，之后不会再被使用

3.5.Optional类

Optional<T>类是一个容器类，代表一个值存在或不存在，原来用null表示一个值不存在，现在Optional可以更好的表达这个概念。并且可以避免空指针异常。

常用方法：

Optional.of(T t) : 创建一个Optional实例；

Optional.empty() : 创建一个空的Optional实例；

Optional.ofNullable(T t) :若t不为空创建一个Optional实例否则创建一个空实例；

isPresent() : 判断是否包含值；

orElse(T t) ：如果调用对象包含值，返回该值，否则返回t；

orElseGet(Supplier s) : 如果调用对象包含值，返回该值，否则返回s获取的值；

map（Function f） ： 如果有值对其处理，并返回处理后的Optional，否则返回Optional.empty();

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