Java8新特性 细说Lambda

java的发展历史

1995年5月23日，Java语言诞生 1996年1月，第一个JDK-JDK1.0诞生
1996年4月，10个最主要的操作系统供应商申明将在其产品中嵌入JAVA技术 1996年9月，约8.3万个网页应用了JAVA技术来制作
1997年2月18日，JDK1.1发布 1997年4月2日，JavaOne会议召开，参与者逾一万人，创当时全球同类会议规模之纪录
1997年9月，JavaDeveloperConnection社区成员超过十万 1998年2月，JDK1.1被下载超过2,000,000次
1998年12月8日，JAVA2企业平台J2EE发布
1999年6月，SUN公司发布Java的三个版本：标准版（JavaSE,以前是J2SE）、企业版（JavaEE以前是J2EE）和微型版（JavaME，以前是J2ME）
2000年5月8日，JDK1.3发布 2000年5月29日，JDK1.4发布
2001年6月5日，NOKIA宣布，到2003年将出售1亿部支持Java的手机 2001年9月24日，J2EE1.3发布
2002年2月26日，J2SE1.4发布，自此Java的计算能力有了大幅提升
2004年9月30日18:00PM，J2SE1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE1.5更名为Java
SE 5.0 2005年6月，JavaOne大会召开，SUN公司公开Java SE
6。此时，Java的各种版本已经更名，以取消其中的数字“2”：J2EE更名为Java EE，J2SE更名为Java
SE，J2ME更名为Java ME 2006年12月，SUN公司发布JRE6.0
2009年04月20日，甲骨文74亿美元收购Sun。取得java的版权。
2010年11月，由于甲骨文对于Java社区的不友善，因此Apache扬言将退出JCP[3]。
2011年7月28日，甲骨文发布java7.0的正式版。 最新版本
甲骨文的Java总架构师马克·雷纳德在2011年JavaOne大会上为大家透露了Java 8的新功能，同时也谈到了一些关于Java
9的计划。[4]

java8是Oracle在2014年3月19日发布正式版的，和JDK7(2011年7月发布）相隔了近3年（拖的时间堪比JDK7和JDK6之间的时间，与历史版本发布间隔相比排在第二位，JDK6发布是2006，JDK7与之相比之间差了5年，这两个版本发布时间间隔最长，中间发生了Oracle收购SUN的大事件，JDK6因此曾成为使用率最高的JDK，)，中间因意见不统一多次延迟。

体现Lambda的特点以及比较
lambda表达式的一般格式如下
(x, y) -> Integer.compare(x, y).
为了能够理解lambda表达式，咱们直接上代码
需求：获取公司员工年龄大于35岁的员工信息
没学过java8之前都是这种样子的

package com.java8.test;

public class Employee {
    private String name;
    private int age;
    private double salary;

    public Employee() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Employee(String name, int age, double salary) {
        super();
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + ", age=" + age + ", salary=" + salary + "]";
    }
    // 获取当前公司中员工年龄大于35的员工信息
    @Test
    public void test3() {

        List<Employee> employees = filterEmployee(employee);
        for (Employee ee : employees) {
            System.out.println(ee.toString());
        }
    }
//奖励方法便利过滤是否符合条件，符合条件的加入到list结合中
    public static List<Employee> filterEmployee(List<Employee> employees) {
        List<Employee> newemp = new ArrayList<Employee>();
        for (Employee emp : employees) {
            if (emp.getAge() >= 35) {
                newemp.add(emp);
            }
        }
        return newemp;
    }
}

=================================================
优化代码一
建立一个Mypredicate<T>接口
package com.java8.test;

public interface MyPredicate<T> {
    public boolean test(T t);
}
--------------------------------
实现接口
public class FilterEmployeeByAge implements MyPredicate<Employee> {

    @Override
    public boolean test(Employee t) {
        // TODO Auto-generated method stub
        return t.getAge()>=35;
    }

}


================
建立测试方法
    @Test
    public void test4() {
        List<Employee> list = filterEmployee(employee, new FilterEmployeeByAge());
        //遍历输出集合
        for (Employee e : list) {
            System.out.println(e.toString());
        }
    }

策略设计模式
    public List<Employee> filterEmployee(List<Employee> list, MyPredicate<Employee> mp) {
        List<Employee> employees = new ArrayList<Employee>();
        for (Employee e : list) {
            if (mp.test(e)) {
                employees.add(e);
            }
        }
        return employees;
    }
