函数式编程的不变模式

import java.util.Arrays;/**
 * 函数式编程的不变模式
 */
public class ArrStream {
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5};
        Arrays.stream(arr).map((x)->x+1).forEach(System.out::print);
        System.out.println();
        Arrays.stream(arr).forEach(System.out::print);
    }
    //23456
    //12345
}

FunctionalInterface注解

/**
 * FunctionalInterface注解
 */
@FunctionalInterface //用于表明是一个函数式接口
public  interface IntHandler {
    void handle(int i);//只包含一个抽象方法
}

@FunctionalInterface //用于表明是一个函数式接口
public  interface IntHandler {
    boolean equals(Object obj);//此时编译未通过，不是函数式接口，因为equals()方法在java.lang.Object中已经实现
}

/**
 * 符合函数式接口要求
 */
@FunctionalInterface //用于表明是一个函数式接口
public  interface IntHandler {
    boolean equals(Object obj);
    void handle(int i);
}

接口的默认方式–default关键字

public interface IHorse {
    void eat();
    //使用default关键字，可以在接口内定义实例方法
    default void run(){
        System.out.println("Horse run");
    }
}

public interface IAnimal {
    default void breath(){
        System.out.println("breath");
    }
}

public interface IDonkey {
    void eat();
    default void run(){
        System.out.println("Donkey run");
    }
}

/**
 * 同时拥有不同接口的实现方法
 */
public class Mule implements IAnimal,IHorse,IDonkey {
    @Override
    public void eat() {
        System.out.println("Mule eat");
    }
    @Override
    public void run(){
        IHorse.super.run();
    }
    public static void main(String[] args){
        Mule mule = new Mule();
        mule.run();
        mule.breath();
    }
    //Horse run
    //breath
}

import java.util.function.Function;/**
 * lambda表达式访问外部的局部变量
 */
public class LambdaTest {
    public static void main(String[] args){
        final int num = 2;//外部的变量必须申明为final，即使省略final也可以编译通过，这是因为Java8会自动将lambda表达式中使用的变量视为final
        Function<Integer,Integer> st = (from)->from*num;
        System.out.println(st.apply(3));
        int num2 = 3;
        Function<Integer,Integer> st2 = (from)->from*num2;
        num2++;//编译保错 Error:(14, 54) java: 从lambda 表达式引用的本地变量必须是最终变量或实际上的最终变量
    }
}

import java.util.ArrayList;
import java.util.List;/**
 * 方法引用：
 * 静态方法引用：ClassName::methodName
 * 实例上的实例方法引用：instanceReference::methodName
 * 超类上的实例方法引用：super:methodName
 * 类型上的实例方法引用：ClassName::methodName
 * 构造方法引用：Class::methodName
 * 数组构造方法引用：TypeName[]::methodName
 *
 * 方法引用使用::定义，::前半部分表示类名或实例名，后半部分表示方法名称，如果是构造函数，则使用new表示
 */
public class InstanceMethodDemo {
    static class User{
        private int id;
        private String name;        public User(int id, String name) {
            this.id = id;
            this.name = name;
        }        public int getId() {
            return id;
        }        public void setId(int id) {
            this.id = id;
        }        public String getName() {
            return name;
        }        public void setName(String name) {
            this.name = name;
        }
    }
    public static void main(String[] args){
        List<User> users = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            users.add(new User(i,"name"+Integer.toString(i)));
        }
        //User::getName,在执行时，java会自动识别流中的元素（这里指User实例）是作为调用目标还是调用方法的参数，
        //显然应该作为调用目标，在这里调用每一个User对象实例的getName()方法，并将这些User的name作为一个新的流，
        //同时，对于这里得到的所有name，使用方法引用System.out::println进行处理。系统会自动判断，流内的元素此时
        //应该作为方法的参数传入，而️不是调用目标        // 一般来说，如果使用的是静态方法，或者调用目标明确，那么流内的元素会自动作为参数使用。如果函数引用表示
        //实例方法，并且不存在调用目标，那么流内元素就会自动作为调用目标
        users.stream().map(User::getName).forEach(System.out::println);
    }
    //name0
    //name1
    //name2
    //name3
    //name4
    //name5
    //name6
    //name7
    //name8
    //name9
}

import java.util.ArrayList;
import java.util.List;public class ConstrMethodRef {
    public static void main(String[] args){
        List<User> users = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            users.add(uf.create(i,"name"+Integer.toString(i)));
        }
        users.stream().map(User::getName).forEach(System.out::println);
    }
    //User::new创建接口实例时，系统会根据UserFactory.create()的函数签名来选择合适的User构造函数
    //在这里，很显然就是 public User(int id, String name)，在创建UserFactory.create()的调用
    //都会委托给User的实际构造函数进行，从而创建User对象实例。
    static UserFactory<User> uf = User::new;
    @FunctionalInterface
    interface UserFactory<U extends User>{
        U create(int id,String name);
    }
    static class User{
        private int id;
        private String name;        public User(int id, String name) {
            this.id = id;
            this.name = name;
        }        public int getId() {
            return id;
        }        public void setId(int id) {
            this.id = id;
        }        public String getName() {
            return name;
        }        public void setName(String name) {
            this.name = name;
        }
    }
}