转载请注明地址：//www.greatytc.com/p/86dc38f0cec8
第一部分、方法引用
方法引用总体上分为四种：
- 类之中静态方法的引用 类名称 :: 静态方法名称
- 类之中普通方法的引用 实例化对象名称::普通方法
- 类中构造方法的引用 类名称 ::new
- 特定类型的任意方法的引用 类名称::方法名称
1、简化的lambda——方法引用（Method Reference）
lambda已经简化了代码的写法，然而方法引用进一步简化了lambda的写法。
方法引用的使用方式：类名::方法名
| 类型 | 使用方式 | 备注 |
|---|---|---|
| 引用静态方法 | ContainingClass::staticMethodName | Integer::valueOf简化了i->Integer.valueOf(i)的写法 |
| 引用特定对象的实例方法 | containingObject::instanceMethodName | s::toString()简化了()->s.toString() |
| 引用特定类型的任意对象的实例方法 | ContainingType::methodName | System.out::println简化了(s)->System.out.println(s)，其中System.out表示的是PrintStream对象 |
| 引用构造函数 | ClassName::new | String::new简化了()->new String() |
例1：
@FunctionalInterface
interface myfun<T,P>{
public P fun(T t);
}
class Test {
public static void main(String[] args) {
//类之中的静态方法
myfun<Integer,String> test1 = String::valueOf; //valueOf
//等价于 myfun<Integer,String> test1 =s->String.valueOf(s);
System.out.println(test1.fun(1000));
//类之中普通方法
String string = "Hello World .";
myfun<String,Boolean> test2 = string::startsWith;
}
}
当然这里的接口myfun，在jdk8中为我们提供了Function的接口，我们可以直接使用。
例：
Class Demo{
public static Integer getInteger(String s) {
Function<String, Integer> function = (a) -> Integer.parseInt(a);
return function.apply(s);
}
}
更简化的写法如下：
Class Demo{
public static Integer getInteger(String s) {
Function<String, Integer> function = Integer::parseInt(a);
return function.apply(s);
}
}
第二部分、内建式函数式接口
- java提供的核心内建函数式接口
- 集合的新型输出操作
核心接口
- 函数型接口 Function <T,R>
- 消费型接口 Consumer<T>
- 供给型接口 Supplier<T>
- 断言型接口 Predicate
举例：
List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
list.forEach(s->System.out.println(s));
第三部分、数据流
1、构造流的几种常见方法
// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();
构造数据流，总体上可分为三种方法。
直接利用Stream的of方法，将几个独立的值转化为数据流。
利用数组
-
利用Collection接口,由于Collection接口有个stream方法。
default Stream<E> stream();stream()方法定义如下：
default Stream<E> stream() { return StreamSupport.stream(spliterator(), false); }
2、数值流的构造
IntStream.of(new int[]{1, 2, 3}).forEach(System.out::println);
IntStream.range(1, 3).forEach(System.out::println);
IntStream.rangeClosed(1, 3).forEach(System.out::println);
3、流转换为其它数据结构
// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();
Stream<List<Integer>> inputStream = Stream.of(
Arrays.asList(1),
Arrays.asList(2, 3),
Arrays.asList(4, 5, 6)
);
Stream<Integer> outputStream = inputStream.
flatMap((childList) -> childList.stream());
reduce 的用例
// 字符串连接，concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
// 求最小值，minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
// 求和，sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和，sumValue = 10, 无起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
// 过滤，字符串连接，concat = "ace"
concat = Stream.of("a", "B", "c", "D", "e", "F").
filter(x -> x.compareTo("Z") > 0).
reduce("", String::concat);
1、使用Stream静态方法来创建Stream
1.1、 of方法：有两个overload方法，一个接受变长参数，一个接口单一值
//1
Stream<Integer> integerStream = Stream.of(1, 2, 3, 5);
Stream<Integer> integerStream = Stream.of("A", "B", "C");
//2
Stream<String> stringStream = Stream.of("taobao");
1.2、generator方法：生成一个无限长度的Stream，其元素的生成是通过给定的Supplier（这个接口可以看成一个对象的工厂，每次调用返回一个给定类型的对象）
Stream.generate(newSupplier<Double>() {
@Override
publicDouble get() {
returnMath.random();
}
});
Stream.generate(() -> Math.random());
Stream.generate(Math::random);
三条语句的作用都是一样的，只是使用了lambda表达式和方法引用的语法来简化代码。每条语句其实都是生成一个无限长度的Stream，其中值是随机的。这个无限长度Stream是懒加载，一般这种无限长度的Stream都会配合Stream的limit()方法来用
1.3、iterate方法：也是生成无限长度的Stream，和generator不同的是，其元素的生成是重复对给定的种子值(seed)调用用户指定函数来生成的。其中包含的元素可以认为是：seed，f(seed),f(f(seed))无限循环
Stream.iterate(1, item -> item + 1).limit(10).forEach(System.out::print);
//结果如下12345678910
2、通过Collection子类获取Stream
这个在本文的第一个例子中就展示了从List对象获取其对应的Stream对象，如果查看Java doc就可以发现Collection接口有一个stream方法，所以其所有子类都都可以获取对应的Stream对象。
publicinterfaceCollection<E> extendsIterable<E> {
//其他方法省略
defaultStream<E> stream() {
returnStreamSupport.stream(spliterator(), false);
}
}
流的几种构造方法：
// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();
例：
Arrays.asList("tony", "cafei", "aaron")//将字符串数组转换为列表
.stream()
.map(str -> str.toUpperCase())
.forEach(it -> System.out.println(it));
也可以简化成如下写法
Arrays.asList("tony", "cafei", "aaron")//将字符串数组转换为列表
.stream()
.map(String::toUpperCase)
.forEach(System.out::println);
参考：Stream语法详解
