在使用Stream之前先介绍几个概念:1、函数式接口 2、常用的函数式接口 3、Lambda 4、方法引用
1、函数式接口
1.只定义了一个抽象方法的接口。
2.JDK8接口中的静态方法和默认方法,都不算是抽象方法。
3.接口默认继承java.lang.Object,所以如果接口显示声明覆盖了Object中方法,那么也不算抽象方法。
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
2、常用的函数式接口
1.Predicate
接口接受一个输入参数,返回一个布尔值结果。该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑(比如:与,或,非)。可以用于接口请求参数校验、判断新老数据是否有变化需要进行更新操作。
boolean test(T t); 例:Predicate
2.Consumer
void accept(T t); 例:Consumer
3.Supplier
4.Function<T,R > 对类型为T的对象应用操作,并返回结果,结果是R类型的对象 R apply(T t);
5.UnaryOperator
6.BiFunction<T,U,R> 接口对类型为T和U的对象应用操作,返回类型为R的对象。 R apply(T t, U u);
7.BinaryOperator
8.Comparator
3、Lambda
public static void main(String[] args) {
int c = 10;
MathOperation m = (a,b)->a+b+c;//编译报错
c = 1;
}
interface MathOperation {
int operation(int a, int b);
}
4、方法引用
格式:
四种不同类型的方法引用:
引用静态方法 ContainingClass::staticMethodName 例: String::valueOf,对应的Lambda:(s) -> String.valueOf(s)
引用特定对象的实例方法 containingObject::instanceMethodName 例子: x::toString,对应的Lambda:() -> this.toString()
引用特定类型的任意对象的实例方法 ContainingType::methodName 例子: String::toString,对应的Lambda:(s) -> s.toString()
引用构造函数 ClassName::new 例子: String::new,对应的Lambda:() -> new String()
5、Optional类
Optional 类主要解决的问题是空指针异常,它本质上是包含有可选值的包装类,可以含有对象也可以为空
常用方法:
isPresent() – 如果有值则返回true
get() – 如果值存在则返回值
orElse(T other) –如果值存在则返回值,否则返回other
ifPresent(Consumer<? super T> consumer) – 如果值存在,则执行consumer
Optional<String> optional = Optional.of("hello");
if (optional.isPresent()){
String hello = optional.get();
}
String world = optional.orElse("world");
6、Stream
Arrays.asList("hello", "world", "hello world").stream().mapToInt(item -> { int length = item.length(); System.out.println(item); return length;}).filter(length -> length == 5).findFirst().ifPresent(System.out::println);
1.Stream的创建
//从单个元素创建
Stream.of(val1, val2, …)
//从集合创建
someList.stream()
//从数组创建
Stream.of(someArray)
Arrays.stream(someArray)
//创建无限流
IntStream.range(0,100)
IntStream.iterate(0, i -> i + 1)
2.中间操作
Stream.of(“abc”, “”, “bc”, “efg”).filter(string - > !string.isEmpty()).collect(Collectors.toList());
Arrays.asList(3, 2, 2, 3, 7, 3, 5).stream().map(i-> i*i).distinct().collect(Collectors.toList());
IntStream.range(0,100).limit(10).forEach(System.out::println);
Stream.of(1,2,3,4,5,6).peek(n-> System.out.println(n*2)).map(n->n+"h").forEach(System.out::println) ;
Stream.of(5,8,7,3,4,1,9).sorted(Integer::compare).forEach(System.out::println);Stream.of(5,8,7,3,4,1,9).sorted((a,b)->a-b).forEach(System.out::println);
students.stream().sorted(Comparator.comparingInt(Student::getAge).reversed().thenComparing(Student::getName)).forEach(System.out::println);
List<String> list1 = Arrays.asList("a","b","c");
List<String> list2 = Arrays.asList("d","e","c");List<String> list3 = Arrays.asList("f","g","c");List<List<String>> list = Arrays.asList(list1,list2,list3);List<String> result = list.stream().flatMap(stringList->stringList.stream()).distinct().collect(Collectors.toList())
3.终端操作
Stream.of(5,8,7,3,4,1,9).min(Integer::compareTo).get() ;
Stream.of(5,8,7,3,4,1,9).max(Integer::compareTo).get() ;
Stream.of(5,8,7,3,4,1,9).anyMatch(num->num==9);
Stream.of(5,8,7,3,4,1,9).allMatch(num->num==9);
Stream.of(5,8,7,3,4,1,9).count();
Stream.of(5,8,7,3,4,1,9).findAny().get();
Stream.of(5,8,7,3,4,1,9).findFirst().get();
/*Reduce:从一个作为累加器的初始值开始,利用binaryOperator与流中的元素逐个结合,从而将流归约为单个值 。reduce操作每处理一个元素总是创建一个新值*/
Stream.of(5,8,7,3,4,1,9).reduce(1,(sum,item)->sum+item);
Stream.of(5,8,7,3,4,1,9).reduce(Integer::sum).get();
/*Collect:接收的参数是将流中的元素累积到汇总结果的各种方式(称为收集器)。修改现存的值,而不是每处理一个元素,创建一个新值*/
students.stream().map(student -> student.getName()).collect(Collectors.toList());
students.stream().map(student -> student.getName()).collect(Collectors.toSet());
students.stream().collect(Collectors.toMap(s1 -> s1.getName(), s2 -> s2.getAge()));
Map<String, List<Student>> map = students.stream().collect(Collectors.groupingBy(Student::getName));
4.一个比较好用的case
//多线程处理有序的集合
IntStream.range(0, files.size()).parallel().forEach(fileIndex -> {do something about files});