Java8是往并行方向走的。由面向对象到函数式编程。
在支持函数式编程的同时还可以支持面向对象的开发。
在JDK1.8里面，接口里面可以有实现方法的！默认方法，default。实现这个接口。
接口里面可以有静态方法
注意Lambda表达式的类型势函数。但是在Java中，Lambda表达式是对象！他们必须依赖于一类特别的对象类型-函数式接口
关于Function<T,R>接口
public class FunctionTest {
public static void main(String[] args) {
FunctionTest functionTest = new FunctionTest();
//传递行为
System.out.println(functionTest.compute(1, value -> {return 10 * value;}));
}
public int compute (int a, Function<Integer, Integer> function){
// 实现，由调用者去实现之
int result = function.apply(a);
return result;
}
}
解析：
单独吧Lambda抽取出来：
public class FunctionTest {
public static void main(String[] args) {
//先把Lambda定义好
Function<Integer, Integer> function = value -> value * 2;
FunctionTest functionTest = new FunctionTest();
System.out.println(functionTest.compute(5, function));
}
public int compute(int a, Function<Integer, Integer> function){
int result = function.apply(a);
return result;
}
}
多个function之间的串联与先后关系的指定：
public class FunctionTest {
public static void main(String[] args) {
FunctionTest functionTest = new FunctionTest();
System.out.println(functionTest.compute1(2, value -> value * 3, value -> value *value));
System.out.println(functionTest.compute2(2, value -> value * 3, value -> value *value));
}
public int compute1(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
return function1.compose(function2).apply(a);
}
public int compute2(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
return function1.andThen(function2).apply(a);
}
}
compose源码：
对比上面的例子，先执行function2 然后将结果赋值给function1去执行
andThen是相反的。
所以，对于 R apply(T t); 要想实现两个输入一个输出，是做不到的。可以通过 BiFunction得到。
public class FunctionTest {
public static void main(String[] args) {
FunctionTest functionTest = new FunctionTest();
System.out.println(functionTest.compute4(2,3, (value1, value2) -> value1 + value2, value -> value * value));
}
public int compute4(int a, int b, BiFunction<Integer, Integer, Integer> biFunction, Function<Integer, Integer> function){
return biFunction.andThen(function).apply(a,b);
}
}
Predicate
filter的参数类型就是Predicate！
函数式编程提供了更高层次的抽象化:
test() 名字都是抽象的，不具体。比较宏观。
public class FunctionTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
FunctionTest functionTest = new FunctionTest();
functionTest.conditionFilter(list, item -> item % 2 == 0);
}
public void conditionFilter(List<Integer> list, Predicate<Integer> predicate){
for (Integer integer : list){
if (predicate.test(integer)){
System.out.println(integer);
}
}
}
}
对于Predicate的default函数：
public class FunctionTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
FunctionTest functionTest = new FunctionTest();
functionTest.conditionFilter(list, item -> item % 2 == 0, item -> item < 6);
}
public void conditionFilter(List<Integer> list, Predicate<Integer> predicate1, Predicate<Integer> predicate2){
for (Integer integer : list){
// and 返回的是Predicate! 所以继续 .test
if (predicate1.and(predicate2).test(integer)){
// if (predicate1.or(predicate2).test(integer)){
if (predicate1.negate().test(integer)){ // 取反。满足条件后剩下的
// 如果两个都满足
System.out.println(integer);
}
}
}
}
静态方法： 返回的也是Predicate
作用就是判断两个参数是否相等。
public class FunctionTest {
public static void main(String[] args) {
FunctionTest functionTest = new FunctionTest();
//isEqual传进来的是test 然后和参数 “test”比较
System.out.println(functionTest.isEqual(new Date()).test(new Date()));
}
public Predicate<Date> isEqual(Object object){
return Predicate.isEqual(object);
}
}
Comparator 还是个函数式接口。里面有好几个函数式接口
结合BinaryOperator
Optional 是个容器，可能包含空值，非空值
public class FunctionTest {
public static void main(String[] args) {
// Optional<String> optional = Optional.empty();
Optional<String> optional = Optional.of("valueTest");
optional.ifPresent(item -> System.out.println(item));
System.out.println(optional.orElse("world"));
System.out.println(optional.orElseGet( () -> "hello"));
}
}
public class FunctionTest {
public static void main(String[] args) {
Employee employee1 = new Employee();
employee1.setName("123");
Employee employee2 = new Employee();
employee2.setName("456");
Company company = new Company();
company.setName("c1");
List<Employee> employees = Arrays.asList(employee1, employee2);
company.setEmployees(employees);
List<Employee> result = company.getEmployees();
// if (result != null){
// return result;
// }else {
// return new ArrayList<>();
// }
//一行代码搞定
Optional<Company> optional = Optional.ofNullable(company);
System.out.println(optional.map( item -> item.getEmployees()).orElse(Collections.emptyList()));
}
}
注意 Optional类型，不用做参数类型！ 因为没有序列化！
作为返回类型，规避null！
方法引用类似于函数指针。‘’
Remember：
function 接收一个 返回一个
Supplier 只返回不接受
总结方法引用分4类：
1. 类名：：静态方法名
2. 引用名(对象名)：：实例方法名
3. 类名：：实例方法名
4. 构造方法引用：： 类名：：new
流有个好处，支持并行化，对一个集合进行迭代，流可以并行，多个线程进行处理。对于多核处理性能大大提升。
public class FunctionTest {
public static void main(String[] args) {
Stream<String> stream = Stream.of("a", "b", "c", "d");
String[] strings = stream.toArray(length -> new String[length]);
Arrays.asList(strings).forEach(System.out::println);
}
}
改造成Lambda表达式构造函数引用: 通过构造函数引用的方式将数组传递进去
public class FunctionTest {
public static void main(String[] args) {
Stream<String> stream = Stream.of("a", "b", "c", "d");
String[] strings = stream.toArray(String[]::new);
Arrays.asList(strings).forEach(System.out::println);
}
}
public class FunctionTest {
public static void main(String[] args) {
Stream<String> stream = Stream.of("a", "b", "c", "d");
List<String> list1 = stream.collect(() -> new ArrayList(),
(theList, item) -> theList.add(item),
(theList1, theList2) -> theList1.addAll(theList2));
//方法二
List<String> list2 = stream.collect(LinkedList::new, LinkedList::add, LinkedList::addAll);
list.stream().forEach(System.out::println);
}
}
public class FunctionTest {
public static void main(String[] args) {
Stream<String> stream = Stream.of("a", "b", "c", "d");
String str = stream.collect(Collectors.joining()).toString();
System.out.println(str);
}
}
flatMap去操作:
public class FunctionTest {
public static void main(String[] args) {
Stream<List<Integer>> listStream = Stream.of(Arrays.asList(1), Arrays.asList(2, 3), Arrays.asList(4, 5, 6));
//每个List转成Stream
listStream.flatMap( theList -> theList.stream())
.map( item -> item * item).forEach(System.out::println);
}
}
正确使用Optional:
public class FunctionTest {
public static void main(String[] args) {
Stream<String> stream = Stream.generate(UUID.randomUUID()::toString);
//返回的是个Optional可以调用get方法。 流里面的第一个元素为啥返回Optional。避免异常。如果流里面没有元素呢？规避之
System.out.println(stream.findFirst().get());
//如果存在元素的话...
stream.findFirst().ifPresent(System.out::println);
//可以创建空的流
Stream<String> stream1 = Stream.empty();
stream1.findFirst().ifPresent(System.out::println);
}
}
public class FunctionTest {
public static void main(String[] args) {
Stream<Integer> stream = Stream.iterate(1, item -> item + 2).limit(6);
IntSummaryStatistics summaryStatistics = stream.filter(item -> item > 2)
.mapToInt(item -> item * 2).skip(2).limit(2).summaryStatistics();
System.out.println( summaryStatistics.getMax());
System.out.println( summaryStatistics.getMin());
}
}
例子：Map： 中间操作，延迟操作。遇到终止操作时候才会执行之
public class FunctionTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("hello", "world", "how are you");
list.stream().map(
item -> {
String result = item.substring(0, 1).toUpperCase() + item.substring(1);
System.out.println("----->");
return result;
}
).forEach( System.out::println);
}
}
Map和flatMap
public static void main(String[] args) {
List<String> list = Arrays.asList("hello welcome", "world hello");
//返回的List string类型的数组 四个数组对象不是不同的！
List<String[]> result = list.stream()
// <R> Stream<R> map(Function<? super T, ? extends R> mapper);
.map(item -> item.split(" ")).distinct().collect(Collectors.toList());
result.forEach(
item -> Arrays.asList(item).forEach(System.out::println)
);
// flatMap System.out.println("----->flatMap"); List<String> resultFlatMap = list.stream().map(item -> item.split(" ")) //<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
//将数组类型 转成 String类型
.flatMap(Arrays::stream) // 接收的是一个数组类型。返回Stream类型。这样返回四个Stream。 调用FlatMap把四个Stream合并成一个！
.distinct().collect(Collectors.toList());
resultFlatMap.forEach(System.out::println);
}
分析 FlatMap将结果打平了，结果放在一个流里面。
上述对于 FlatMap的使用， 首先map映射成字符串数组类型的内容， 然后将字符串数组打平。打平成一个Stream。即： 将 Stream<Strimg[]> ------> Stream<String>
public class FunctionTest {
public static void main(String[] args) {
List<String> list1 = Arrays.asList("你好", "哈哈");
List<String> list2 = Arrays.asList("zhangsan", "lisi", "wangwu");
List<String> result = list1.stream().flatMap(item -> list2.stream().map(item2 -> item + " " + item2)).collect(Collectors.toList());
result.forEach(System.out::println);
}
}
Stream:
和迭代器不同的是，Stream可以并行化操作，迭代器只能命令式、串行化操作
当使用串行方式遍历时，每特item读完后再读下一个
使用并行去遍历时，数据会被分成多段，其中每一个都在不同的线程中处理，然后将结果一起输出。
Stream的并行操作依赖于Java7中引入的Fork/Join框架。任务分解成小任务。
集合关注的是数据与数据存储
流关注的是数计算，流与迭代器类似的一点是： 流复发重复使用或者消费的。
中间操作都会返回一个Stream对象，比如 Stream<Integer> Stream<Strimg> 比如 mapToInt返回 Stream<Integer>
public class FunctionTest {
public static void main(String[] args) {
Employee employee1 = new Employee("a");
Employee employee2 = new Employee("a");
Employee employee3 = new Employee("b");
Employee employee4 = new Employee("c");
List<Employee> list = Arrays.asList(employee1, employee2, employee3, employee4);
Map<String, Long> nameCountMap = list.stream().collect(Collectors.groupingBy(Employee::getName, Collectors.counting()));
System.out.println(nameCountMap);
}
}
list.stream().collect(Collectors.groupingBy(Employee::getName, Collectors.averagingDouble(Employee::getScore));
分组：group by
分区： partition by 区别group by 只能分两组 ，比如 true false。 90以上及格，以下不及格
collect是Stream提供的一个方法。Collector作为Collect方法的参数。Collector接口非常重要，分析之：
Collector是一个接口，文档解释“它是一个可变的汇聚操作，将输入元素累积到一个可变的结果容器中；它会在所有元素处理完毕之后，将累积结果转换为一个最终的表示(这是一个可选操作。支持串行并行两种方式执行。
注意: 并行不一定比串行块，因为并行涉及到线程切换。比如cpu 2核的，生成四个线程。势必四个线程去增强这两个核心，会存在上下文切换。
Collectors本身提供了关于Collectors的常见汇聚实现，Collectors本身是一个工厂。
Collector是由四个元素组成的
combiner函数，有四个线程同时去执行，那么就会生成四个部分结果。然后合并成一个。用在并行流的场景。
为了确保串行与并行操作的结果等价性，Collector函数需要满足两个条件，identity(同一性)与associativity(结合性)。
public interface Collector<T,A,R> T:集合或者流中的每个元素类型， A可变容器类型， R：结果类型
·
public class FunctionTest {
public static void main(String[] args) {
Employee employee1 = new Employee("a", 12);
Employee employee2 = new Employee("a", 23);
Employee employee3 = new Employee("b", 43);
Employee employee4 = new Employee("c", 34);
List<Employee> employees = Arrays.asList(employee1, employee2, employee3, employee4);
String collect1 = employees.stream().map(Employee::getName).collect(Collectors.joining(","));
//连续分组
Map<Integer, Map<String, List<Employee>>> collect = employees.stream()
.collect(Collectors.groupingBy(Employee::getScore, Collectors.groupingBy(Employee::getName)));
//分区
Map<Boolean, List<Employee>> collect2 = employees.stream().collect(Collectors.partitioningBy(e -> e.getScore() > 3));
//连续分区
Map<Boolean, Map<Boolean, List<Employee>>> collect3 = employees.stream().collect(Collectors.partitioningBy(e -> e.getScore() > 80, Collectors.partitioningBy(e -> e.getScore() > 5)));
//综合实战
Map<Boolean, Long> collect4 = employees.stream().collect(Collectors.partitioningBy(employee -> employee.getScore() > 90, Collectors.counting()));
Map<String, Employee> collect5 = employees.stream().collect(Collectors.groupingBy(Employee::getName,
// 收集然后XXX
Collectors.collectingAndThen(Collectors.minBy(Comparator.comparingInt(Employee::getScore)),
Optional::get)));
}
}
排序：
Collector.sort() 本质上是调用 list.sort()
public class FunctionTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("helloWorld", "nihao", "java");
Collections.sort(list, (item1, item2) -> {return (item1.length() - item2.length());});
System.out.println(list);
//当lambda没法推断类型时候，指定下
Collections.sort(list, Comparator.comparingInt((String item) -> item.length()).reversed());
list.sort(Comparator.comparingInt(String::length).reversed());
list.sort(Comparator.comparingInt((String item) -> item.length()).reversed());
//不区分大小写的排序,两个排序规则. 先升序，然后XXX.两个比较规则，第一个相同就调用第二个方法。
Collections.sort(list, Comparator.comparingInt(String::length).thenComparing(String.CASE_INSENSITIVE_ORDER));
Collections.sort(list, Comparator.comparingInt(String::length).thenComparing( (item1, item2) -> item1.toLowerCase().compareTo(item2.toLowerCase())));
Collections.sort(list, Comparator.comparingInt(String::length).thenComparing(Comparator.comparing(String::toLowerCase)));
//长度希望等的，才需要进行第二次比较。小写进行比较，小写逆序。
Collections.sort(list, Comparator.comparingInt(String::length).thenComparing(Comparator.comparing(String::toLowerCase, Comparator.reverseOrder())));
Collections.sort(list, Comparator.comparingInt(String::length).reversed().thenComparing(Comparator.comparing(String::toLowerCase, Comparator.reverseOrder())));
//多级排序
Collections.sort(list, Comparator.comparingInt(String::length).reversed()
// 相同的(比较结果为0的，继续使用下面的方法)
.thenComparing(Comparator.comparing(String::toLowerCase, Comparator.reverseOrder()))
// 是否起作用，取决于前面的比较情况结果
.thenComparing(Comparator.reverseOrder()));
}
}
定义实现自己的收集器：
/**
* 1.实现接口时候，要定义好泛型
* 2.
*/
public class MySetCollector<T> implements Collector<T, Set<T>, Set<T>> {
/**
* 提供一个空的容器，供accumulator 后续方法调用
* @return
*/
@Override
public Supplier<Set<T>> supplier() {
System.out.println("-----> supplier");
return HashSet<T>::new;
}
/**
* 累加器类型的，接收两个参数不返回值
* @return
*/
@Override
public BiConsumer<Set<T>, T> accumulator() {
System.out.println("-----> accumulator");
//通过方法引用的方式返回了一个 BiConsumer 对象
// return Set<T>::add;
return (set, item) -> set.add(item);
}
/**
* 将并行流，多个线程所执行的结果合并起来
* @return
*/
@Override
public BinaryOperator<Set<T>> combiner() {
// 把一个部分结果，添加到另外一个部分结果中
System.out.println("------> combiner");
return (set1, set2) -> {
set1.addAll(set2);
return set1;
};
}
/**
* 多线程情况下，最后一步要执行的。返回最终的结果类型。返回结果容器给用户。
* @return
*/
@Override
public Function<Set<T>, Set<T>> finisher() {
// return t -> t;
return Function.identity();
}
/**
* 返回一个set集合，表示当前的收集器诸多独特性。
* @return
*/
@Override
public Set<Characteristics> characteristics() {
System.out.println("----->characteristics");
// 直接返回一个不可变的集合,参数为指定的特性
return Collections.unmodifiableSet(EnumSet.of(IDENTITY_FINISH, UNORDERED));
}
public static void main(String[] args) {
List<String> list = Arrays.asList("hello", "world", "welcome", "hello");
Set<String> collect = list.stream().collect(new MySetCollector<>());
System.out.println(collect);
}
}
看下面例子：
public class MySetCollector2<T> implements Collector<T,Set<T>, Map<T,T>> {
@Override
public Supplier<Set<T>> supplier() {
System.out.println("supplier invoked");
return HashSet::new;
}
@Override
public BiConsumer<Set<T>, T> accumulator() {
System.out.println("accumulator invoked");
return (set, item) -> {
set.add(item);
};
}
@Override
public BinaryOperator<Set<T>> combiner() {
System.out.println("combiner invoked");
return (set1, set2) -> {
set1.addAll(set2);
return set1;
};
}
@Override
public Function<Set<T>, Map<T, T>> finisher() {
System.out.println("finisher invoked");
return set -> {
Map<T,T> map = new HashMap<>();
set.stream().forEach(
item -> map.put(item, item)
);
return map;
};
}
@Override
public Set<Characteristics> characteristics() {
System.out.println("characteristics invoked!");
return Collections.unmodifiableSet(EnumSet.of(Characteristics.UNORDERED));
}
public static void main(String[] args) {
List<String> list = Arrays.asList("hello", "world", "welcome", "a", "b", "c");
Set<String> set = new HashSet<>();
set.addAll(list);
System.out.println("set"+ set);
Map<String, String> collect = set.stream().collect(new MySetCollector2<>());
System.out.println(collect);
}
}
收集器：
对于Collectors惊天工厂类来说，其实现一共分为两种情况：
- 通过ColletcorImpl来实现
- 通过reduceing方法来实现(reducing方法本身又是通过CollectorImpl来实现)
关于toList()
public static <T>
Collector<T, ?, List<T>> toList() {
return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add,
(left, right) -> { left.addAll(right); return left; },
CH_ID);
}
682
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
