一、可以在接口中写方法体
在接口中增加新方法时,可以带方法体。
带来的好处:
当新接口发布时,以前实现该接口的类,无需改动。
即:无需实现新添加的方法。
语法:使用 default 关键字
interface A{ void show(); default void sayHello(){ System.out.println("Hello, World!"); } }
注意:
1、实现多个接口时,接口中有重名的方法体的实现。
如果同时实现两个具有相同方法名且实现了该方法的接口,
需要提供自己对该方法的实现。才可以解决冲突。
sayHello() 重复,类 C 需要实现自己的 sayHello()
interface A{ void showA(); default void sayHello(){ System.out.println("Hello, A!"); } } interface B{ void showB(); default void sayHello(){ System.out.println("Hello, B!"); } } class C implements A,B{ public void sayHello(){ System.out.println("Hello, C!"); } public static void main(String[] args){ C c = new C(); c.sayHello(); // Hello, C! } }
2、类方法的 优先级 高于 接口方法
接口 A 和 类 B 中都定义了方法 sayHello() 的实现,
类 C 优先使用 类 B 的方法。
interface A{ void showA(); default void sayHello(){ System.out.println("Hello, A!"); } } class B{ public void sayHello(){ System.out.println("Hello, B!"); } } class C extends B implements A{ public static void main(String[] args){ C c = new C(); c.sayHello(); // Hello, B! } }
3、接口中不可以重写 java.lang.Object 里面的方法
interface A { // can't define a equals method in interface. default public boolean equals(){ } }
4、可以在接口中定义 static 方法
interface A{ void showA(); static void sayHello(){ System.out.println("Hello, A!"); } } class C { public static void main(String[] args){ A.sayHello(); // Hello, A! } }
二、Functional Programming VS. Object Oriented Programming
Functional Programming with Java 8
https://www.youtube.com/watch?v=LcfzV38YDu4
面向函数的编程(Functional Programming)是指对于只有一个方法的接口可以使用 Lambda 表达式实现。
只有一个方法的接口很好的一个例子就是: java.lang.Comparable 接口。
它只有一个方法: compareTo(Object obj)
三、Lambda Expression ( -> 斜着看 )
Lambda Expression VS. Anonymous inner class
对于只有一个方法的接口的实现类,写实现类时,只需提供( 参数 + Lambda + 方法体 )即可。
interface A{ void show(); } public class LambdaDemo{ public static void main(String[] args){ A obj; // old obj = new A(){ public void show(){ System.out.println("Hello"); } } // java 8 obj = () -> { System.out.println("Multiple"); System.out.println("Lines ... "); } // or obj = () -> System.out.println("Single line."); } }
说明:
为接口引入了一个新的注解:@FunctionalInterface
表示该接口为函数式接口,只允许有一个方法。否则编译器报错。
// 只允许有一个方法。否则编译器报错。 @FunctionalInterface public interface Runnable { public abstract void run(); }
四、为 java.lang.Iterable 接口增加了 forEach() 方法
NOTE:
1、java 8 之前, java.lang.Iterable 接口只有一个方法:
java.util.Iterator
2、java.util.Collection 接口,继承了 java.lang.Iterable 接口。
import java.util.Arrays; import java.util.List; import java.util.function.Consumer; class IConsumer implements Consumer{ @Override public void accept(Integer t) { System.out.println(t); } } public class Java8ForEach { public static void main(String[] args) { List list =Arrays.asList(1,2,3,5,6); // normal loop for(Integer i : list){ System.out.println(i); } // Java 8 forEach - normal Consumer action = new IConsumer(); list.forEach(action); // Java 8 forEach - use lambda expressions. // see how we do it in one liner list.forEach(each -> System.out.println(each)); } }
五、Streaming API
Java collections got a new package java.util.Stream.
classes in this package provide a stream API.
And supports functional-style operations on streams of elements.
Stream API enables bulk operations like sequential or parallel map-readuce on Collections.
//Java 7 or earlier: public List listFilter(ListbigList){ List filteredList = new ArrayList<>(); for (Integer p : bigList) { if (p > 40) { filteredList.add(p); } } return filteredList; }
//Java 8: public List listFilter(ListbigList){ return bigList .stream() .filter(p -> p > 40) .collect(Collectors.toList()); }
-
So, if you know, in this world, it's an information age, we have a concept of "Big Data", "Haddoop", we have to process huge amount of data.
1) In stream we have two types of methods:
1. Intermediate method. Like: filter(), map()
lazy, it can't give result immediately until you call a terminate method.
2. Terminate method. Like: findFirst(), forEach()
Example Given:
Listvalues = Arrays.asList(4,5,6,7,8); values.stream().filter(i->{ Sysout.out.println("Hello"); return true; });
2) Stream is once used, it can't be reused:
Streams = values.stream(); s.forEach(Sysout.out::println); // works s.forEach(Sysout.out::println); // throws Exception
--
中间操作
该操作会保持 stream 处于中间状态,允许做进一步的操作。它返回的还是的 Stream,允许更多的链式操作。常见的中间操作有:
- filter():对元素进行过滤;
- sorted():对元素排序;
- map():元素的映射;
- distinct():去除重复元素;
- subStream():获取子 Stream 等。
例如,下面是对一个字符串集合进行过滤,返回以“s”开头的字符串集合,并将该集合依次打印出来:
list.stream() .filter((s) -> s.startsWith("s")) .forEach(System.out::println);
这里的 filter(...) 就是一个中间操作,该中间操作可以链式地应用其他 Stream 操作。
终止操作
该操作必须是流的最后一个操作,一旦被调用,Stream 就到了一个终止状态,而且不能再使用了。常见的终止操作有:
- forEach():对每个元素做处理;
- toArray():把元素导出到数组;
- findFirst():返回第一个匹配的元素;
- anyMatch():是否有匹配的元素等。
例如,下面是对一个字符串集合进行过滤,返回以“s”开头的字符串集合,并将该集合依次打印出来:
list.stream() .filter((s) -> s.startsWith("s")) .forEach(System.out::println);
这里的 forEach(...) 就是一个终止操作,该操作之后不能再链式的添加其他操作了。
-
转载请注明
原文出处:http://lixh1986.iteye.com/blog/2329376
引用:
http://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html
Java 8 new features with Example
https://www.youtube.com/playlist?list=PLsyeobzWxl7qbvNnJKjYbkTLn2w3eRy1Q
Java 8 Stream API Features Lambda Expression
https://www.youtube.com/playlist?list=PLsyeobzWxl7otduRddQWYTQezVul0xIX6
http://programtalk.com/java/java-8-new-features/
更多:
Java 9 新特性
http://programtalk.com/java/java-9-new-features/
-