Lambda表达式

Lambda表达式

  • 利用Lambda可以更简洁的实现匿名内部类与函数声明与调用
  • 基于Lambda提供stream流式处理极大简化对集合的操作
package com.pro.Lambda;

/**
 * 四则运算
 */
 @FunctionalInterface //通知编译器这是函数式接口,进行抽象方法检查
public interface MathOperation {
    public Float operate(Integer a, Integer b);
}

package com.pro.Lambda;

/**
 * 更简洁的实现匿名内部类与函数声明与调用
 */
public class LambdaSample {
    //约束条件:Lambda表达式只能实现有且只有一个抽象方法的接口,Java称为“函数式接口”
    public static void main(String[] args) {
        //1.标准Lambda使用方式
        MathOperation addtion = (Integer a, Integer b) -> {
            System.out.println("加法运算");
            return a + b + 0f;
        };
        System.out.println(addtion.operate(5, 3));

        //2.Lambda允许忽略参数类型
        MathOperation substraction = (a, b) -> {
            System.out.println("减法运算");
            return a - b + 0f;
        };
        System.out.println(substraction.operate(5,3));

        //3.单行实现代码可以省略大括号和return
        MathOperation multiplication = (a,b)->a*b+0f;
        System.out.println("乘法运算");
        System.out.println(multiplication.operate(5,3));

        MathOperation division = (a, b) -> {
            System.out.println("除法运算");
            return a / b + 0f;
        };
        System.out.println(division.operate(6, 3));
    }
}

在这里插入图片描述

函数式编程与接口

  • 函数式编程是基于函数式接口并使用lambda表达的编程方式,是将代码作为可重用数据代入到程序中
  • 函数式接口时有且只有一个抽象方法的接口,Java中有大量的函数式接口,如java.lang.Runnable、java.util.function

下面主要说明一下几个常用函数式接口

Predicate函数式接口
  • Predicate用于测试传入的数据是否满足判断要求,需要实现test()方法进行逻辑判断
package com.pro.Lambda;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/**
 * 理解函数式编程
 * Predicate函数式接口的使用方法
 */
public class PredicateSample {
    public static void main(String[] args) {
        Predicate<Integer> predicate = n -> n > 4;
        boolean flag = predicate.test(10);
        System.out.println(flag);
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        //将数组与列表链接起来,当更新其中之一时,另一个自动更新
//        for (Integer num : list) {//求出奇数
//            if (num % 2 == 1) {
//                System.out.println(num);
//            }
//        }
        filter(list,n->n%2==1);//取所有奇数
        filter(list, n -> n % 2 == 0);//取所有偶数
        filter(list, n -> n > 5 && n % 2 == 0);//取出大于5的偶数
    }

    public static void filter(List<Integer> list, Predicate<Integer> predicate) {
        for (Integer num : list) {
            if (predicate.test(num)) {
                System.out.print(num +" ");
            }
        }
        System.out.println();
    }
}

在这里插入图片描述

package com.pro.Lambda;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/**
 * Predicate函数式接口的使用方法
 * 查找字符串集合中包含字符‘a’的元素
 */
public class PredicateSample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("java", "python", "php", "HTML");
        //将数组与列表链接起来,当更新其中之一时,另一个自动更新
        filter(list,n->n.indexOf('a')!=-1);
    }

    public static void filter(List<String> list, Predicate<String> predicate) {
        for (String num : list) {
            if (predicate.test(num)) {
                System.out.print(num+" ");
            }
        }
        System.out.println();
    }
}

在这里插入图片描述

Consumer函数式接口
  • Consumer对应有一个输入参数无输出的功能代码
package com.pro.Lambda;

import java.sql.SQLOutput;
import java.util.function.Consumer;

/**
 * Consumer接口的使用
 */
public class ConsumerSample {
    public static void main(String[] args) {
        output(s-> System.out.println("向控制台打印:"+s));
    }

    public static void output(Consumer<String> consumer) {
        String text = "我是一串字符串";
        consumer.accept(text);
        
    }

}

在这里插入图片描述

Function函数式接口
  • Function对应有一个输入参数且需要返回数据的功能代码
