java8新特性

java不愧是我们程序猿的天堂，他版本更新的速度快的令人发指。我们现在项目还在使用1.7版本，但是已经出到了14。虽然新版本大家都是用的不多，不过1.8版本已经被大家广泛的应用起来，还是有必要学习学习的。今天我们也来看看1.8中都有哪些新的特性。

下面先看一段代码，首先定义一个接口类。可以发现接口类不再单单的只有方法没有实现，现在他也可以有default修饰的方法实现，也可以有静态方法。这就是java8中的其中一个新特性默认方法。如果这个接口只有一个未被实现的方法，那么这个接口又可以被称为函数式接口。

package eightNew;

/**
 * 这是一个函数式接口
 */
public interface Operation {

    /**有且仅有一个抽象方法，但是可以有多个非抽象方法的接口**/
    int operation(int a,int b);

    default void print(){

        System.out.println("java8新特性，接口类里面可以有default修饰的默认方法，此方法是允许实现的");
    }

    default void say(){

        System.out.println("hello world");
    }

    static void write(){

        System.out.println("静态方法不能被他的实现类调用。因为如果实现了两个类，他们都有相同的一个静态方法，这时候会有问题。");
    }

}

package eightNew;

public class MathOperation implements Operation {

    @Override
    public int operation(int a, int b) {
        return 0;
    }

    public static void main(String[] args) {
        MathOperation mathOperation = new MathOperation();
        mathOperation.print();
        mathOperation.say();

        Operation.write();
    }
}

package eightNew;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class LambdaTest {
    public static void main(String[] args) {

        List<String> lists = new ArrayList<>();
        lists.add("a");
        lists.add("b");
        lists.add("c");

        //java7的写法
        Collections.sort(lists, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.compareTo(s2);
            }
        });

        //java8的写法
        Collections.sort(lists,(s1,s2) -> s1.compareTo(s2));

        /**线程的写法**/
        Thread thread = new Thread(() -> System.out.println("线程开始..."));
        thread.start();

        /**模仿上面的写法,找一下规律**/

        //不声明参数类型
        LambdaTest.operate(2,3,(a,b) -> a + b);

        //声明参数类型
        LambdaTest.operate(2,3,(int a,int b) -> a + b);

        //返回语句加上大括号
        LambdaTest.operate(2,3,(int a,int b) -> {return a + b;});

        /**方法引用**/
        //如果接口类已经有了具体的实现，那么可以通过方法引用来调用
        MathOperation mathOperation = new MathOperation();
        LambdaTest.operate(1,2,mathOperation::operation);
    }

    /**
     * 引用了接口类的方法
     * @param a
     * @param b
     * @param operation
     */
    public static void operate(int a, int b, Operation operation){
        operation.operation(a,b);
    }

    public int add(int a,int b){
        a = a + b;
        System.out.println("这是一个add()方法...");
        return a;
    }
}

上面的代码是针对java中lambda表达式和方法引用的应用。方法引用比较简单，就像我们之前的类.方法差不多。

如果有一个接口类，然后有一个引用到这个接口的类，比如上面中operate()方法，他就引用到了Operation接口类。按照之前版本的写法，我们需要实现这个接口，就像MathOperation这个类一样，然后再调用operate方法时，把这个实现类传进去，就是调用实现类中实现的具体方法。lambda表达式就是简化了这个实现过程。箭头前面就是实现接口类的方法所需要的参数，后面就是方法的具体实现。但是需要注意这样的接口类里面只能有一个接口方法。不然会报错。

下面再看一下类

package eightNew;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class StreamTest {
    public static void main(String[] args) {
        //创建一个list集合
        List<String> lists = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

        /**求一下里面字符串长度为3的总个数**/
        int count = 0;
        Iterator<String> iterator = lists.iterator();
        while (iterator.hasNext()){
            String str = iterator.next();
            if(str.length() == 3){
                count ++ ;
            }
        }
        System.out.println("字符串长度为3的总数为：" + count);

        //使用Java8中的Stream
        long number = 0;
        number = lists.stream() //先获取集合的流
                .filter(str -> str.length()==3) //对流做相应需要的过滤处理（长度为3）
                .count(); //对处理完后的数据再做操作（比如求和）
        System.out.println("字符串长度为3的总数为：" + number);
    }
}

这个是Stream的特性，他是针对集合类使用的。

以上只是我对java8一些新特性的理解，不是很全面。先对其有些概念，在后面有机会使用再详细的深入了解。