--插入：lamda表达式--

Lamda表达式属于函数式编程的概念，要理解函数式编程的产生目的，就要先理解匿名内部类。

匿名内部类：

interface SayHello(){
    void printHello();
}


public class MyWorld(){
    public static void welcomeWorld(SayHello sayHello){
        sayHello.printHello();
    }
    
    public static void main(String[] args){
        welcomeWorld(new SayHello(){
                @Override
                public void printHello(){
                    system.out.print("hello world");   
                }
            }
        );
    }
}

使用lamda表达式:

interface SayHello(){
    void printHello();
}


public class MyWorld(){
    public static void welcomeWorld(SayHello sayHello){
        sayHello.printHello();
    }
    
    public static void main(String[] args){
        welcomeWorld(() -> system.out.print("hello world");)
    }
}

()相当于printHello()，只不过因为无参所以为空

==其他功能==

1. 使用lambda表达式对集合进行迭代

    public void iterTest() {
        List languages = Arrays.asList("java","scala","python");
        //before java8
        for(String each:languages) {
            System.out.println(each);
        }
        //after java8
        languages.forEach(x -> System.out.println(x));
        languages.forEach(System.out::println);
    }

2. 用lambda表达式实现map函数

public void mapTest() {
        List cost = Arrays.asList(10.0, 20.0,30.0);
        cost.stream().map(x -> x + x*0.05).forEach(x -> System.out.println(x));
    }
    
10.5
21.0
31.5

3. 用lambda表达式实现map与reduce：map的作用是将一个对象变为另外一个，而reduce实现的则是将所有值合并为一个

 public void mapReduceTest() {
        List cost = Arrays.asList(10.0, 20.0,30.0);
        double allCost = cost.stream().map(x -> x+x*0.05).reduce((sum,x) -> sum + x).get();
        System.out.println(allCost);
    }
    

63.0

用for循环：

public void sumTest() {
        List cost = Arrays.asList(10.0, 20.0,30.0);
        double sum = 0;
        for(double each:cost) {
            each += each * 0.05;
            sum += each;
        }
        System.out.println(sum);
    }

---

==附：java8之方法引用==

Java 8中方法也是一种对象，可以By名字来引用。不过方法引用的唯一用途是支持Lambda的简写，使用方法名称来表示Lambda。不能通过方法引用来获得诸如方法签名的相关信息。

方法引用的分类

方法引用分为4类，常用的是前两种。方法引用也受到访问控制权限的限制，可以通过在引用位置是否能够调用被引用方法来判断。具体分类信息如下：

• 引用静态方法

ContainingClass::staticMethodName

例子: String::valueOf，对应的Lambda：==(s) -> String.valueOf(s)==

比较容易理解，和静态方法调用相比，只是把.换为::

• 引用特定对象的实例方法

containingObject::instanceMethodName

例子: x::toString，对应的Lambda：==() -> this.toString()==

与引用静态方法相比，都换为实例的而已

• 引用特定类型的任意对象的实例方法

ContainingType::methodName

例子: String::toString，对应的Lambda：==(s) -> s.toString()==

太难以理解了。难以理解的东西，也难以维护。建议还是不要用该种方法引用。实例方法要通过对象来调用，方法引用对应Lambda，Lambda的第一个参数会成为调用实例方法的对象。

• 引用构造函数

ClassName::new

例子: String::new，对应的Lambda：==() -> new String()==

构造函数本质上是静态方法，只是方法名字比较特殊。

++==注：方法引用仅仅是Lambda的配套服务，主要目的是通过名字来获得Lambda，重复利用已有的方法。==++

public class MethodReference {
    public static void main(String[] args) {
        // 方法引用::引用构造函数
        PersonFactory factory = new PersonFactory(Person::new);

        List personList = new ArrayList();

        Person p1 = factory.getPerson();
        p1.setName("Kobe");
        personList.add(p1);
        Person p2 = factory.getPerson();
        p2.setName("James");
        personList.add(p2);
        Person p3 = factory.getPerson();
        p3.setName("Paul");
        personList.add(p3);

        Person[] persons1 = personList.toArray(new Person[personList.size()]);
        System.out.print("排序前: ");
        printArray(persons1);

        // 方法引用::引用静态方法
        Arrays.sort(persons1, MethodReference::myCompare);
        System.out.print("排序后: ");
        printArray(persons1);
        System.out.println();

        Person[] persons2 = personList.toArray(new Person[personList.size()]);
        System.out.print("排序前: ");
        printArray(persons2);

        // 方法引用::用特定对象的实例方法
        Arrays.sort(persons2, p1::compare);
        System.out.print("排序后: ");
        printArray(persons2);
        System.out.println();

        Person[] persons3 = personList.toArray(new Person[personList.size()]);
        System.out.print("排序前: ");
        printArray(persons3);

        // 方法引用::引用特定类型的任意对象的实例方法
        Arrays.sort(persons3, Person::compareTo);
        System.out.print("排序后: ");
        printArray(persons3);
    }

    public static void printArray(Person[] persons) {
        for (Person p : persons) {
            System.out.print(p.name + "  ");
        }
        System.out.println();
    }

    public static int myCompare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }

    static class Person {
        private String name;

        public Person() {
        }

        public String getName() {
            return name;
        }

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

        public int compare(Person p1, Person p2) {
            return p1.getName().compareTo(p2.getName());
        }

        public int compareTo(Person p) {
            return this.getName().compareTo(p.getName());
        }
    }

    static class PersonFactory {
        private Supplier supplier;

        public PersonFactory(Supplier supplier) {
            this.supplier = supplier;
        }

        public Person getPerson() {
            return supplier.get();
        }
    }
}