Vavr

Vavr"/>

Vavr

Vavr - Java8函数式编程拓展库使用指南目录

• Maven 项目包管理
• Vavr 常用对象讲解
• • 1. Tuples 元组
  • • 1.1 Create a tuple 创建一个元组
    • 1.2 Map a tuple 改变元组内部元素值
    • 1.3 Transform a tuple 元组转换
  • 2. Functions 方法
  • • 2.1 Composition 方法组合
    • 2.2 Lifting 返回值包装
    • 2.3 Partial application 分部应用
    • 2.4 Currying 颗粒性
    • 2.5 Memoization 内存存储
  • 3. Values 值包装
  • • 3.1 Option 选项
    • 3.2 Try 尝试执行
    • 3.3 Lazy 惰性加载
    • 3.4 Either 两者之一
    • 3.5 Future 将来
    • 3.6 Validation 校验
  • 4. Collections 集合包装
  • 5. Pattern Matching 模式匹配
  • • 5.1 User-Defined Patterns 自定义匹配条件

Vavr是对Java8函数式编程的拓展，提供更丰富的API及更友好的处理思路方式，使我们在使用函数式变成时更加得心应手。

Maven 项目包管理

`<dependency><groupId>io.vavr</groupId><artifactId>vavr</artifactId><version>0.10.4</version>
</dependency>`

Vavr官方文档地址：vavr官方文档
下面我们会对Vavr的常用对象、功能及基本使用做一个讲解。

Vavr 常用对象讲解

1. Tuples 元组

元组是将多个不同类型的数据包裹的一个容器，比如可以将字符串，数字，数组用一个元组包裹，这样即可以通过一个元组变量获取到包括的任一数据。

1.1 Create a tuple 创建一个元组

Tuple2<String, Integer> java8 = Tuple.of("Java", 8); 
String s = java8._1;   // s = Java
Integer i = java8._2;  // i = 8

1.2 Map a tuple 改变元组内部元素值

/*** 这里有两种方式* 方式一：map后多个处理函数* 方式二：map后一个处理函数*/
Tuple2<String, Integer> that1 = java8.map(s -> s.substring(2) + "vr",i -> i / 8
);Tuple2<String, Integer> that2 = java8.map((s, i) -> Tuple.of(s.substring(2) + "vr", i / 8)
);
// 此时that1、that2里 s = vavr, i = 1

1.3 Transform a tuple 元组转换

String that = java8.apply((s, i) -> s.substring(2) + "vr " + i / 8
// 此时that为 vavr 1

2. Functions 方法

这里的Functions类似Java8里的Function，可以说是对Java8Function做的拓展，其中最大的拓展是Java8中的Function只支持定义一个参数和一个结果，但实际运用当中的话我们得有多个参数，那这样Java8的Function中必须得将参数包装成一个Bean，在Bean中去封装多个参数值，而Vavr则直接将其拓展，使Function可以支持多个参数，最多支持8个参数，创建示例如下：

// 创建方式一
Function<Integer, Integer, Integer> sum = (a, b) -> a + b;// 创建方式二
Function2<Integer, Integer, Integer> sum = new Function2<Integer, Integer, Integer>() {@Overridepublic Integer apply(Integer a, Integer b) {return a + b;}
};// 创建方式三
Function3<Integer, Integer, Integer> sum = Function3.of((a, b) -> a + b);

2.1 Composition 方法组合

组合前：

Function1<Integer, Integer> func1 = a -> a + 1;
Function1<Integer, Integer> func2 = a -> a * 2;
Function1<Integer, Integer> func3 = func1.andThen(func2);
System.out.println(func3.apply(2));  // (2 + 1) * 3 = 6

组合后：

Function1<Integer, Integer> func1 = a -> a