===================================================
优化方式二，通过内部类来控制方法的实现，不用进行书写实现类来实现接口，我们可以通过内部类来书写方法的实现，
// 优化方式二
    @Test
    public void test5() {
        List<Employee> list = filterEmployee(employee, new MyPredicate<Employee>() {

            @Override
            public boolean test(Employee t) {
                // TODO Auto-generated method stub
                return t.getSalary() <= 5000;
            }
        });
        for (Employee e : list) {
            System.out.println(e.toString());
        }
    }

其中filterEmployee方法是同上边公用的，employee是一个全局变量集合，在本文中没有写出来
===============================================
优化方式三、使用Lambda表达式来书写
    // 优化方式三
    // Lambda表达式
    @Test
    public void test6() {
        List<Employee> filterEmployee = filterEmployee(employee, (e) -> e.getSalary() <= 5000);
        filterEmployee.forEach(System.out::println);
    }
在这里我们先不说Lambda如何实现该方法的，读者可以先熟悉一下代码，稍后会详细说明Lambda的使用以及语法。从这可以看出，Lambda的代码块很少，
================================================
优化方式四
//优化方式四
    @Test
    public void test7(){
        employee.stream()
            .filter((e)->e.getSalary()>=5000)
            .limit(2)
            .forEach(System.out::println);
        System.out.println("=============");
        employee.stream()
        .map(Employee::getName)
        .forEach(System.out::println);
    }

lambda表达式

/**
* 1.lambda 表达式的基础语法，java8中引入了一个新的操作符，“->” 该操作符 或Lambda操作符箭头操作符将Lambda表达式拆分为两部分，
*
* 左侧：Lambda 表达式参数列表 右侧：Lambda 表达式中所需要执行的功能，即Lambda体
*
* 语法格式一、无参数，无返回值 ()->System.out.println(“hellow”); ()->System.out.println(
* “hello Lambda”);
* 语法格式二：有一个参数，并且无返回值 Consumer consumer = (x) ->
* System.out.println(x);
* 语法格式三：只有一个参数，参数小括号可以省略不写 x->System.out.println(x)
* Consumer consumer = (x) -> System.out.println(x);// 对Consumer的实现
* Consumer consumer1 = x -> System.out.println(x);// 一个参数小括号可以不写
* consumer.accept(“平顶山学院”); 语法格式四:若有两个以上的参数，有返回值，并且Lambda体中有多条语句 Comparator
* comparator = (x, y) -> {
*
* System.out.println(“函数式接口”); return Integer.compare(x, y); };
*
* 语法格式五：若Lambda体中只有一条语句，return 和大括号都可以省略不写 Comparator
* com1=(x,y)->Integer.compare(x, y);
*
*
* 语法格式六、Lambda表达式的参数列表的数据类型可以省略补写，因为jvm编译器可以通过上下文推断出， （Integer x,Integer
* y）->System.out.println(“”)
* 总结： 上联：左右遇一括号省， 下联：左侧推断类型省 横批：能省则省
* 二、Lambda表达式需要”函数式接口“的支持
* 函数式接口：借口中只有一个抽象方法的借口，成为函数式接口，可以使用注解@FunctionInterface修饰 可以检查是否是函数式接口，
*
*/
java8提供了Consumer接口，我们可以通过这个接口来描述lambda特性
eg:

@Test
    public void test2() {
        Consumer<String> consumer = (x) -> System.out.println(x);// 对Consumer的实现
        Consumer<String> consumer1 = x -> System.out.println(x);// 一个参数小括号可以不写
        consumer.accept("平顶山学院");
    }
解析：我们可以发现，Consumer接口有一个accept（T t）方法，我们利用那个（x）->Systme.out.println(x)  ->左侧括号表示该方法一个参数，右侧表示没有返回值我们可以写个输出语句来验证执行。
下边两个例子相同
@Test
    public void test3() {
        Comparator<Integer> comparator = (x, y) -> {
            System.out.println("函数式接口");
            return Integer.compare(x, y);//表示该方法有返回值
        };
        comparator.compare(1, 2);//执行接口方法
    }

    @Test
    public void test4() {
        Comparator<Integer> com1 = (x, y) -> Integer.compare(x, y);
    }

