Java--lambda&Stream

目录

出现的背景

Lambda表达式的简介

Lambda表达式的结构

功能接口

Stream

获取流

流操作


出现的背景

java是面向对象的语言,向方法传递参数不能是单个函数

sort需要一个比较的函数,只能创建一个对象,将方法包装在对象中传递可以通过创建匿名内部类对象,将比较函数包装起来

java8之后为了再次简化语法,推出lambda语言

lambda就是一个匿名函数,简化匿名内部类语法,以后可以将匿名函数当作参数传递,由Java根据语言进行推断,补全常规代码

public class Demo1 {
    public static void main(String[] args) {
       ArrayList list=new ArrayList();
       list.sort(new Comparator() {
           @Override
           public int compare(Object o1, Object o2) {
               return 0;
           }
       });
    }
}

Lambda表达式的简介

lambda表达式是一个匿名函数,可以理解为将代码像数据一样传递,使得Java语言的白哦大能力得到提升,其本质是一个“语法糖

语法糖:通过较少的代码实现较多的功能,指计算机语言中添加的某种语法,这种语法对计算机语言功能并没有影响,但是更方便程序员使用

使用lambda表达式接口中,只能有一个抽象方法,因为需要自动类型推断

public class TestCar {
    public static void main(String[] args) {
        Car car1=new Car("宝马", 101);
        Car car2=new Car("奥迪", 102);
        Car car3=new Car("奔驰", 103);
        Car car4=new Car("法拉利", 104);

        Car[]cars={car2,car4,car1,car3};
         //对 Car对象进行排序
        // 匿名内部类写法
//        Arrays.sort(cars, new Comparator<Car>() {
//            @Override
//            public int compare(Car o1, Car o2) {
//                return 0;
//            }
//        });
        //将匿名内部类用lambda语法简化
        Arrays.sort(cars,(c1,c2)->{
            return c1.getNo()-c2.getNo();
        });
        System.out.println(Arrays.toString(cars));
        //(a)->{
        //asdcj
        //}
    }
}

Lambda表达式的结构

1.lambda表达式可以具有0个,1个或多个参数

2.可以显示声明参数类型,也可以由编译器自动从上下文推断参数的类型。eg:(int a,int b)和(a,b)相同

3.参数用小括号括起来,用逗号分隔。eg:(a,b)或(int a,int b)或(String a,int b,float c)

空括号用于表示一组空的参数,eg:()->32

4.当有且仅有一个参数时,如果不显示指明类型,则不必使用小括号。eg:a->return a*a

5.Lambda表达式的正文可以包含零条,一条或多条语句

6.如果Lambda表达式的正文可以包含零条,一条或多条语句

7.如果Lambda表达式的正文只有一条语句,则大括号可不用写,且表达式的返回值类型要与匿名函数的返回类型相同

8.如果Lambda表达式的正文有一条以上的语句必须包含在大括号(代码块)中,且表达式返回值类型要与匿名函数的返回类型相同

无参数,无返回值,lambda 体中只有一行代码时,{}可以忽略
() -> System.out.println("Hello World");

无参数,有返回值
() -> { return 3.1415 };

有参数,无返回值
(String s) -> { System.out.println(s); }

有一个参数,无返回值
s -> { System.out.println(s); }

有多个参数,有返回值
(int a, int b) -> { return a + b; }

有多个参数,表达式参数类型可以不写,jvm 可以根据上下文进行类型推断
(a, b) -> { return a - b; }

功能接口

@FunctionalInterface//表示是一个功能函数接口,接口中只能定义一个抽象方法
public interface Oper {
    //使用lambda表达式接口中,只能有一个抽象方法,因为需要自动类型推断
    //void show();
    int add(int a,int b);

    //void show1();

}
public class TestOper {

    public void test(Oper oper){
        //oper.show();
        oper.add(2,5);
    }

