0
点赞
收藏
分享

微信扫一扫

Java8新特性(一)

小_北_爸 2022-07-27 阅读 66
lambdastreamlambda表达式函数式接口javaOpenStack云计算


目录

​​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新特性

java开发语言

Java8新特性

日记本javaJava

Java8 新特性

数据函数式接口java虚拟化云计算

java8新特性学习（一）

p2plinqhtml

JAVA8新特性

javalambda表达式四大函数接口流式计算LombokJava后端开发yyds干货盘点

java8 新特性

java开发语言后端

java8 新特性Stream

json数组数据源Linux系统/运维

Java8新特性全面

java

Java8 新特性讲解

java开发语言

十七：Java8新特性

java开发语言
0 条评论