package com.pro.Lambda;

import java.util.Random;
import java.util.function.Function;

/**
 * 利用Function函数式接口生成定长随机字符串
 */
public class FunctionSample {
    public static void main(String[] args) {
        Function<Integer, String> randomStringFunciton = l -> {
            String chars = "abcdefghijklmnopqrstuvxwyz0123456789";
            StringBuffer stringBuffer = new StringBuffer();
            Random random = new Random();
            for (int i = 0; i < l; i++) {
                int position = random.nextInt(chars.length());
                stringBuffer.append(chars.charAt(position));
            }
            return stringBuffer.toString();
        };
        String randomString = randomStringFunciton.apply(16);
        System.out.println(randomString);

    }

}

在这里插入图片描述

Stream流式处理

  • Stream流式处理是建立在Lambda基础上的多数据处理技术
  • Stream对集合数据处理进行高度抽象,极大简化代码量
  • Stream可对集合进行迭代,去重,筛选,排序,聚合等一系列的处理

Stream流五种创建方式

package com.pro.stream;

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * Stream 流对象的五种创建方式
 */
public class StreamGenerator {
    //1.基于数组进行创建
    @Test
    public void generator1() {
        String[] arr ={"Lily","Andy","Jackson","Smith"};
        Stream<String> stream = Stream.of(arr);//针对传入数组进行解析生成Stream对象
        stream.forEach(s -> System.out.println(s));//循环遍历
    }
    //2.基于集合进行创建
    @Test
    public void generator2() {
        List<String> list = new ArrayList<>();
        list.add("Lily");
        list.add("Andy");
        list.add("Jackson");
        list.add("Smith");
        Stream<String> stream = list.stream();//list自带的方法获取Stream对象
        stream.forEach(s -> System.out.println(s));
    }

    //3.利用generate方法创建无限长度流
    @Test
    public void generator3() {
        Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(100000));
        //无限长度的随机整数数据流
        stream.limit(10).forEach(i -> System.out.println(i));
        //limit指定数量
    }

    //4.基于迭代器创建流
    @Test
    public void generator4() {
        Stream<Integer> stream = Stream.iterate(1, n -> n + 1);
        //参数一:起始的数据,参数二:循环的步长
        stream.limit(100).forEach(i -> System.out.println(i));
    }

    //5.基于字符序列创建流
    public void generator5() {
        String str = "abcdefg";
        IntStream stream = str.chars();//每一个Stream中都是整数
        stream.forEach(c -> System.out.println((char) c));
    }
}

Stream常用的方法

接口说明
forEach循环遍历
map映射每一个元素到对应的结果
filter通过设置的条件过滤出元素
limit用于获取指定数量的流
sorted用于对流进行排序
Collectors实现将流转换成集合和聚合元素
package com.pro.stream;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class StreamMethod {
    //提取集合中所有偶数并求和
    @Test
    public void case1() {
        List<String> list = Arrays.asList("1", "2", "3", "4", "5");
        int sum = list.stream()//获取stream对象
                .mapToInt(s -> Integer.parseInt(s)) //mapToInt将流中每一个数据转为整数
                .filter(n -> n % 2 == 0) //filter对流数据进行过滤
                .sum();//求和
        System.out.println(sum);
    }
    //所有名字首字母大写
    @Test
    public void case2() {
        List<String> list = Arrays.asList("lily", "smith", "jackson");
        List newList = list.stream()
                .map(s -> s.substring(0, 1).toUpperCase() + s.substring(1)) //对流中的数据进行相应的转换
                //.forEach(s -> System.out.println(s));//打印输出
                .collect(Collectors.toList());//将数据包装成集合返回
        System.out.println(newList);
    }

    //将所有奇数从大到小进行排序,且不许出现重复
    @Test
    public void case3() {
        List<Integer> list = Arrays.asList(1, 60, 38, 21, 51, 60, 51, 73);
        List newList = list.stream().distinct() //distinct去除重复的流数据
                .filter(n->n%2==1)
                .sorted((a,b)->b-a) //流数据排序
                .collect(Collectors.toList());
        System.out.println(newList);

    }

}

在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值