[color=green][size=medium][b]java8之新特性介绍(java 8 new features)[/b][/size][/color]
[size=medium][b]一、可以在接口中写方法体[/b][/size]
在接口中增加新方法时,可以带方法体。
带来的好处:
当新接口发布时,以前实现该接口的类,无需改动。
即:无需实现新添加的方法。
语法:使用 [color=brown][b]default[/b][/color] 关键字
注意:
1、实现多个接口时,接口中有重名的方法体的实现。
如果同时实现两个具有相同方法名且实现了该方法的接口,
需要提供自己对该方法的实现。才可以解决冲突。
sayHello() 重复,类 C 需要实现自己的 sayHello()
2、类方法的 优先级 高于 接口方法
接口 A 和 类 B 中都定义了方法 sayHello() 的实现,
类 C 优先使用 类 B 的方法。
3、接口中不可以重写 java.lang.Object 里面的方法
4、可以在接口中定义 static 方法
[size=medium][b]二、Functional Programming [color=brown]VS.[/color] Object Oriented Programming[/b][/size]
[b]Functional Programming with Java 8[/b]
https://www.youtube.com/watch?v=LcfzV38YDu4
面向函数的编程(Functional Programming)是指对于只有一个方法的接口可以使用 Lambda 表达式实现。
只有一个方法的接口很好的一个例子就是: java.lang.Comparable 接口。
它只有一个方法: compareTo(Object obj)
[size=medium][b]三、Lambda Expression ( -> 斜着看 )[/b][/size]
[img]http://dl2.iteye.com/upload/attachment/0120/5007/a283f7f2-7eaf-3b2c-b871-614174ffb32c.png[/img]
Lambda Expression VS. Anonymous inner class
对于只有一个方法的接口的实现类,写实现类时,只需提供( 参数 + Lambda + 方法体 )即可。
说明:
[img]http://dl2.iteye.com/upload/attachment/0120/5013/2edd9df3-c11b-342c-8d75-2add928f01e5.png[/img]
[b]为接口引入了一个新的注解:@FunctionalInterface[/b]
表示该接口为函数式接口,只允许有一个方法。否则编译器报错。
[size=medium][b]四、为 java.lang.Iterable 接口增加了 forEach() 方法[/b][/size]
[b]NOTE:[/b]
1、java 8 之前, java.lang.Iterable 接口只有一个方法:
java.util.Iterator<T> iterator()
2、java.util.Collection 接口,继承了 java.lang.Iterable 接口。
[size=medium][b]五、Streaming API[/b][/size]
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.
-
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.
[b]1) In stream we have two types of methods:[/b]
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:
[b]2) Stream is once used, it can't be reused:[/b]
--
[b]中间操作[/b]
该操作会保持 stream 处于中间状态,允许做进一步的操作。它返回的还是的 Stream,允许更多的链式操作。常见的中间操作有:
- filter():对元素进行过滤;
- sorted():对元素排序;
- map():元素的映射;
- distinct():去除重复元素;
- subStream():获取子 Stream 等。
例如,下面是对一个字符串集合进行过滤,返回以“s”开头的字符串集合,并将该集合依次打印出来:
这里的 filter(...) 就是一个中间操作,该中间操作可以链式地应用其他 Stream 操作。
[b]终止操作[/b]
该操作必须是流的最后一个操作,一旦被调用,Stream 就到了一个终止状态,而且不能再使用了。常见的终止操作有:
- forEach():对每个元素做处理;
- toArray():把元素导出到数组;
- findFirst():返回第一个匹配的元素;
- anyMatch():是否有匹配的元素等。
例如,下面是对一个字符串集合进行过滤,返回以“s”开头的字符串集合,并将该集合依次打印出来:
这里的 forEach(...) 就是一个终止操作,该操作之后不能再链式的添加其他操作了。
-
转载请注明
原文出处:http://lixh1986.iteye.com/blog/2329376
引用:
[url]http://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html[/url]
[size=medium][color=green]Java 8 new features with Example
https://www.youtube.com/playlist?list=PLsyeobzWxl7qbvNnJKjYbkTLn2w3eRy1Q
[/color][/size]
[size=medium][color=green]Java 8 Stream API Features Lambda Expression
https://www.youtube.com/playlist?list=PLsyeobzWxl7otduRddQWYTQezVul0xIX6
[/color][/size]
[url]http://programtalk.com/java/java-8-new-features/[/url]
更多:
Java 9 新特性
[url]http://programtalk.com/java/java-9-new-features/[/url]
-
[size=medium][b]一、可以在接口中写方法体[/b][/size]
在接口中增加新方法时,可以带方法体。
带来的好处:
当新接口发布时,以前实现该接口的类,无需改动。
即:无需实现新添加的方法。
语法:使用 [color=brown][b]default[/b][/color] 关键字
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!
}
}
[size=medium][b]二、Functional Programming [color=brown]VS.[/color] Object Oriented Programming[/b][/size]
[b]Functional Programming with Java 8[/b]
https://www.youtube.com/watch?v=LcfzV38YDu4
面向函数的编程(Functional Programming)是指对于只有一个方法的接口可以使用 Lambda 表达式实现。
只有一个方法的接口很好的一个例子就是: java.lang.Comparable 接口。
它只有一个方法: compareTo(Object obj)
[size=medium][b]三、Lambda Expression ( -> 斜着看 )[/b][/size]
[img]http://dl2.iteye.com/upload/attachment/0120/5007/a283f7f2-7eaf-3b2c-b871-614174ffb32c.png[/img]
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.");
}
}
说明:
[img]http://dl2.iteye.com/upload/attachment/0120/5013/2edd9df3-c11b-342c-8d75-2add928f01e5.png[/img]
[b]为接口引入了一个新的注解:@FunctionalInterface[/b]
表示该接口为函数式接口,只允许有一个方法。否则编译器报错。
// 只允许有一个方法。否则编译器报错。
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
[size=medium][b]四、为 java.lang.Iterable 接口增加了 forEach() 方法[/b][/size]
[b]NOTE:[/b]
1、java 8 之前, java.lang.Iterable 接口只有一个方法:
java.util.Iterator<T> 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<Integer>{
@Override
public void accept(Integer t) {
System.out.println(t);
}
}
public class Java8ForEach {
public static void main(String[] args) {
List<Integer> list =Arrays.asList(1,2,3,5,6);
// normal loop
for(Integer i : list){
System.out.println(i);
}
// Java 8 forEach - normal
Consumer<Integer> 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));
}
}
[size=medium][b]五、Streaming API[/b][/size]
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(List<Integer> bigList){
List<Integer> filteredList = new ArrayList<>();
for (Integer p : bigList) {
if (p > 40) {
filteredList.add(p);
}
}
return filteredList;
}
//Java 8:
public List listFilter(List<integer> bigList){
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.
[b]1) In stream we have two types of methods:[/b]
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:
List<Integer> values = Arrays.asList(4,5,6,7,8);
values.stream().filter(i->{
Sysout.out.println("Hello");
return true;
});
[b]2) Stream is once used, it can't be reused:[/b]
Stream<Integer> s = values.stream();
s.forEach(Sysout.out::println); // works
s.forEach(Sysout.out::println); // throws Exception
--
[b]中间操作[/b]
该操作会保持 stream 处于中间状态,允许做进一步的操作。它返回的还是的 Stream,允许更多的链式操作。常见的中间操作有:
- filter():对元素进行过滤;
- sorted():对元素排序;
- map():元素的映射;
- distinct():去除重复元素;
- subStream():获取子 Stream 等。
例如,下面是对一个字符串集合进行过滤,返回以“s”开头的字符串集合,并将该集合依次打印出来:
list.stream()
.filter((s) -> s.startsWith("s"))
.forEach(System.out::println);
这里的 filter(...) 就是一个中间操作,该中间操作可以链式地应用其他 Stream 操作。
[b]终止操作[/b]
该操作必须是流的最后一个操作,一旦被调用,Stream 就到了一个终止状态,而且不能再使用了。常见的终止操作有:
- forEach():对每个元素做处理;
- toArray():把元素导出到数组;
- findFirst():返回第一个匹配的元素;
- anyMatch():是否有匹配的元素等。
例如,下面是对一个字符串集合进行过滤,返回以“s”开头的字符串集合,并将该集合依次打印出来:
list.stream()
.filter((s) -> s.startsWith("s"))
.forEach(System.out::println);
这里的 forEach(...) 就是一个终止操作,该操作之后不能再链式的添加其他操作了。
-
转载请注明
原文出处:http://lixh1986.iteye.com/blog/2329376
引用:
[url]http://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html[/url]
[size=medium][color=green]Java 8 new features with Example
https://www.youtube.com/playlist?list=PLsyeobzWxl7qbvNnJKjYbkTLn2w3eRy1Q
[/color][/size]
[size=medium][color=green]Java 8 Stream API Features Lambda Expression
https://www.youtube.com/playlist?list=PLsyeobzWxl7otduRddQWYTQezVul0xIX6
[/color][/size]
[url]http://programtalk.com/java/java-8-new-features/[/url]
更多:
Java 9 新特性
[url]http://programtalk.com/java/java-9-new-features/[/url]
-