java8 新特性

功能接口/函数式接口 @FunctionInterface

函数式接口就是只定义一个抽象方法并且添加@FunctionInterface的接口，如Runnable Callable Comparator。

函数式接口是为了Java中lambda使用而出现的

函数式接口特点：

　　接口有且只有一个抽象方法

　　允许定义静态非抽象方法

　　允许定义default非抽象方法

　　允许java.lang.Object中public方法

　　FunctionInterface不是必须的，如果一个接口符合"函数式接口"定义，那么加不加该注解都没有影响

函数式接口作为方法的参数

如果方法的参数是一个函数式接口，可以使用Lambda表达式作为参数传递

public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        startThread(()-> System.out.println("start job"));
    }
    private static void startThread(Runnable runnable) {
        Thread t=new Thread(runnable);
        t.start();
    }
}

函数式接口作为方法的返回值 

public class Demo {
    public static void main(String[] args) {
                ArrayList<String> array=new ArrayList<String>();
        array.add("aa");
        array.add("b");
        array.add("cccc");
        array.add("ddd");

        System.out.println("排序前："+array);
        Collections.sort(array);//自然排序
        System.out.println("自然排序后："+array);
        Collections.sort(array,getComparator());
        System.out.println("指定比较器排序后："+array); 
    }

    private static Comparator<String> getComparator(){
//        Comparator<String> comparator=new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length()-o2.length();
//            }
//        };
//        return comparator;

        return (s1,s2)->s1.length()-s2.length();
    }

 

注释部分是不使用lamda表示式代码

java内置四大函数式接口 --这些接口都是为了应对Lamda来使用的

函数式接口	参数类型	返回类型	用途
Consumer 消费型接口	T	无	对类型为T的对象应用操作，包含方法：void accept(T t)，常用于遍历
Supplier 共给型接口	无	T	返回类型为T的对象，包含方法：T get() ，用于产生数据
Function<T， R> 函数型接口	T	R	对类型为T的对象应用操作，并返回结果，结果是R类型的对象，包含方法：R apply(T t)， 用于逻辑处理
Predicate 断定型接口	T	boolean	确定类型为T的对象是否满足某约束，并返回boolean值。包含方法boolean test(T t)， 用于判断

consumer<T>实例：有输入没有返回

    public static void main(String[] args) {
         Consumer consumer = new Consumer<Object>() {
             @Override
             public void accept(Object o) {
                 System.out.println("o = " + o);
             }
         };
 ​
         consumer.accept("我是消费式函数接口");
     }

可以看出，传入了参数，没有返回值，故称为消费型

Supplier<T> 无中生有，没有输入，但有返回值

     public static void main(String[] args) {
         Supplier<String> supplier = new Supplier<String>() {
             @Override
             public String get() {
                 return "我是一个私生子";
             }
         };
         String s = supplier.get();
         System.out.println("s = " + s);
     }
 ​
 //运行结果
 s = 我是一个私生子

Predicate<T>里边抽象方法有参数，返回boolean，对数据进行校验作用

 public static void main(String[] args) {
         Predicate<String> predicate = new Predicate<String>() {
             @Override
             public boolean test(String s) {
                 if("1".equals(s)){
                     return true;
                 }
                 return false;
             }
         };
         boolean test = predicate.test("2");
         System.out.println("test = " + test);
     }
 ​
 //运行结果
 test = false

Function<T,R>,抽象方法中有入参，也有返回值，用于对代码进行逻辑处理

 

     public static void main(String[] args) {
         Function<String, Object> function = new Function<String, Object>() {
             @Override
             public Object apply(String s) {
                 return "传给我的参数是：" + s;
             }
         };
         Object tom = function.apply("Tom");
         System.out.println(tom);
     }
 ​
 //运行结果
 传给我的参数是：Tom

 

一、Stream

含义：Stream是对集合对象进行各种便利、高效聚合操作或者大批量数据操作。stream借助lambda表达式极大提高编程效率和程序可读性

 

构成：数据源——>数据转换——>执行操作获取想要结果。每次转换原有stream对象不变，返回一个新的stream对象

　　例：

//实现将含有a、b、c三个元素的list转换为大写字母放入新的list中
List<String> strs=Arrays.asList("a","b","c");
//java8之前做法
List<String> before8=new ArrayList<String>();
for(String str:strs){
    before8.add(str.toUpperCase());  
}
//java8之后做法
List<String> after8=strs.stream().map(String ::toUpperCase).collect(Collector.toList());

//map作用是将对象转化为其他类型对象

 

stream()使用详解：

1、map():将input stream的每一个元素映射成output stream的另一个元素。--只是将原来元素做聚合等计算，但没有if条件判断

List<Integer> nums=Arrays.asList(1,2,3);
List<Integer> newNums=nums.stream().map(n->n*n).collect(Collectors.toList());

　　结果:[1,4,9]

2、filter():过滤inputstream，将满足条件的元素生成outputstream  ---存在if条件判断

List<Integer> nums=Arrays.asList(1,2,3,4,5,6);
List<Integer> newNums=nums.stream().filter(n->n%2==0).collect(Collectors.toList());

　　结果：[2, 4, 6]

3、forEach():对每个inputstream元素执行->后表达式

　　

public class TestJava8 {
    public static void main(String[] args) {
        List<Integer> nums=Arrays.asList(1,2,3,4,5,6);
        nums.stream().forEach(n->getn(n));
        nums.stream().forEach(n->getn(n*8));
    }

