函数式接口(Functional Interfaces):如果一个接口定义个唯一一个抽象方法,那么这个接口就成为函数式接口。同时,引入了一个新的注解:@FunctionalInterface。可以把他它放在一个接口前,表示这个接口是一个函数式接口。这个注解是非必须的,只要接口只包含一个方法的接口,虚拟机会自动判断,不过最好在接口上使用注解 @FunctionalInterface 进行声明。在接口中添加了 @FunctionalInterface 的接口,只允许有一个抽象方法,否则编译器也会报错。
/**
* 函数式接口
*/
@FunctionalInterface
interface Sum{
int add(int value);
}
lambda无法单独出现,需要一个函数式接口来盛放,可以说lambda表达式方法体是函数式接口的实现,lambda实例化函数式接口,可以将函数作为方法参数,或者将代码作为数据对待。
//1.不接受参数,直接返回1
()->1
//2.接受两个int类型的参数,返回这两个参数的和
(int x,int y )-> x+y
//3.接受x,y两个参数,JVM根据上下文推断参数的类型,返回两个参数的和
(x,y)->x+y
//4.接受一个字符串,打印该字符串,没有返回值
(String name)->System.out.println(name)
//5.接受一个参数,JVM根据上下文推断参数的类型,打印该参数,没有返回值,只有一个参数可以省略圆括号
name->System.out.prinln(name)
//6.接受两个String类型参数,分别输出,没有返回值
(String name,String sex)->{System.out.println(name);System.out.println(sex)}
//7.接受呀一个参数,返回它本身的2倍
x->2*x
/**
* 函数式接口
* @param <A>
* @param <B>
*/
@FunctionalInterface
interface Transform<A,B>{
B transform(A a);
}
//传统方式使用接口
Transform<String ,Integer> transform1 = new Transform<String, Integer>() {
@Override
public Integer transform(String s) {
return Integer.valueOf(s);
}
} ;
//Lambda方式使用接口,就是这么简单粗暴,没脾气
Transform<String,Integer> transform2 = (s)-> Integer.valueOf(s);
public static void main(String[] args) {
int num = 6;//局部变量
Sum sum = value -> {
// num = 8; 这里会编译出错
return num + value;
};
sum.add(8);
}
/**
* 函数式接口
*/
@FunctionalInterface
interface Sum{
int add(int value);
}
public int num1 = 6;
public static int num2 = 8;
private int getSum(){
Sum sum = value -> {
num1 = 10;
num2 = 10;
return num1 + num2;
};
return sum.add(1);
}
/**
* 函数式接口
*/
@FunctionalInterface
interface Sum{
int add(int value);
}
在lambda表达式中,方法引用是一种简化写法,引用的方法就是Lambda表达式的方法体的实现
左边是类名或者实例名,中间的“::”是方法引用符号,右边是相应的方法名
静态方法引用, 实例方法引用, 构造方法引用
public static void main(String[] args){
//传统方式
Transform<String ,Integer> transform1 = new Transform<String, Integer>() {
@Override
public Integer transform(String s) {
return C_StaticMethodReference.strToInt(s);
}
};
int result1 = transform1.transform("100");
//Lambda方式
Transform<String,Integer> transform2 = C_StaticMethodReference ::strToInt;
int result2 = transform2.transform("200");
}
static int strToInt(String str){
return Integer.valueOf(str);
}
/**
* 函数式接口
* @param <A>
* @param <B>
*/
@FunctionalInterface
interface Transform<A,B>{
B transform(A a);
}
public static void main(String[] args){
//传统方式
Transform<String ,Integer> transform1 = new Transform<String, Integer>() {
@Override
public Integer transform(String s) {
return new Obj().strToInt(s);
}
};
int result1 = transform1.transform("100");
//Lambda方式
Obj obj = new Obj();
Transform<String,Integer> transform2 = obj::strToInt;
int result2 = transform2.transform("200");
}
/**
* 函数式接口
* @param <A>
* @param <B>
*/
interface Transform<A,B>{
B transform(A a);
}
/**
* 实例对象类
*/
static class Obj{
public int strToInt(String str){
return Integer.valueOf(str);
}
}
//传统方式
Factory factory1 = new Factory() {
@Override
public Parent create(String name, int age) {
return new Boy(name,age);
}
};
Boy boy = (Boy) factory1.create("小明",18);
factory1 = new Factory() {
@Override
public Parent create(String name, int age) {
return new Girl(name,age);
}
};
Girl girl = (Girl) factory1.create("小红",18);
//Lambda方式
Factory<Boy> boyFactory = Boy::new;
Boy boy1 = boyFactory.create("小明",18);
Factory<Girl> girlFactory = Girl::new;
Girl girl1 = girlFactory.create("小红",18);
//工厂类接口
public interface Factory<T extends Parent> {
T create(String name,int age);
}
//父类
public class Parent {
private String name ;
private int age;
public Parent(String name, int age) {
this.name = name;
this.age = age;
}
public void doSome(){
}
}
//男孩类
public class Boy extends Parent {
public Boy(String name, int age) {
super(name, age);
}
@Override
public void doSome() {
System.out.println("我是个男孩");
}
}
//女孩类
public class Girl extends Parent {
public Girl(String name, int age) {
super(name, age);
}
@Override
public void doSome() {
System.out.println("我是个女孩");
}
}
/**
* Predicate接口:输入一个参数,返回一个boolean值,内置了许多用于逻辑判断的默认方法
*/
public class F_Predicate {
public void predicateTest(){
Predicate<String> predicateStr = s -> s.length()>8;
boolean testResult = predicateStr.test("test");//需要api 24
testResult = predicateStr.negate().test("test");//取反,也就是s.length<=8
Predicate<Object> predicateObj = Objects::nonNull;
Object obj = null;
testResult = predicateObj.test(obj);//判断是否为空
}
}
/**
* consumer接口:对输入的参数进行操作。有输入没输出
*/
private static void consumerTest(){
Consumer<Integer> add5 = (p) -> {
System.out.println("old value:" + p);
p = p + 5;
System.out.println("new value:" + p);
};
add5.accept(10);
}
/**
* Function接口:接受一个参数,返回单一的结果。默认的方法(andThen)可将多个函数串在一起,形成复合Funtion(有输入,有输出)结果
*/
public static void functionTest(){
Function<String, Integer> toInteger = Integer::valueOf;
//toInteger的执行结果作为第二个backToString的输入
Function<String, String> backToString = toInteger.andThen(String::valueOf);
String result = backToString.apply("1234");
System.out.println(result);
Function<Integer, Integer> add = (i) -> {
System.out.println("frist input:" + i);
return i * 2;
};
Function<Integer, Integer> zero = add.andThen((i) -> {
System.out.println("second input:" + i);
return i * 0;
});
Integer res = zero.apply(8);
System.out.println(res);
}
/**
* Supplier接口:返回一个给定类型的结果。不需要输入参数,无输入有输出
*/
private static void supplierTest(){
Supplier<String> supplier = () -> "我就是输出";
String s = supplier.get();
System.out.println(s);
}
//创建一个集合
List<String> list = new ArrayList<>();
list.add("a1");list.add("a2");list.add("a3");list.add("b1");list.add("b2");list.add("b3");
结合Predicate接口,Filter对流对象中的所有元素进行过滤,该操作是一个中间操作,这意味着你可以在操作返回结果的基础上进行其他操作
public static void sreamFilterTest(List<String> lists){ //要明确这list的泛型类型,否则jvm不能根据上下文确定参数类型
lists.stream().filter((s -> s.startsWith("a"))).forEach(System.out::println);//将开头是a的过滤出来
//等价于以上操作
Predicate<String> predicate = (s) -> s.startsWith("a");//将开头是a的过滤出来
lists.stream().filter(predicate).forEach(System.out::println);
//连续过滤
Predicate<String> predicate1 = (s -> s.endsWith("1"));//将开头是a,并且结尾是1的过滤出来
lists.stream().filter(predicate).filter(predicate1).forEach(System.out::println);
}
结合Comparator,该操作返回一个排序过后的流的视图,原始流的顺序不会改变。通过Comparator来指定排序规则,默认是自然排序
private static void streamSortedTest(List<String> list){
//默认排序
list.stream().filter(s -> s.startsWith("a")).forEach(System.out::println);
System.out.println("- - - - - - - - -");
//自定义排序
list.stream().sorted(((s, t1) -> t1.compareTo(s))).filter(s -> s.startsWith("a")).forEach(System.out::println);
}
结合Function接口,该操作能将流对象中的每一个元素映射为另一个元素,实现元素类型的转换。
private static void streamMapTest(List<String> list){
list.stream().map(String::toUpperCase).sorted((s, t1) -> t1.compareTo(s)).forEach(System.out::println);
System.out.println("- - - - - - ");
//自定义映射规则
Function<String,String> function = s -> {return s + ".map3";};
list.stream().map(function).forEach(System.out::println);
}
用来判断某个predicate是否和流对象相匹配,最终返回boolean类型的结果
private static void streamMatchTest(List<String> list){
//流对象中只要有一个元素匹配就返回true
boolean anyStartWithA = list.stream().anyMatch(s -> s.startsWith("a"));
System.out.println("集合中是否有以'a'来头:"+ anyStartWithA);
//流对象中每一个元素都匹配才返回true
boolean allStartWithA = list.stream().allMatch(s -> s.startsWith("a"));
System.out.println("集合中每一个都是以'a'开头:"+ allStartWithA);
//流对象中没有匹配时返回true
boolean noneStartWithA = list.stream().noneMatch(s -> s.startsWith("c"));
System.out.println("集合中没有以'c'开头:"+ noneStartWithA);
}
在对经过变换后,将变换的stream元素收集,比如将这些元素存在集合中,可以使用stream提供的collect方法
private static void streamCollectTest(List<String> list){
List<String> listNew = list.stream().filter(s -> s.startsWith("b")).sorted().collect(Collectors.toList());
System.out.println(listNew );
}
允许我们用自己的方式计算元素或者将一个stream中元素以某种规律关联
private static void streamReduceTest(List<String> list){
Optional<String> optional = list.stream().sorted().reduce((s, s2) -> {
System.out.println(s+"-"+s2);
return s+"-"+s2;
});
}
用来统计流中元素的总数
private static void streamCountTest(List<String> list){
long count = list.stream().filter(s -> s.startsWith("b")).count();
System.out.println("以'b'开头的数量:"+ count);
}
并行Stream:基于Fork-join并行分解框架实现,将大数据集合切分为多个小数据结合交给不同的线程去处理,这样在多核处理情况下,性能会得到很大的提高。 这和MapReduce的设计理念一致:大任务化小,小任务再分配到不同的机器执行。只不过这里的小任务是交给不同的处理器。 结果是性能提高50%,单核下还是串行流性能比较好,并行流的使用场景是多核+大数据
//创建一个大集合
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000000; i++) {
UUID uuid = UUID.randomUUID();
list.add(uuid.toString());
}
//并行stream
private static void parallelStreamSortedTest(List<String> list){
long startTime = System.nanoTime();//返回最准确的可用系统计时器的当前值,以毫微秒为单位。
long count = list.parallelStream().sorted().count();
long endTime = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
System.out.printf("并行排序花费时间:%d ms",millis);
}
//串行stream
private static void streamSortedTest(List<String> list){
long startTime = System.nanoTime();//返回最准确的可用系统计时器的当前值,以毫微秒为单位。
long count = list.stream().sorted().count();
long endTime = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
System.out.printf("串行排序花费时间:%d ms",millis);
}
本文由 Alicyu 创作,如果您觉得本文不错,请随意赞赏
采用 知识共享署名4.0 国际许可协议进行许可
本站文章除注明转载/出处外,均为本站原创或翻译,转载前请务必署名
原文链接:https://www.alicyu.com/archives/jdk8
最后更新:2019-10-18 15:29:13
Update your browser to view this website correctly. Update my browser now