java8之新特性介绍（java 8 new features）

[color=green][size=medium][b]java8之新特性介绍（java 8 new features）[/b][/size][/color]

[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]


-