        private static String getn(int n) {
        System.out.println("-----------"+n);
        return n+"dd";    
    }
}
结果：
-----------1
-----------2
-----------3
-----------4
-----------5
-----------6
-----------8
-----------16
-----------24
-----------32
-----------40
-----------48

 

4、reduce():作用是把stream元素组合起来

　　reduce格式是：reduce(参考值，操作函数），参考值会参与到后边操作函数中；如果没有参考值则返回的Optional[]格式

　　常见：sum、min、max、concat　等方法

List<Integer> lists=Arrays.asList(-3,-7,-1,5,1);
lists.stream().reduce(0,Integer::sum));//结果是0-3-7-1+5+1=-5
lists.stream().reduce(Integer::sum));//结果是Optional[-5]
lists.stream().reduce(Integer::sum).get());//结果是-5
lists.stream().reduce(Integer::min).get());//结果是-7 同理还有max()方法

List<String> strs=Arrays.asList("Q","W","E");
strs.stream.reduce("",String::concat)); //结果是"QWE"
strs.stream.reduce("A",String:concat));//结果是"AQWE"

 

 5、limit/skip

　　limit(n):返回前n个元素

　　skip(n):去掉前n个元素

　　iterate():迭代，用于从函数生成流，一般用limit()或skip()对这种流加以限制

Stream.iterate(0, n->n+3).limit(10).skip(3).forEach(System.out::println);
结果：
9
12
15
18
21
24
27

 

6、Match匹配，stream有三个match方法

　　　　allMatch():Stream中全部元素都符合逻辑判断，则返回true

　　　　anyMatch():Stream中只要有一个元素都符合逻辑判断，则返回true

　　　　noneMatch():Stream中全部元素都不符合逻辑判断，则返回true

        List<Staff> stuffs=Arrays.asList(
                new Staff("mkyong", 30),
                new Staff("jack", 27),
                new Staff("lawrence", 33),
                new Staff("lawrence", 22)
                );
        
        System.out.println(stuffs.stream().allMatch(stuff->stuff.getAge()>28));
        System.out.println(stuffs.stream().anyMatch(stuff->stuff.getAge()>28));
        System.out.println(stuffs.stream().noneMatch(sutff->sutff.getAge()>28));

结果：
    false
    true
    false

 

7、sort() 排序； distinct()找出不重复内容　

lists.stream().filter(word -> word.length() > 0).
 map(String::toLowerCase).
 distinct().
 sorted().
 collect(Collectors.toList());

 

8、groupby/partitionby

        List<Staff> stuffs=Arrays.asList(
                new Staff("mkyong", 30),
                new Staff("jack", 22),
                new Staff("lawrence", 33),
                new Staff("lawrence", 22)
                );
        Map<Integer,List<Staff>> stfs=stuffs.stream().collect(Collectors.groupingBy(Staff::getAge)); //分组
        for(Map.Entry<Integer, List<Staff>> entry:stfs.entrySet()) {
            System.out.println("key:"+entry.getKey());
            System.out.println("value:"+JSON.toJSONString(entry.getValue()));
        }

结果：
key:33
value:[{"age":33,"name":"lawrence"}]
key:22
value:[{"age":22,"name":"jack"},{"age":22,"name":"lawrence"}]
key:30
value:[{"age":30,"name":"mkyong"}]

 

 

二、方法引用

含义：方法引用是用来直接访问类或者实例的已存在的方法或者构造方法，方法引用是一个lambda表达式，其方法引用的操作符是双冒号::

 方法引用类型：　　

类型	示例
引用静态方法	ContainingClass::staticMethodName
引用某个对象的实例方法	containingObject::instanceMethodName
引用某个类型的任意对象的实例方法	ContainingType::methodName
引用构造方法	ClassName::new

 　　

 

 

 

 

 

