0
点赞
收藏
分享

微信扫一扫

Java8新特性(一)


目录

​​Java8新特性简介​​

​​一.Lambda表达式​​

                  ​​1.为什么使用Lambda表示式​​

​​2.Lambda表达式​​

                  ​​3.Lambda表达式语法​​

​​二.函数式接口​​

​​1​​​​.java内置四大核心核心函数式接口​​

​​三.方法引用与构造器引用​​

​​1.方法引用​​

​​2.构造器引用​​

​​3. 数组引用​​

​​四.Stream API​​

                  ​​1.了解Stream          ​​

                ​​  2. 什么是Stream         ​​

                  ​​3.stream 的操作的三个步骤        ​​

                  ​​4.创建Stream​​

                 ​​ 5.由数组创建流         ​​

​​6.由值创建流         ​​

​​7.由函数创建流:创建无限流         ​​

​​8.Stream的中间操作         ​​

​​9.Stream的终止操作​​

​​10.并行流和串行流​​

 

Java8新特性简介

          1.速度更快

          2.代码更少(增加了新语法Lambda表达式)

          3.强大的Stream Api

          4.便于并行

          5.最大化减少空指针异常Optional

一.Lambda表达式

      1.为什么使用Lambda表示式

        Lambda是一个匿名函数,我们可以把Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。

        可以写出更简介,更灵活的代码。作为一种更紧凑的代码风格,使用Java的语言表达能力得到提升。

       2.Lambda表达式

          1.从匿名类到Lambda的转换

              

public class java8_4 {


public static void main(String[] args) {

//匿名内部类
Runnable r1 = new Runnable() {

@Override
public void run() {
System.out.println("Hello Lambda!");
}
};

Runnable r2 = () -> {
System.out.println("Hello Lambda!");
};

Thread thread1=new Thread(r1);
thread1.start();

Thread thread2=new Thread(r2);
thread2.start();

}


}









 

 
//原来使用匿名内部类作为参数传递
TreeSet<String> ts=new TreeSet<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return Integer.compare(o1.length(),o2.length());
}
});
//Lambda表达式作为参数传递
TreeSet<String> ts2=new TreeSet<>((o1,o2)-> Integer.compare(o1.length(),o2.length()));

2.Lambda表达式语法

             Lambda表达式在Java语言中引入了一个新的语法元素和操作符。这个操作符为"->",该操作符被称为Lambda操作符或箭头操作符,它将

Lambda分为部分:

             左侧:指定了Lambda表达式需要的所有参数

             右侧:指定了Lambda体,即Lambda表达体要执行的功能

3.Lambda表达式语法

       语法格式一:无参,无返回值,lambda体只需要一条语句

         

  Runnable r4=()-> System.out.println("Hello Lambda!");

       语法格式二:Lambda需要一个参数

   

        Consumer<String> fun=(args)->{System.out.println("Hello Lambda!");}

       语法格式三:Lambda需要一个参数

           

Consumer<String> fun=args->System.out.println(args);

       语法格式四:Lambda需要两个参数,并且有返回值

       

 BinaryOperator<Long> bo=(x,y)->{ System.out.println("实际函数接口方法!"); return x+y; };

     语法格式五:当Lambda体只有一个语句时,return与大括号可以省略     

BinaryOperator<Long> bo=(x,y)->x+y;

     语法格式六:     

    BinaryOperator<Long> bo=(Long x,Longy)->{

System.out.print("实现函数接口方法!");

return x+y;

}

类型推断

       上述Lambda表达式中参数类型都是由编译器推断得出,Lambda表达式中无需指定类型,程序依然可以编译,Lambda表达式中无需指定类型,程序依然

可以编译,这是因为Javac根据程序的上下文,在后台推断出了参数的类型。Lambda表达式的类型依赖于上下文环境,是由编译器推断出来的。这就是所谓的

”类型推断“

 

 

二.函数式接口

什么是函数式接口

      1.只包含一个抽象方法的接口,称为函数式接口。

      2.你可以通过Lambda表达式来创建该接口的对象。(若Lambda表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明)

      3.我们可以在任意函数式接口上使用@FunctionalInterface注解,这样做可以检查它是否是一个函数式接口,同时Javadoc也会包含一条声明,说明这个接口是

一个函数式接口。

    //自定义函数式接口
@FunctionalInterface
public interface MyNumber{

public double getValue();

}

 

//自定义函数式接口
@FunctionalInterface
public interface MyNumber<T>{

public T getValue(T t);

}

 //作为参数传递Lambda表达式

public String toUpperString(MyFunc<String> mf,String str){

return mf.getValue(str);

}

 //作为参数传递Lambda表达式
String newStr=toUpperString( (str)->str.toUpperCase(),"abcdef");

4.java内置四大核心核心函数式接口

       

函数式接口