书写一个需求：对一个数进行运算

package com.java8.test;
public interface MyFun {
    public Integer getValue(Integer num);
}

    // 需求：对一个数进行运算
    @Test
    public void test5() {
        Integer integer = operation(100, (x) -> x * x);
        System.out.println(integer);
        System.out.println(operation(200, (y)->y+200));
    }
    public Integer operation(Integer num, MyFun mf) {
        return mf.getValue(num);
    }

下边我们可以做几个实例来巩固一下

// 对list集合进行排序，如果年龄相同按照姓名进行排序
    List<Employee> employee = Arrays.asList(new Employee("张三", 18, 91258.3), new Employee("李四", 22, 8525.3),
            new Employee("刘强", 21, 4562.3), new Employee("王鸣三", 22, 8951.2), new Employee("李四强", 42, 3582.7));

    @Test
    public void test() {
        Collections.sort(employee, (e1, e2) -> {
            if (e1.getAge() == e2.getAge()) {
                return e1.getName().compareTo(e2.getName());
            } else {
                return Integer.compare(e1.getAge(), e2.getAge());
            }
        });
        for (Employee e : employee) {
            System.out.println(e.toString());
        }
    }

@Test
    public void test2() {
        /*
         * String strHandle = strHandle("\t\t\t 平顶山学院  ", (str)->str.trim());
         * System.out.println(strHandle);
         */
        String str = strHandle("adadefasd", (x) -> x.toUpperCase());
        System.out.println(str);
    }

    // 需求：用于处理字符串
    public String strHandle(String str, MyFunction my) {
        return my.getValue(str);
    }

@FunctionalInterface
public interface MyFunction {

    public String getValue(String str);
}

package com.java8.test.review;


public interface MyFunction2<T, R> {
    public R getValue(T t1, T t2);

}

@Test
    public void test3() {
        op(100L, 200L, (x, y) -> x + y);
        op(100L, 200L, (x,y)->x*y);
    }
    // 对于两个Long数据进行处理
    public void op(Long o1, Long o2, MyFunction2<Long, Long> mf) {
        System.out.println(mf.getValue(o1, o2));
    }

java8内置对象
/**
* java8内置的四大核心函数式接口，
* Consumer 混淆型接口 void accept(T t);
*
* Supplier :供给型接口 T get();
*
* Function

public class TestLambda {
    // 断言型接口 Predicate<T>
    @Test
    public void test4() {
        List<String> list=Arrays.asList("hello","zhangsan","liss","liuqiang");

        List<String> result=filterStr(list, (e)->e.length()>4);
        for(String list2:result){
            System.out.println(list2);
        }

    }
    // 需求：将满足条件的字符串放入到集合中

    public List<String> filterStr(List<String> list, Predicate<String> predicate) {
        List<String> list2 = new ArrayList<>();
        for (String s : list) {
            if (predicate.test(s)) {
                list2.add(s);
            }
        }
        return list2;
    }

    // 函数型接口Function<T,R> T 为参数类型，R为返回值类型
    @Test
    public void test3() {
        String string = strHandler("   平顶山学院   ", (e) -> e.trim());
        System.out.println(string);
        String string2 = strHandler("adeFdsgssadf", (e) -> e.toUpperCase());
        System.out.println(string2);
        String string3 = strHandler("weidianlun,zhangsanling,dingpiengju", (e) -> e.subSequence(2, 5).toString());
        System.out.println(string3);

    }

    // 需求用于处理字符串
    public String strHandler(String string, Function<String, String> function) {
        return function.apply(string);

    };

    // 供给型接口Supplier<T>
    @Test
    public void test2() {
        List<Integer> list = getNumList(10, () -> (int) (Math.random() * 100));
        for (Integer i : list) {
            System.out.print("-" + i);
        }
    }

    // 产生一些整数，并放入到集合中
    public List<Integer> getNumList(int num, Supplier<Integer> su) {
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < num; i++) {
            Integer integer = su.get();
            list.add(integer);
        }
        return list;
    }

    // Consumer<T> 消费型接口
    @Test
    public void test1() {
        xiaofei(1000d, (e) -> System.out.println("每次消费" + e + "元"));
    }

    public void xiaofei(Double money, Consumer<Double> consumer) {
        consumer.accept(money);
    }
}