• java8函数式编程，常用高阶函数处理

    jdk1.8引入了Lombda表达式，函数式编程，帮我大大减少了代码的重复性，和代码的复杂度，更优雅的处理我们代码和方法，也能帮我业务数据做处理。

    函数接口：

    函数接口指仅具有单个抽象方法的接口，用来表示 Lambda 表达式的类型。

    是惰性求值还是及早求值很简单：只需看它的返回值。如果返回值是 Stream， 那么是惰性求值；如果返回值是另一个值或为空，那么就是及早求值。

    通过构建建筑者模式构建数据：

    1. package com.example.java8.employees;
    2.  
    3. import java.util.List;
    4. import java.util.Objects;
    5.  
    6. /**
    7.  * 使用建造者模式创建对象：
    8.  * 1，对象在赋值过后进行bulider创建对象
    9.  *2，多线程里面对象他是线程安全，类this指向
    10.  * @author xpwi
    11.  * @since 2022-08-14
    12.  */
    13. public class EmployeesVO {
    14.  
    15.     /**
    16.      * id 编号
    17.      */
    18.     private int id;
    19.  
    20.     /**
    21.      * 姓名
    22.      */
    23.     private String name;
    24.     /**
    25.      * 性别
    26.      */
    27.     private Integer gender;
    28.  
    29.     /**
    30.      * 年龄
    31.      */
    32.     private Integer age;
    33.  
    34.     /**
    35.      * 信息
    36.      */
    37.     private String msg;
    38.  
    39.  
    40.     private List result;
    41.  
    42.     public EmployeesVO(Bulider bulider){
    43.         this.id = bulider.id;
    44.         this.name = bulider.name;
    45.         this.age = bulider.age;
    46.         this.gender = bulider.gender;
    47.         this.msg = bulider.msg;
    48.         this.result=bulider.result;
    49.  
    50.     }
    51.  
    52.  
    53.     public int getId() {
    54.         return id;
    55.     }
    56.  
    57.     public void setId(int id) {
    58.         this.id = id;
    59.     }
    60.  
    61.     public String getName() {
    62.         return name;
    63.     }
    64.  
    65.     public void setName(String name) {
    66.         this.name = name;
    67.     }
    68.  
    69.     public Integer getGender() {
    70.         return gender;
    71.     }
    72.  
    73.     public void setGender(Integer gender) {
    74.         this.gender = gender;
    75.     }
    76.  
    77.     public Integer getAge() {
    78.         return age;
    79.     }
    80.  
    81.     public void setAge(Integer age) {
    82.         this.age = age;
    83.     }
    84.  
    85.     public String getMsg() {
    86.         return msg;
    87.     }
    88.  
    89.     public void setMsg(String msg) {
    90.         this.msg = msg;
    91.     }
    92.  
    93.     public List getResult() {
    94.         return result;
    95.     }
    96.  
    97.     public void setResult(List result) {
    98.         this.result = result;
    99.     }
    100.  
    101.     /**
    102.      * 工厂
    103.      *
    104.      */
    105.     public  static class  Bulider{
    106.         /**
    107.          * id 编号
    108.          */
    109.         private int id;
    110.  
    111.         /**
    112.          * 姓名
    113.          */
    114.         private String name;
    115.         /**
    116.          * 性别
    117.          */
    118.         private Integer gender;
    119.  
    120.         /**
    121.          * 年龄
    122.          */
    123.         private Integer age;
    124.  
    125.         /**
    126.          * 信息
    127.          */
    128.         private String msg;
    129.  
    130.  
    131.         private List result;
    132.  
    133.         public Bulider(int id, String name, Integer gender, Integer age, String msg,List result) {
    134.             this.id = id;
    135.             this.name = name;
    136.             this.gender = gender;
    137.             this.age = age;
    138.             this.msg = msg;
    139.             this.result = result;
    140.         }
    141.  
    142.         public Bulider id(int id){
    143.             this.id=id;
    144.             return this;
    145.         }
    146.         public Bulider name(String name){
    147.             this.name=name;
    148.             return this;
    149.         }
    150.         public Bulider name(Integer gender){
    151.             this.gender=gender;
    152.             return this;
    153.         }
    154.         public Bulider age(Integer age){
    155.             this.age=gender;
    156.             return this;
    157.         }
    158.         public Bulider age(String  msg){
    159.             this.msg=msg;
    160.             return this;
    161.         }
    162.         public Bulider result(List result){
    163.             this.result=result;
    164.             return this;
    165.         }
    166.         /**
    167.          * this指向赋值this
    168.          * @return
    169.          */
    170.         public EmployeesVO bulider(){
    171.             return new EmployeesVO(this);
    172.         }
    173.  
    174.     }
    175.  
    176.     @Override
    177.     public boolean equals(Object o) {
    178.         if (this == o) return true;
    179.         if (o == null || getClass() != o.getClass()) return false;
    180.         EmployeesVO that = (EmployeesVO) o;
    181.         return id == that.id &&
    182.                 Objects.equals(name, that.name) &&
    183.                 Objects.equals(gender, that.gender) &&
    184.                 Objects.equals(age, that.age) &&
    185.                 Objects.equals(msg, that.msg) &&
    186.                 Objects.equals(result, that.result);
    187.     }
    188.  
    189.     @Override
    190.     public int hashCode() {
    191.         return Objects.hash(id, name, gender, age, msg, result);
    192.     }
    193. }

    测试类：

    1. package com.example.java8.employees;
    2.  
    3. import java.util.*;
    4. import java.util.stream.Collectors;
    5.  
    6. /**
    7.  * 
    8.  *
    9.  * @author xpwi
    10.  * @since 2022-08-14
    11.  */
    12. public class TestJava8 {
    13.  
    14.     public static List oldList = new ArrayList<>();
    15.     public static List newList = new ArrayList<>();
    16.  
    17.     static {
    18.         initData();
    19.     }
    20.  
    21.     /**
    22.      * 初始化数据
    23.      */
    24.     public static void initData() {
    25.         List result= new ArrayList<>();
    26.         result.add("1d");
    27.         result.add("25");
    28.         result.add("3d");
    29.         List result2= new ArrayList<>();
    30.         result2.add("4d");
    31.         result2.add("55");
    32.         result2.add("6d");
    33.         EmployeesVO employeesVO1 = null;
    34.                  employeesVO1 = new EmployeesVO.Bulider(1, "王二", 0, 25, "test1",result).bulider();
    35.         oldList.add(employeesVO1);
    36.         employeesVO1 = new EmployeesVO.Bulider(1, "王二", 0, 25, "test1",result).bulider();
    37.         oldList.add(employeesVO1);
    38.         employeesVO1= new EmployeesVO.Bulider(1, "王二", 1, 25, "test1",result).bulider();
    39.         oldList.add(employeesVO1);
    40.         employeesVO1 = new EmployeesVO.Bulider(4, "李慧", 1, 20, "test 4",result2).bulider();
    41.         oldList.add(employeesVO1);
    42.         employeesVO1 = new EmployeesVO.Bulider(5, "王二三", 0, 25, "test 5",result2).bulider();
    43.         oldList.add(employeesVO1);
    44.  
    45.  
    46.         List result4= new ArrayList<>();
    47.         result2.add("1f");
    48.         result2.add("e5");
    49.  
    50.         result2.add("1h");
    51.         EmployeesVO employeesVO6 = new EmployeesVO.Bulider(6, "王二", 0, 25, "test 6",result2).bulider();
    52.        EmployeesVO employeesVO7 = new EmployeesVO.Bulider(7, "李二", 0, 25, "test 7",result4).bulider();
    53.         EmployeesVO employeesVO8 = new EmployeesVO.Bulider(8, "杨慧", 1, 23, "test 8",result4).bulider();
    54.         EmployeesVO employeesVO9 = new EmployeesVO.Bulider(9, "周慧", 1, 20, "test 8",result4).bulider();
    55.         EmployeesVO employeesVO10 = new EmployeesVO.Bulider(10, "周二", 0, 25, "test 10",result4).bulider();
    56.  
    57.         newList.add(employeesVO6);
    58.         newList.add(employeesVO7);
    59.         newList.add(employeesVO8);
    60.         newList.add(employeesVO9);
    61.         newList.add(employeesVO10);
    62.     }
    63.  
    64.     /**
    65.      * java常用函数：
    66.      * 1，filter  代码的if操作，过滤数据
    67.      * 2，map
    68.      * 3，flatMap
    69.      * 4,collect
    70.      * 5,peek 调试 ，idea工具
    71.      * 6,noneMatch,anyMatch
    72.      * 7,skip
    73.      * 8,distinct
    74.      * 9,收集器 分组，sql group by
    75.      * 分组，过滤，求和，平均，多个流合并，集合并集，交集，差集，map，集合转换
    76.      *
    77.      * @param args
    78.      */
    79.     public static void main(String args[]) {
    80.         //filter 操作
    81.         List result1 = oldList.stream().filter(employeesVO -> employeesVO.getName().equals("王二三")).collect(Collectors.toList());
    82.         //集合差集 根据前面的对象来的
    83.         List  result2 = oldList.stream().filter(item-> !newList.stream().map(
    84.                 employees -> employees.getName()
    85.         ).collect(Collectors.toList()).contains(item.getName())).collect(Collectors.toList());
    86.         //俩个对象相同的交集
    87.         List  result3 = oldList.stream().filter(item->newList.stream().anyMatch(
    88.                 employeesVO -> Objects.equals(item.getName(),employeesVO.getName()))
    89.         ).peek(employeesVO -> employeesVO.getGender()).collect(Collectors.toList());
    90.         //去重
    91.         List  result4 =  newList.stream().collect(
    92.                 Collectors.collectingAndThen(Collectors.toCollection(
    93.                 ()->new TreeSet<>(Comparator.comparing(o->o.getName()+":"+o.getId()))
    94.         ),ArrayList::new));
    95.         //分页
    96.        //  newList.stream().skip((i-1)*size).limit(size).collect(Collectors.toList());
    97.  
    98.         //flatmap 合并流
    99.         List  result5 =   oldList.stream().map(m->m.getResult()).flatMap(Collection::stream).collect(Collectors.toList());
    100.  
    101.         //gropuby 分组
    102.         Map > result6 = newList.stream().map(item->item).collect(Collectors.groupingBy(employeesVO -> employeesVO.getGender()));
    103.  
    104.        //收集器
    105.         Map > result7 = newList.stream().collect(Collectors.partitioningBy(employeesVO -> employeesVO.getGender()==0));
    106.        //distinct 去重 重写equeas 和hash方法
    107.         List result8 =   oldList.stream().distinct().collect(Collectors.toList());
    108.        //map集合
    109.         EmployeesVO employeesVO = new EmployeesVO.Bulider(6, "缓存", 0, 25, "缓存",null).bulider();
    110.  
    111.         cache.put("缓存",employeesVO);
    112.         TestJava8 testJava8 = new TestJava8();
    113.         EmployeesVO employeesVO1 =testJava8.getEmpCache("缓存222");
    114.  
    115.         EmployeesVO employeesVO3 =testJava8.getEmpCache("缓存222");
    116.         System.out.println(result2);
    117.     }
    118.  
    119.     public static  Map cache = new HashMap<>();
    120.  
    121.     public  EmployeesVO employeesVO(String name){
    122.         EmployeesVO employeesVO = new EmployeesVO.Bulider(6, "缓存", 0, 25, "缓存",null).bulider();
    123.      return employeesVO;
    124.     }
    125.  
    126.     public  EmployeesVO getEmpCache(String name){
    127.         return cache.computeIfAbsent(name,this::employeesVO);
    128.     }
    129.  
    130. }

    filter 操作

    相对循环里面的if

    List beginningWithNumbers = new ArrayList<>();

    for(String value : asList("a", "1abc", "abc1")) {

    if (isDigit(value.charAt(0))) {

    beginningWithNumbers.add(value);

    }

    }

    assertEquals(asList("1abc"), beginningWithNumbers);

    flatMap 操作（多个流合并成一个流）

    一个对象的集合合并为一个对象

    List result = newList.stream().map(m->m.getResult()).flatMap(Collection::stream).collect(Collectors.toList());

    java8分页

    list.stream().skip((i - 1) * sheetSize).limit(sheetSize). collect(Collectors.toList());

    List newList2 = newList.stream().skip(( 1-1)* 2).limit(2).collect(Collectors.toList());
    List newList3 = newList.stream().skip(( 2 -1)*2).limit(2).collect(Collectors.toList());
    List newList4= newList.stream().skip(( 3 -1)*2).limit(2).collect(Collectors.toList());

    java8 集合取差集

    List result3 = newList.stream().filter(item-> !oldList.stream().map(
    employees -> employees.getName()
    ).collect(Collectors.toList()).contains(item.getName())).collect(Collectors.toList());

    java8根据参数过滤

    result2.stream().filter(m->m.getVehicleNo().equals(parms.get(0))).collect(Collectors.toList());

    java8集合对象多个值去重：

    newList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(
    ()-> new TreeSet<>(Comparator.comparing(o -> o.getName()+":"+o.getId()))
    ), ArrayIter::new));

    java8取俩个对象相同的属性的值：

    List result= oldList.stream().filter(item->newList.stream().anyMatch(employees -> Objects.equals(employees.name, item.name))).collect(Collectors.toList());

    java8取前面个一个对象不相同的属性的值：


    List result= oldList.stream().filter(item->newList.stream().noneMatch(employees -> Objects.equals(employees.name, item.name))).collect(Collectors.toList());

    收集器：partitioningBy


    Map> map = newList.stream().collect(Collectors.partitioningBy(employDO -> 0==employDO.getGender()));

    groupingBy 收集器
    SQL 中的 group by 操作

    Map > resultFlter = newList.stream().map(m->m).collect(Collectors.groupingBy(employees -> employees.getName()));

    map集合函数：computeIfAbsent

    static Map artistCache = new HashMap<>();

    public Employees getAuthCenterVo(String unionId){
    Employees newEmployees = new Employees();
    newEmployees.setId(1222);
    newEmployees.setName("22222");
    newEmployees.setAge(2222);
    newEmployees.setGender(2222);
    return newEmployees;
    }
    public Employees getlist(String name) {
    return artistCache.computeIfAbsent(name, this::getAuthCenterVo);
    }

    调试解决方案：peak

    记录日志这是 peek 方法的用途之一。为了像调试循环那样一步一步跟踪，可在 peek 方法 中加入断点，这样就能逐个调试流中的元素了。 此时，peek 方法可知包含一个空的方法体，只要能设置断点就行。有一些调试器不允许在 空的方法体中设置断点，此时，我将值简单地映射为其本身，这样就有地方设置断点了， 虽然这样做不够完美，但只要能工作就行

    断点到方法调试

    peek方法

    示列1：

    List result = newList.stream().peek(
    m->System.out.println(m)
    ).collect(
    Collectors.collectingAndThen(
    Collectors.toCollection(() -> new TreeSet<>(
    Comparator.comparing(
    o->o.getName()+":"+o.getGender()))
    ),ArrayList::new ));

    示列2：
    long wordsList = Arrays.stream(test22.split(",")).map(m->m ).peek( t->System.out.println(t)).filter(textContent::equals)
    .count();

    idea调试

    常用的java8函数表达式就基本差不多这么多了，如果你需要了解其他的高阶的函数，可以去用@FuctionInterface注解操作

  • 相关阅读:
    React组件生命周期
    进程调度算法-时间片轮转、最高优先级和多级反馈队列调度算法
    深度之眼（十六）——Python：有益的探索
    【算法笔记】树状数组/Binary Indexed Tree/Fenwick Tree
    java毕业生设计医药网络挂号系统计算机源码+系统+mysql+调试部署+lw
    JAVAEE---多线程
    胆囊结石的危害你了解多少？
    深入分析LinkedHashMap
    【Mysql】where 条件子句之逻辑运算符
    【老卫搞机】090期：键盘？主机？全功能键盘主机！
  • 原文地址：https://blog.csdn.net/qq_39751120/article/details/126323823