参数类型

返回类型

用途

Consumer<T> 消费型接口

T

void

对类型为T的对象应用操作,包含方法void accept (T t);

Supplier<T> 供给型接口


T

返回类型为T的对象,包含方法:T get();

Function<T,R>函数型接口

T

R

对类型为T的对象,应用操作,并返回结果。结果是R类型的对象。包含方法R apply(T t);

Predicate<T>断定型接口

T

boolean

确定类型为T的对象是否满足某种约束,并返回boolean值,包含方法boolean test(T t);

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

三.方法引用与构造器引用

1.方法引用

        当要传递给lambda体的操作,已经有实现的方法,可以使用方法引用!
     (实现抽象方法的参数列表,必须与方法引用方法的参数列表保持一致)
       方法引用:使用操作符“::”将方法名和对象的名称分隔开来。
       如下三种主要使用情况:

 

           对象::实例方法
              类::静态方法
              类::实例方案

         例如:(x)->System.out.println(X)
        等同于: System.out::println

        例如:BinaryOperator<Double> bo=(x,y)->Math.pow(x,y);
        等同于:BinaryOperator<Double> bo=Math::pow;
        例如  compare((x,y)->x.equals(y),"abcdef","abcdef");
         等同于: compare(String::equals,"abc","abc");
        注意:当需要引用方法的第一个参数是调用对象,并且第二个参数是需要引用方法的第二参数
      (或无参数)时:ClassName::methodName

2.构造器引用

    格式:ClassName::new 

    与函数式接口相结合,自动与函数式接口中方法兼容。

    可以把构造器引用赋值给定义的方法,与构造器参数列表要与接口中抽象方法的参数列表一致

    例如: Function<Integer,MyClass> fun=(n)->new MyClass(n); 等同于:  Function<Integer,Myclass> fun=MyClass::new;

3. 数组引用

 格式: type[]::new

 例如: Function<Integer,Integer[]> fun=(n)-> new Integer[n];  等同于:Function<Integer,Integer[]> fun=Integer::new;

 

四.Stream API

       1.了解Stream
          

       1.JAVA8中有两大最为重要的改变,第一个lambda表达式, 另外一个则是Stream API(Java.util.stream.*)
       2.Stream是Java8中处理集合的关键的关键抽象概念,它可以指定你希望对集合进行操作,可以执行非常复杂的查找,过滤和映射数据等操作。
       3.使用Stream API对集合数据进行操作,就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作,简而言之,Stream API提供了一种高效且易于使用的处理数据的方式
        

     2. 什么是Stream
         

         流(Stream) 到底是什么呢?
         
        是数据渠道,用于操作数据源(集合,数组等)所生成的元素序列。
        
        “集合讲的是数据,流讲得是计算!”
      
         注意:
         * 1.stream自己不会存储元素
         * 2.stream不会改变源对象,相反,他们会返回一个持有结果的新stream
         * 3.stream操作是延迟执行的,意味着他们会等到需要结果的时候才执行。
        

   3.stream 的操作的三个步骤
        

          创建Stream
         * 一个数据源(如果:集合,数组),获取一个流
         
          中间操作:
         * 一个中间操作链,对数据源的数据进行操作
         
          终止操作:
         * 一个终止操作,执行中间操作链,并产生结果。
         

Java8新特性(一)_函数式接口

4.创建Stream

       

 

         Java8中的collenction接口被扩展,提供两个获取流的方法
         
         * default Stream <E>  stream():返回一个顺序流
         
         * default Stream <E>   parallelStream:返回一个并行流
         

         
 5.由数组创建流
         

          Java8的Arrays的静态方法stream()可以获取数据流
         
          Static <T> stream<T> stream(T[] array):返回一个流
          
          重载形式,能够处理基本类型的数组
         
          public static InStream stream(int[] array)
          public static LongStream stream(long[] array)
          public static DoubleStream stream(double[] array)
         

6.由值创建流
         

 可以使用静态方法stream of(),通过显示值创建一个流,它可以接收任意数量的参数
         

      public static<T> Stream <T> of(T ... valus) 返回一个流

7.由函数创建流:创建无限流
         

  可以使用静态方法stream.iterate()和Stream.generate(),创建无限流。
         * 迭代
          public static <T> Stream<T> iterate(final T seed,final UnaryOperator<T>f)
         
         * 生成
          public static <T> Stream<T> generate(Supplier<T> s);
         