2.1引用静态方法：（类名::静态方法名）

组成语法：ClassName::statcimethodName

　　诸如：String::valueOf  等价s->String.valueOf(s)

　　　　　Math::pow  等价于(x,y)->math.pow(x,y)　

 

public class Student {
    private String name;
    private double score;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public Student(String name, double score) {
        this.name = name;
        this.score = score;
    }

}

 

package com.citi.ark.mls.service.qftest.methodrefer;

public class StudentCompare {
    //静态方法
    public static int compareStudentByScoreClz(Student s1, Student s2) {
        return (int) s1.getScore() - (int) s2.getScore();
    }
    //实例方法
    public int compareStudentByScoreObj(Student s1,Student s2){
        return (int) s2.getScore() - (int) s1.getScore();
    }
}

 

public class StaticMethodRefer {
    public static void main(String[] args) {
        Student s1=new Student("fff",75);
        Student s2=new Student("eee",70);
        Student s3=new Student("ccc",79);
        Student s4=new Student("ddd",65);
        List<Student> studentList= Arrays.asList(s1,s2,s3,s4);
        studentList.sort(StudentCompare::compareStudentByScoreClz);
        studentList.forEach(student -> System.out.println("name:"+student.getName()+",score:"+student.getScore()) );
    }
}

 

如上例，StudentCompare::compareStudentByScoreClz对类的静态方法引用，输出结果

name:ddd,score:65.0
name:eee,score:70.0
name:fff,score:75.0
name:ccc,score:79.0

2.2引用某个对象的实例方法（对象名::实例方法名）

 如上例中，将main方法改为如下

public class StaticMethodRefer {
    public static void main(String[] args) {
        Student s1=new Student("fff",75);
        Student s2=new Student("eee",70);
        Student s3=new Student("ccc",79);
        Student s4=new Student("ddd",65);
        List<Student> studentList= Arrays.asList(s1,s2,s3,s4);
        StudentCompare studentCompare=new StudentCompare();
        studentList.sort(studentCompare::compareStudentByScoreObj);
        studentList.forEach(student -> System.out.println("name:"+student.getName()+",score:"+student.getScore()) );
    }
}

 

 实例方法引用是在进行方法引用之前需要创建实例，通过实例对象名去引用方法

 输出结果：

 name:ccc,score:79.0

name:fff,score:75.0
name:eee,score:70.0
name:ddd,score:65.0

 2.3 类的实例方法引用(类名::实例方法名）

在方法调用中，是不能用类名直接调用实例方法的，但在方法引用中可以用用类名::实例方法这种形式通过类名直接调用实例方法

public class Student {
    private String name;
    private double score;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public Student(String name, double score) {
        this.name = name;
        this.score = score;
    }
    //实例方法
    public int compareStudentByName(Student student){
        return this.getName().compareToIgnoreCase(student.getName());
    }
}

 

public class StaticMethodRefer {
    public static void main(String[] args) {
        Student s1=new Student("fff",75);
        Student s2=new Student("eee",70);
        Student s3=new Student("ccc",79);
        Student s4=new Student("ddd",65);
        List<Student> studentList= Arrays.asList(s1,s2,s3,s4);
        studentList.sort(Student::compareStudentByName);
        studentList.forEach(student -> System.out.println("name:"+student.getName()+",score:"+student.getScore()) );
    }
}

 

 从表面看，是类Student调用了compareStudentgByName，但Student是类而compareStudentByName不是静态方法，只是实例方法，所以Student类不能调用compareStudentByname.我们跟进List接口的sort方法，sort方法的参数是一个Comparator的函数式接口，该接口的抽象方法有两个参数.而我们的compareStudentByName方法只有一个参数，这要求的参数个数和我们传入的参数个数根本对应不上呀，那么lambada的另一个参数是谁呢,其实另一个参数另一个参数就是compareStudentByName方法的调用者即this(Student的当前实例)。

针对以上类的实例方法引用的问题，一般lambada表达式的第一个参数作为实例方法的调用者，其余参数作为实例方法的参数传入

 

default void sort(Comparator<? super E> c) {
　　Object[] a = this.toArray();
　　Arrays.sort(a, (Comparator) c);
　　ListIterator<E> i = this.listIterator();
　　for (Object e : a) {
　　　　i.next();
　　　　i.set((E) e);
　　}
}

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
    ...
}

 

 2.4构造方法引用

构造方法引用就是通过new调用构造方法，创建一个对象

 

参考: https://blog.csdn.net/yelang0/article/details/100054075

https://zhuanlan.zhihu.com/p/549904376