目录
Java8新特性简介
一.Lambda表达式
1.为什么使用Lambda表示式
2.Lambda表达式
3.Lambda表达式语法
二.函数式接口
1.java内置四大核心核心函数式接口
三.方法引用与构造器引用
1.方法引用
2.构造器引用
3. 数组引用
四.Stream API
1.了解Stream
2. 什么是Stream
3.stream 的操作的三个步骤
4.创建Stream
5.由数组创建流
6.由值创建流
7.由函数创建流:创建无限流
8.Stream的中间操作
9.Stream的终止操作
10.并行流和串行流
Java8新特性简介
1.速度更快
2.代码更少(增加了新语法Lambda表达式)
3.强大的Stream Api
4.便于并行
5.最大化减少空指针异常Optional
一.Lambda表达式
1.为什么使用Lambda表示式
Lambda是一个匿名函数,我们可以把Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。
可以写出更简介,更灵活的代码。作为一种更紧凑的代码风格,使用Java的语言表达能力得到提升。
2.Lambda表达式
1.从匿名类到Lambda的转换
public class java8_4 {
public static void main(String[] args) {
//匿名内部类
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello Lambda!");
}
};
Runnable r2 = () -> {
System.out.println("Hello Lambda!");
};
Thread thread1=new Thread(r1);
thread1.start();
Thread thread2=new Thread(r2);
thread2.start();
}
}
//原来使用匿名内部类作为参数传递
TreeSet<String> ts=new TreeSet<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return Integer.compare(o1.length(),o2.length());
}
});
//Lambda表达式作为参数传递
TreeSet<String> ts2=new TreeSet<>((o1,o2)-> Integer.compare(o1.length(),o2.length()));
2.Lambda表达式语法
Lambda表达式在Java语言中引入了一个新的语法元素和操作符。这个操作符为"->",该操作符被称为Lambda操作符或箭头操作符,它将
Lambda分为部分:
左侧:指定了Lambda表达式需要的所有参数
右侧:指定了Lambda体,即Lambda表达体要执行的功能
3.Lambda表达式语法
语法格式一:无参,无返回值,lambda体只需要一条语句
Runnable r4=()-> System.out.println("Hello Lambda!");
语法格式二:Lambda需要一个参数
Consumer<String> fun=(args)->{System.out.println("Hello Lambda!");}
语法格式三:Lambda需要一个参数
Consumer<String> fun=args->System.out.println(args);
语法格式四:Lambda需要两个参数,并且有返回值
BinaryOperator<Long> bo=(x,y)->{ System.out.println("实际函数接口方法!"); return x+y; };
语法格式五:当Lambda体只有一个语句时,return与大括号可以省略
BinaryOperator<Long> bo=(x,y)->x+y;
语法格式六:
BinaryOperator<Long> bo=(Long x,Longy)->{
System.out.print("实现函数接口方法!");
return x+y;
}
类型推断
上述Lambda表达式中参数类型都是由编译器推断得出,Lambda表达式中无需指定类型,程序依然可以编译,Lambda表达式中无需指定类型,程序依然
可以编译,这是因为Javac根据程序的上下文,在后台推断出了参数的类型。Lambda表达式的类型依赖于上下文环境,是由编译器推断出来的。这就是所谓的
”类型推断“
二.函数式接口
什么是函数式接口
1.只包含一个抽象方法的接口,称为函数式接口。
2.你可以通过Lambda表达式来创建该接口的对象。(若Lambda表达式抛出一个受检异常,那么该异常需要在目标接口的抽象方法上进行声明)
3.我们可以在任意函数式接口上使用@FunctionalInterface注解,这样做可以检查它是否是一个函数式接口,同时Javadoc也会包含一条声明,说明这个接口是
一个函数式接口。
//自定义函数式接口
@FunctionalInterface
public interface MyNumber{
public double getValue();
}
//自定义函数式接口
@FunctionalInterface
public interface MyNumber<T>{
public T getValue(T t);
}
//作为参数传递Lambda表达式
public String toUpperString(MyFunc<String> mf,String str){
return mf.getValue(str);
}
//作为参数传递Lambda表达式
String newStr=toUpperString( (str)->str.toUpperCase(),"abcdef");
4.java内置四大核心核心函数式接口
函数式接口 | 参数类型 | 返回类型 | 用途 |
Consumer<T> 消费型接口 | T | void | 对类型为T的对象应用操作,包含方法void accept (T t); |
Supplier<T> 供给型接口 | 无 | T | 返回类型为T的对象,包含方法:T get(); |
Function<T,R>函数型接口 | T | R | 对类型为T的对象,应用操作,并返回结果。结果是R类型的对象。包含方法R apply(T t); |
Predicate<T>断定型接口 | T | boolean | 确定类型为T的对象是否满足某种约束,并返回boolean值,包含方法boolean test(T t); |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
| | | |
三.方法引用与构造器引用
1.方法引用
当要传递给lambda体的操作,已经有实现的方法,可以使用方法引用!
(实现抽象方法的参数列表,必须与方法引用方法的参数列表保持一致)
方法引用:使用操作符“::”将方法名和对象的名称分隔开来。
如下三种主要使用情况:
对象::实例方法
类::静态方法
类::实例方案
例如:(x)->System.out.println(X)
等同于: System.out::println
例如:BinaryOperator<Double> bo=(x,y)->Math.pow(x,y);
等同于:BinaryOperator<Double> bo=Math::pow;
例如 compare((x,y)->x.equals(y),"abcdef","abcdef");
等同于: compare(String::equals,"abc","abc");
注意:当需要引用方法的第一个参数是调用对象,并且第二个参数是需要引用方法的第二参数
(或无参数)时:ClassName::methodName
2.构造器引用
格式:ClassName::new
与函数式接口相结合,自动与函数式接口中方法兼容。
可以把构造器引用赋值给定义的方法,与构造器参数列表要与接口中抽象方法的参数列表一致
例如: Function<Integer,MyClass> fun=(n)->new MyClass(n); 等同于: Function<Integer,Myclass> fun=MyClass::new;
3. 数组引用
格式: type[]::new
例如: Function<Integer,Integer[]> fun=(n)-> new Integer[n]; 等同于:Function<Integer,Integer[]> fun=Integer::new;
四.Stream API
1.了解Stream
1.JAVA8中有两大最为重要的改变,第一个lambda表达式, 另外一个则是Stream API(Java.util.stream.*)
2.Stream是Java8中处理集合的关键的关键抽象概念,它可以指定你希望对集合进行操作,可以执行非常复杂的查找,过滤和映射数据等操作。
3.使用Stream API对集合数据进行操作,就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作,简而言之,Stream API提供了一种高效且易于使用的处理数据的方式
2. 什么是Stream
流(Stream) 到底是什么呢?
是数据渠道,用于操作数据源(集合,数组等)所生成的元素序列。
“集合讲的是数据,流讲得是计算!”
注意:
* 1.stream自己不会存储元素
* 2.stream不会改变源对象,相反,他们会返回一个持有结果的新stream
* 3.stream操作是延迟执行的,意味着他们会等到需要结果的时候才执行。
3.stream 的操作的三个步骤
创建Stream
* 一个数据源(如果:集合,数组),获取一个流
中间操作:
* 一个中间操作链,对数据源的数据进行操作
终止操作:
* 一个终止操作,执行中间操作链,并产生结果。
4.创建Stream
Java8中的collenction接口被扩展,提供两个获取流的方法
* default Stream <E> stream():返回一个顺序流
* default Stream <E> parallelStream:返回一个并行流
5.由数组创建流
Java8的Arrays的静态方法stream()可以获取数据流
Static <T> stream<T> stream(T[] array):返回一个流
重载形式,能够处理基本类型的数组
public static InStream stream(int[] array)
public static LongStream stream(long[] array)
public static DoubleStream stream(double[] array)
6.由值创建流
可以使用静态方法stream of(),通过显示值创建一个流,它可以接收任意数量的参数
public static<T> Stream <T> of(T ... valus) 返回一个流
7.由函数创建流:创建无限流
可以使用静态方法stream.iterate()和Stream.generate(),创建无限流。
* 迭代
public static <T> Stream<T> iterate(final T seed,final UnaryOperator<T>f)
* 生成
public static <T> Stream<T> generate(Supplier<T> s);
8.Stream的中间操作
多个中间操作可以连接起来形成一个流水线,除非流水线上触发终止操作,否则中间不会执行任何的处理!
而再终止操作时一次性全部处理,称为"惰性求值"
筛选与切片
* filter(Predicate p) 接收Lambda从流中排除某些元素
* distinct() 筛选,通过流所生成的元素的hashCode和equals去除重复元素
* limit(long maxSize) 截断流,使其元素不会超过给定数量
* skip(long n) 跳过元素,返回一个扔掉了前n个元素的流,若流中元素不足n个,则返回一个空流,与limit(n)互补
映射
* map(function f) 接收一个函数作为其参数,该函数会被应用到每个元素上,并将其映射成一个新的元素
* mapTodouble(ToDoubleFunction f) 接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的DoubleStream
* mapToInt(TOIntFunction f) 接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的LongStream
* flatMap(Function f) 接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流
排序
* sorted () 产生一个新流,其中按自然顺序比较
* Sorted(Comparator comp) 产生一个心流,其中按比较器顺序排序
* Stream的终止操作
* 终端操作会从流的流水线生成结果
9.Stream的终止操作
终端操作会从流的流水线生成结果。其结果可以是任何不是流的值,例如:List,Integer,甚至是void。
查找与匹配
方法 | 描述 |
allMatch(predicate p) | 检查是否匹配所有元素 |
anyMatch(predicate p) | 检查是否至少匹配一个元素 |
noneMatch | 检查是否没有匹配所有元素 |
findfirst() | 返回第一个元素 |
findAny() | 返回当前流中的任意元素 |
方法 | 描述 |
count | 返回流中元素总数 |
max(Comparator c) | 返回流中最大值 |
min(Comparator c) | 返回流中最小值 |
forEach(Consumer c) | 内部迭代(使用Collection接口需要用户去做迭代,称为外部迭代。相反,Stream API使用内部迭代---他帮你把迭代做了) |
归约
reduce(T iden,BinaryOperator b) | 可以将流中元素反复结合起来,得到一个值返回T |
reduce(BinaryOperate b) | 可以将流中的元素反复结合起来,得到一个值返回Optional<T> |
map和reduce的链接通常称为map-reduce模式
收集
方法 | 描述 |
collect(Collector c) | 将流转换为其他形式。接收一个Collector接口的实现,用于给Stream中元素汇总的方法 |
Collector接口中方法的实现决定了如何对流执行收集操作(如收集到List,set,Map)。但是Collector实用类提供了很多静态方法
可以方便的创建常见收集器实例,具体方法与实例如下表:
方法 | 返回类型 | 作用 |
toList | List<T> | 把流中元素收集到List |
List<Employee>emps=list.stream().collect(Collectors.toList()); | | |
toSet | Set<T> | 把流中元素收集到创建的集合 |
Set<Employee> emps=list.stream().collect(Collectors.toSet()); | | |
toCllection | Collection<T> | ;;把流中元素收集到创建的集合 |
Collection<Employee> emps=list.stream().collect(Collectors.toCollection(ArraysList::new)); | | |
counting | Long | 计算流中元素个数 |
long count=lits.stream().collect(Collectors.counting()); | | |
summingInt | Integer | 对流中元素的整数属性求和 |
inttotal=list.stream().collect(Collctors.summingInt(Employee::getSalary)); | | |
averagingInt | Double | 计算流中元素Integer属性的平均值 |
doubleavg=list.stream().collect(Collectors.averaginInt(Employee::getSalary)); | | |
summarizingInt | IntSummaryStatistics | 收集流中Integer属性的统计值 如:平均值
|
IntSummaryStatisticsisss=list.stream().collect(Collectors.summarizingInt(Employ::getSalary)) | | |
joining | String | 连接流中每个字符串 |
string str=list.stream().map(Employee::getName).collect(Collectors.joining()); | | |
maxBy | Optional<T> | 根据比较器选择最大值 |
Optional<Emp> max=list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary))); | | |
minBy | Optional<T> | 根据比较器选择最小值 |
Optional<Emp> min=list.stream().collect(Collectors.minBy(comparingInt)) | | |
reducing | 归约产生的类型 | 从一个作为累加器的初始值开始利用BinaryOperator 与流中元素逐个结合,从而归约成单个值 |
inttoal=list.stream().collect(Collectors,reducing(0,Employee::getSalar,Integer::sum)); | | |
collectingAndThen | 转换函数返回的类型 | 包裹另一个收集器,对其结果转换函数 |
inttoal=list.stream().collect(Collectors,collectingAndThen(Collectors.toList,List::size)); | | |
groupingBy | Map<K,List<T>> | 根据某属性值对流分组,属性为K,结果为V |
Map<Emp.Status,List<Emp>> map=list.stream().collect(Collectoes.groupingBy(Employee::getStatus)); | | |
partitioningBy | Map<Boolean,List<T>> | 根据true或false进行分区 |
Map<Boolan,List<Emp>> vd=list.stream().collect(Collectors.partitioningBy(Employee::getManage));
10.并行流和串行流
并行流就是把一个内容分成多个数据块,并用不同的线程分别处理每个数据块的流
Java8中将并行进行了优化,我们可以很容易的对数据进行并行操作,Stream API可以声明性得通过parallel()与sequential()在并行流与顺序流之间进行切换