    public static void main(String[] args) {
        TestOper testOper=new TestOper();
//        testOper.test(()->{
//            System.out.println("aaaaaaaaaaa");
//            System.out.println("aaaaaaaaaaa");
//        });


        testOper.test((a,b)->{return a+b; });

        new Thread(()->{
            for (int i = 0; i <1000 ; i++) {

            }
        }).start();


        System.out.println("显示信息");
       // testOper.test(( a, b)->{return });




    }

//    public interface Oper{
//        void area(int a,int b);
//    }
// Shape d=(a,b)->{
//     System.out.println(a+b);
// };
//    d.area(1,2);
}

Stream

什么是Stream?

Stream流是Java8新推出的功能,与IO流完全不同的,提供对象数据集合进行操作的各种方法,我们只需要声明式的告诉其应该作什么,Java中的集合,数组主要是存储数据,而Stream主要作用是对集合进行操作。

流就是“从支持数据处理操作的源,生成的元素序列”。
元素列表:和集合一样,流也提供了一个接口,访问特定元素类型的一组有序值。
数据源 :获取数据的源,比如集合。
数据处理操作 :流更偏向于数据处理和计算,比如 filter、map、find、sort 等。
简单来说,我们通过一个集合的 stream 方法获取一个流,然后对流进行一
系列流操作,最后再构建成我们需要的数据集合。

数据集合--Stream--filter--Stream--sorted--Stream--tolist/sum/max/min--result

就是一个集合进行便利操作的高端迭代器

public class Demo {
    public static void main(String[] args) {
        Integer[]array={4,3,2,5,6,1,7,1,2};
        Arrays.stream(array)
                .filter((e)->{ return e<7 ;})//过滤
                .sorted((a,b)->{return a-b;})//排序
                .distinct()//去重
                .skip(3)//跳过
                .limit(3)//限制
                .forEach((e)->//终端操作
                 System.out.println(e));
 public static void main(String[] args) {
        ArrayList<Apple> applestore = new ArrayList();
        applestore.add( Apple1("red",500,"河南"));
        applestore.add( Apple2("red",400,"陕西"));
        applestore.add( Apple3("green",300,"上海"));
        applestore.add( Apple4("green",200,"湖北"));
        applestore.add( Apple5("green",100,"湖南"));}

获取流

使用 Collection 接口下的 stream()
List<String> list = new ArrayList<>(); 
Stream<String> stream = list.stream();
使用 Arrays 中的 stream() 方法,将数组转成流
Integer[] nums = new Integer[10]; 
Stream<Integer> stream = Arrays.stream(nums);
使用 Stream 中的静态方法:of()
Stream<Integer> stream = Stream.of(1,2,3,4,5,6);

使用 BufferedReader.lines() 方法,将每行内容转成流

BufferedReader reader=new BufferedReader(new FileReader("stream.txt")); 
Stream<String> lineStream = reader.lines();

流操作

List<Apple> apples = applestore .stream() 获得流 
 filter(a -> a.getColor().equals("red")) 中间操作 
 collect(Collectors.toList()); 终端操作

数据源=>中间操作=>终端操作=>结果

中间操作

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

        Integer[]array={4,3,2,5,6,1,7,1,2};
        Arrays.stream(array)
                .filter((e)->{ return e<7 ;})//过滤
                .sorted((a,b)->{return a-b;})//排序
                .distinct()//去重
                .skip(3)//跳过n个元素
                .limit(3)//获取元素
                .map():将其映射成一个新的元素
                .forEach((e)->//终端操作
                        System.out.println(e));
//        Stream.of();
//        ArrayList list=new ArrayList();
//        list.add(1);
//        list.stream();

    }
}

终端操作

//  forEach:遍历流中的元素
//  toArray:将流中的元素倒入一个数组
//  Min:返回流中元素最小值
//  Max:返回流中元素最大值
//  count:返回流中元素的总个数
//  Reduce:所有元素求和
//  anyMatch:接收一个 Predicate 函数,只要流中有一个元素满足条件则返 回 true,否则返回false 
//  allMatch:接收一个 Predicate 函数,当流中每个元素都符合条件时才返 回 true,否则返回false //  findFirst:返回流中第一个元素
//  collect:将流中的元素倒入一个集合,Collection 或 Map

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值