8.Stream的中间操作
         

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

           筛选与切片
         
         * filter(Predicate p)  接收Lambda从流中排除某些元素
         
         * distinct()  筛选,通过流所生成的元素的hashCode和equals去除重复元素
         
         * limit(long maxSize) 截断流,使其元素不会超过给定数量
         
         * skip(long n)  跳过元素,返回一个扔掉了前n个元素的流,若流中元素不足n个,则返回一个空流,与limit(n)互补
         
         映射
         
         * map(function f) 接收一个函数作为其参数,该函数会被应用到每个元素上,并将其映射成一个新的元素
         
         * mapTodouble(ToDoubleFunction f)  接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的DoubleStream
         
         * mapToInt(TOIntFunction f)       接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的LongStream
         
         * flatMap(Function f)          接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流
        
        
         排序
         
         * sorted () 产生一个新流,其中按自然顺序比较
         
         * Sorted(Comparator comp) 产生一个心流,其中按比较器顺序排序
         
         * Stream的终止操作
         
         * 终端操作会从流的流水线生成结果

 

9.Stream的终止操作

       

        终端操作会从流的流水线生成结果。其结果可以是任何不是流的值,例如:List,Integer,甚至是void。

        查找与匹配

        

方法

描述

allMatch(predicate p)

检查是否匹配所有元素

anyMatch(predicate p)

检查是否至少匹配一个元素

noneMatch

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

findfirst()

返回第一个元素

findAny()

返回当前流中的任意元素

 

方法

描述

count

返回流中元素总数

max(Comparator c)

返回流中最大值

min(Comparator c)

返回流中最小值

forEach(Consumer c)

内部迭代(使用Collection接口需要用户去做迭代,称为外部迭代。相反,Stream API使用内部迭代---他帮你把迭代做了)

归约

                                                                                                       

reduce(T iden,BinaryOperator b)

可以将流中元素反复结合起来,得到一个值返回T

reduce(BinaryOperate b)

可以将流中的元素反复结合起来,得到一个值返回Optional<T>

 map和reduce的链接通常称为map-reduce模式

 

                                                                                                                   收集

方法

描述

collect(Collector c)

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

                                                                                                               Collector接口中方法的实现决定了如何对流执行收集操作(如收集到List,set,Map)。但是Collector实用类提供了很多静态方法

                                                                                                              可以方便的创建常见收集器实例,具体方法与实例如下表:

 

方法

返回类型

作用

toList

List<T>

把流中元素收集到List

List<Employee>emps=list.stream().collect(Collectors.toList());

 

 

toSet

Set<T>

把流中元素收集到创建的集合

Set<Employee> emps=list.stream().collect(Collectors.toSet());

 

 

toCllection

Collection<T>

;;把流中元素收集到创建的集合

Collection<Employee> emps=list.stream().collect(Collectors.toCollection(ArraysList::new));

 

 

counting

Long

计算流中元素个数

long count=lits.stream().collect(Collectors.counting());

 

 

summingInt

Integer

对流中元素的整数属性求和

inttotal=list.stream().collect(Collctors.summingInt(Employee::getSalary));

 

 

averagingInt

Double

计算流中元素Integer属性的平均值

doubleavg=list.stream().collect(Collectors.averaginInt(Employee::getSalary));

 

 

summarizingInt

IntSummaryStatistics

收集流中Integer属性的统计值

如:平均值

 

IntSummaryStatisticsisss=list.stream().collect(Collectors.summarizingInt(Employ::getSalary))

 

 

joining

String

连接流中每个字符串

string str=list.stream().map(Employee::getName).collect(Collectors.joining());

 

 

maxBy

Optional<T>

根据比较器选择最大值

Optional<Emp> max=list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary)));

 

 

minBy

Optional<T>

根据比较器选择最小值

Optional<Emp> min=list.stream().collect(Collectors.minBy(comparingInt))

 

 

reducing

归约产生的类型

从一个作为累加器的初始值开始利用BinaryOperator

与流中元素逐个结合,从而归约成单个值

inttoal=list.stream().collect(Collectors,reducing(0,Employee::getSalar,Integer::sum));

 

 

collectingAndThen

转换函数返回的类型

包裹另一个收集器,对其结果转换函数

inttoal=list.stream().collect(Collectors,collectingAndThen(Collectors.toList,List::size));

 

 

groupingBy

Map<K,List<T>>

根据某属性值对流分组,属性为K,结果为V

Map<Emp.Status,List<Emp>> map=list.stream().collect(Collectoes.groupingBy(Employee::getStatus));

 

 

partitioningBy

Map<Boolean,List<T>>

根据true或false进行分区

Map<Boolan,List<Emp>> vd=list.stream().collect(Collectors.partitioningBy(Employee::getManage));

 

10.并行流和串行流

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

        Java8中将并行进行了优化,我们可以很容易的对数据进行并行操作,Stream API可以声明性得通过parallel()与sequential()在并行流与顺序流之间进行切换

 

 

 

 

 

 

                                                                                                                

    

举报

相关推荐

Java8新特性

java8新特性

java8新特性学习(一)

java8 新特性

Java8 新特性讲解

【Java8的新特性】

Java8新特性全面

0 条评论