CoreJava学习第十六课-JDK8中Lambda表达式和Stream编程

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了CoreJava学习第十六课-JDK8中Lambda表达式和Stream编程，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6319字，纯文字阅读大概需要10分钟。

内容图文

Lambda表达式

从JDK8 Lambda表达式开始，java成为面向对象编程思想+函数式编程思想

避免冗余代码, 提高程序的可重用性
提高可重用性: 将代码的不变部分, 和可变部分 分离
继承关系
将子类共性抽取到父类
将数据作为方法的参数
将代码作为方法的参数? 定义接口,通过接口回调实现
Lambda : 函数式编程

Lambda表达式 ?匿名内部类的简便写法 ?实现的接口必须只有一个抽象方法  (函数式接口)
语法: 
1.  (参数表)->{代码块}
2.  (参数表)-> 表达式(只有一句代码时)
?
参数表中形参的类型可以省略, 由编译器自动推断
如果参数表只有一个参数,()可以省略
public class TestLambda2 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("Yangdd",48,60));
        //list.add...
        
        findStu(list, new Predicates() {
            public boolean test(Student s) {
                return s.getAge()==18;//写接口，都是为这句代码服务的
            }
        });
        //简化
        findStu(list, (Student s) -> s.getAge()==18 );
        //进一步简化
        findStu(list, s->s.getAge()==30);//如果参数表只有一个参数,()可以省略
    }
    static List<Student> findStu(List<Student> list ,Predicates p){
        List<Student> result = new ArrayList<Student>();
        for(Student s:list){
            boolean b = p.test(s);
            if (b) result.add(s);
        }
        return result;
    }
}
interface Predicates{
    public boolean test(Student s);
}

//以下都是lambda表达式写法
Runnable r= new Runnable(){
 ? ?public void run(){
 ? ? ? ?System.out.println("hehe");
 ?  }
};
Runnable r = ()->{System.out.println("hehe");};
?
Callable<Integer> c = new Callable<Integer>(){
 ? ?public Integer call(){
 ? ? ? ?return 10;
 ?  }
}
Callable<Integer> c = ()->10;

方法引用
public class TestMethodLambda {
    public static void main(String[] args) {
        A a = new A(){
            public void act(MyClass mc) {
                mc.method();
            }
        };
        A a2 = (MyClass mc)->mc.method();
        A a3 = MyClass::method;
        
        B b = new B() {
            public void act(MyClass mc , String s) {
                mc.method(s);
            }
        };
        B b2 = (MyClass mc , String s)->mc.method(s);
        B b3 = MyClass::method;
        
        C c2 = (MyClass mc,String s1,String s2)->mc.method(s1, s2);
        C c3 = MyClass::method;
        
        D d2 = ()->MyClass.staticMethod();
        D d3 = MyClass::staticMethod;
        
        E e2 = (s)->System.out.println(s);
        E e3 = System.out::println;
    }
}
?
interface A{
    void act(MyClass mc);
}
interface B{
    void act(MyClass mc , String s);
}
interface C{
    void act(MyClass mc , String s1 , String s2);
}
interface D{
    void act();
}
interface E{
    void act(String s);
}
?
class MyClass{
    public void method() {
        System.out.println("method()");
    }
    public void method(String s) {
        System.out.println("method(String)");
    }
    public void method(String s , String s2) {
        System.out.println("method(String,String)");
    }
    
    public static void staticMethod() {
        System.out.println("Static Method");
    }
}

构造方法引用
 ? ? ?  ()->new Teacher();
 ? ? ? ?Teacher::new
 ? ? ? ? ? ?
 ? ? ?  (int a)->new Teacher(a);
 ? ? ? ?Teacher::new
 ? ? ? ? ? ?
 ? ? ?  (String s)->new Teacher(s);
     ? ?Teacher::new
 ? ? ? ? ? ?
 ? ? ?  (int a, String s)->new Teacher(a,s);
 ? ? ? ?Teacher::new

?

JDK8对集合的遍历

接口的新语法:
    接口中可以定义默认方法? default void print(){} --->since JDK8
    接口中可以定义静态方法? static void print(){}?? --->since JDK8
    接口中可以定义私有方法?? since JDK9

函数式接口: 函数描述符

接口名，方法名不重要；方法参数和返回值重要

• Runnable    ()-> Void

• Callable    ()-> T

Stream  函数式数据处理

集合: 负责数据的存储

Stream: 处理集合中数据的运算

获得Stream<T>
   来自Collection?? stream(): 获得单线程的Stream
   来自Collection?? parallelStream():获得并发的Stream //底层用fork-join实现
   来自Arrays.stream(T[])??? 返回值Stream<T>
   来自Files.lines(Path)?? Stream<String>? 读取文本文件,并把每行文本放入Stream<String>
   注：Map没有stream()方法

Stream<String> s = Files.lines(Paths.get("a.txt")); ? 处理英文
Stream<String> s = Files.lines(Paths.get("a.txt") , Charset.forName("GBK")); ?处理中文

中间操作

java.util.stream包下，Stream类中，方法的返回值还是stream的都是中间操作

收集操作/终端操作

java.util.stream包下，Stream类中，方法的返回值不是stream的

收集器 Collector<T,A,R>

T:流中的元素类型

R:收集之后的结果类型

Collectors 直接获得Collector

Collectors的方法返回值是一个Collector, Collector的第三泛型才是collect方法的返回值

原始流特化

IntStream  LongStream  DoubleStream

获得原始特化流的方法:
Stream<T>? 调用? mapToInt(T->int)
IntStream.range(a,b)??? a ---> b-1
IntStream.rangeClosed(a,b)? a--->b
IntStream.generate(()->int ) 由函数生成每个元素
IntStream.iterate(a,int->int) 第一个元素是a,利用函数,通过前一个元迭代计算后一个元素

方法:
average()? OptionalDouble?? 求平均数
sum() int?? 求和
boxed() Stream<Integer>

内容总结

以上是互联网集市为您收集整理的CoreJava学习第十六课-JDK8中Lambda表达式和Stream编程全部内容，希望文章能够帮你解决CoreJava学习第十六课-JDK8中Lambda表达式和Stream编程所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端