参考书籍：Java8 函数式编程
AndroidStudio创建一个java Module
sourceCompatibility = "1.8"
targetCompatibility = "1.8"
这里需要将java版本设置为1.8+
public class SimpleLambda {
public static void main(String[] args){
/**
* 默认无参数 默认返回Runnable类型
*/
Runnable runnable = () -> System.out.println("Hello Lambda");
runnable.run();
Runnable runnable1 = () -> {
System.out.print("Hello");
System.out.println(" Lambda");
};
runnable1.run();
/**
* 一个参数，无返回值， 默认返回Consumer类型
*/
Consumer<Integer> tConsumer = (Integer x) -> System.out.println(x);
Consumer<Double> doubleConsumer = (Double d) -> System.out.println(d);
//由方法引用代替
Consumer<Integer> tConsumer1 = System.out::println;
Consumer<Double> doubleConsumer1 = System.out::println;
tConsumer.accept(10);
tConsumer1.accept(101);
doubleConsumer.accept(20.0);
doubleConsumer1.accept(201.0);
Predicate<Integer> predicate = (x) -> x > 10;
System.out.println(predicate.test(10));
/**
* 两个参数，有返回值
*/
//lambda表达式默认返回类型IntBinaryOperator
IntBinaryOperator intBinaryOperator = (x, y) -> x + y;
System.out.println(intBinaryOperator.applyAsInt(3, 4));
//lambda表达式默认返回类型DoubleBinaryOperator
DoubleBinaryOperator doubleBinaryOperator = (double x, double y) -> x + y;
System.out.println(doubleBinaryOperator.applyAsDouble(3.0, 4.0));
BinaryOperator<Integer> add = (x, y) -> x + y;
System.out.println(add.apply(10, 20));
}
}
总结个简单的公式：
(参数...) -> 表达式;
(参数...) -> {代码块};
这里由于java8的类型推断，参数类型可写可不写，不写底层会根据方法的参数列表推断出来。
以上代码等号右边的lambda为什么返回等号左边的类型，看到下面的函数式接口就明白了
查看原码发现，Runnable多了一个注解 @FunctionalInterface(函数式接口)
package java.lang;
@FunctionalInterface
public interface Runnable {
void run();
}
什么是函数式接口
简单说，只有一个抽象方法（不包括default static方法）的接口。
函数式接口其实就是Lambda表达式（又称为闭包）本身的类型
以下是java8中util.function包下的类，我总结了一个，分为5大种类
分别是Function, Operator, Consumer, Supplier, Predicate
Paste_Image.png
Stream
我们来看看java8新引进的Stream及对集合类的改进
Arrays：将Arrays转换为Stream
String[] arrays = {"a1", "a2", "a3"};
Stream<String> stream = Arrays.stream(arrays);
相关新加方法及重载方法：
//
public static <T> Stream<T> stream(T[] array) {
return stream(array, 0, array.length);
}
public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive) {
return StreamSupport.stream(spliterator(array, startInclusive, endExclusive), false);
}
//
public static IntStream stream(int[] array) {
return stream(array, 0, array.length);
}
public static IntStream stream(int[] array, int startInclusive, int endExclusive) {
return StreamSupport.intStream(spliterator(array, startInclusive, endExclusive), false);
}
//
public static LongStream stream(long[] array) {
return stream(array, 0, array.length);
}
public static LongStream stream(long[] array, int startInclusive, int endExclusive) {
return StreamSupport.longStream(spliterator(array, startInclusive, endExclusive), false);
}
//
public static DoubleStream stream(double[] array) {
return stream(array, 0, array.length);
}
public static DoubleStream stream(double[] array, int startInclusive, int endExclusive) {
return StreamSupport.doubleStream(spliterator(array, startInclusive, endExclusive), false);
}
Collection:将各种继承Collection的接口（List, Set）转换为Stream
List<String> stringList = new ArrayList<>();
Stream<String> streamList = stringList.stream();
Set<Long> map = new HashSet<>();
Stream<Long> streamMap = map.stream();
Collection相关新加方法
java1.8后引入了接口的默认方法和静态方法，接口中也可以有实现方法了
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
除了以上可以获得Stream对象外，还有一些相应的方法：
先看一张结构图：
Paste_Image.png
尝试从以上子类中获得相应的Stream:
IntStream intStream = IntStream.of(1, 2, 3);
OptionalDouble average = intStream.average();
System.out.println(average);//OptionalDouble[2.0]
LongStream longStream = LongStream.of(1000, 2000, 3000);
OptionalLong first = longStream.findFirst();
System.out.println(first);//OptionalLong[1000]
DoubleStream doubleStream = DoubleStream.of(1.0, 2.0, 3.0);
OptionalDouble max = doubleStream.max();
System.out.println(max);//OptionalDouble[3.0]
Stream<String> streamString = Stream.of("a", "b", "c", "d");
long count = streamString.count();
System.out.println(count);//4
得到Stream后，我们便可对其进行一系列操作，以上只是实现了几个简单的方法。接下来我们来看看一些常用的操作
常用的流操作
先来看两个概念：惰性求值方法，及早求值方法。
先记住，只要是方法返回的是Stream对象，则是惰性求值方法，其它的是及早求值方法。
这样的设计， 为链式调用提供便利。一般的调用顺序为：
1.获得流 (of)
2.惰性求值(of, filter, sorted)
3.及早求值(collect)
List<String> list = Stream.of("Java", "Android", "Php", "IOS")//获得Stream对象
.filter(s -> s.length() > 3)//过滤，只保留长度大于3的
.sorted()//排序
.collect(Collectors.toList());//将结果输出到List中
System.out.println(list);//[Android, Java]
以此分类，先来看几个惰性求值方法：
map:将一种类型转换为另一种类型
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
Function<String, String> stringStringFunction = s -> s.toUpperCase();
List<String> list = Stream.of("Java", "Android", "Php", "IOS")
.map(stringStringFunction)
.collect(Collectors.toList());
System.out.println(list.getClass().getSimpleName() + list);//ArrayList[JAVA, ANDROID, PHP, IOS]
相当于：
List<String> list = Stream.of("Java", "Android", "Php", "IOS")
.map(s -> s.toUpperCase())
//.map(String::toUpperCase)//或写成方法引用的格式，可以理解为以传入的参数为对象，调用该方法。
.collect(Collectors.toList());
System.out.println(list.getClass().getSimpleName() + list);//ArrayList[JAVA, ANDROID, PHP, IOS]
filter:过滤，保留符合参数条件的数据
Stream<T> filter(Predicate<? super T> predicate);
List<String> list = Stream.of("Java", "Android", "Php", "IOS")
.filter(s -> s.startsWith("A") | s.startsWith("I"))
.collect(Collectors.toList());
System.out.println(list.getClass().getSimpleName() + list);//ArrayList[Android, IOS]
flatMap:将多个Stream合并为一个Stream
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
List<String> languageList = Arrays.asList("Java", "Android", "Php", "IOS");
List<String> movieList = Arrays.asList("声之形", "你的名字", "千与千寻");
List<String> list = Stream.of(languageList, movieList)
.flatMap(Collection::stream)//这里的参数为List<String>
.collect(Collectors.toList());
System.out.println(list.getClass().getSimpleName() + list);//ArrayList[Java, Android, Php, IOS, 声之形, 你的名字, 千与千寻]
distinct:去重
Stream<T> distinct();
List<Integer> collect = Stream.of(1, 2, 3, 4, 3, 5, 4)
.distinct()
.collect(Collectors.toList());
System.out.println(collect);//[1, 2, 3, 4, 5]
limit:限制个数
Stream<T> limit(long maxSize);
List<Integer> collect = Stream.of(1, 2, 3, 4, 3, 5, 4)
.limit(5)
.distinct()
.collect(Collectors.toList());
System.out.println(collect);//[1, 2, 3, 4]
peek:用于调试
Stream<T> peek(Consumer<? super T> action);
Stream.of("one", "two", "three", "four")
.filter(e -> e.length() > 3)
.peek(e -> System.out.println("Filtered value: " + e))
.map(String::toUpperCase)
.peek(e -> System.out.println("Mapped value: " + e))
.collect(Collectors.toList());
输出：
Filtered value: three
Mapped value: THREE
Filtered value: four
Mapped value: FOUR
skip:跳过若干个数据
Stream<T> skip(long n);
List<Integer> collect = Stream.of(1, 2, 3, 4, 5, 6)
.skip(2)
.collect(Collectors.toList());
System.out.println(collect);//[3, 4, 5, 6]
再来看几个及早求值方法：
collect:从流中生成相应的集合
<R, A> R collect(Collector<? super T, A, R> collector);
List<String> list = Stream.of("Java", "Android", "Php", "IOS")
.filter(s -> s.length() > 3)
.sorted()
.collect(Collectors.toList());
System.out.println(list.getClass().getSimpleName() + list);//ArrayList[Android, Java]
Set<String> set = Stream.of("Java", "Android", "Php", "IOS")
.filter(s -> s.length() > 3)
.sorted()
.collect(Collectors.toSet());
System.out.println(set.getClass().getSimpleName() + set);//HashSet[Java, Android]
Function<String, String> keyMapper = s -> s + "key";
Function<String, String> valueMapper = s -> s + "value";
Map<String, String> map = Stream.of("Java", "Android", "Php", "IOS")
.filter(s -> s.length() > 3)
.sorted()
.collect(Collectors.toMap(keyMapper, valueMapper));
System.out.println(map.getClass().getSimpleName() + map);//HashMap{Javakey=Javavalue, Androidkey=Androidvalue}
max/min: 按照一定规则，获得最大，最小值
Optional<T> max(Comparator<? super T> comparator);
Optional<String> max = Stream.of("Java", "Android", "Php", "IOS")
.max(Comparator.comparing(String::length));
System.out.println(max.get());//Android
count: 获得数据的个数
long count();
long count = Stream.of("Java", "Android", "Php", "IOS").count();
System.out.println(count);//4
reduce: 从一组值中生成一个值 （以上的max, min, count都是reduce操作）
T reduce(T identity, BinaryOperator<T> accumulator);
Integer reduce = Stream.of(1, 2, 3, 4, 5).reduce(0, (first, second) -> first + second);
System.out.println(reduce);//15
forEach:遍历输出
void forEach(Consumer<? super T> action);
Stream.of(1, 2, 3, 4, 5).forEach(System.out::println);
未完待续。。。
