JAVA8-lambda表达式简单使用

简单学习使用lambda表达式，做个记录；

Lambda表达式的语法
基本语法:
(parameters) -> expression
或

(parameters) ->{ statements; }

简单的入门例子：

// 1. 什么参数都不要，返回8
() -> 8  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

基本的Lambda例子

例1：Lambda表达式遍历List

public void m2(){
        System.out.println("==========================================================");
       List<String> list = new ArrayList<>();
      list.add("susan");
      list.add("jack");
      list.add("rose");
      list.add("evan");
      list.forEach(name-> System.out.println("name = " + name));
        // 在 Java 8 中使用双冒号操作符(double colon operator)
        list.forEach(System.out::println);
        System.out.println("==========================================================");
    }

得到结果如下：

例2：Lambda表达式实现runnable 接口

    public void m3(){
        // 1.1使用匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello world !");
            }
        }).start();

// 1.2使用 lambda expression
        new Thread(() -> System.out.println("Hello world !")).start();

// 2.1使用匿名内部类
        Runnable race1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello world !");
            }
        };

// 2.2使用 lambda expression
        Runnable race2 = () -> System.out.println("Hello world !");

// 直接调用 run 方法(没有开启新的线程!)
        race1.run();
        race2.run();
    }

使用Lambdas排序集合

   public void m4(){
        String [] player ={"susan","jack","honey","evan","zero"};
        //使用匿名内部类，根据name排序
        Arrays.sort(player, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return (o1.compareTo(o2));
            }
        });

        //lambda 表达式排序1 等同于上面的方法
        Comparator<String> stringComparator = (String s1, String s2) -> (s1.compareTo(s2));
        Arrays.sort(player,stringComparator);
        //lambda 表达式排序2 
        Arrays.sort(player,(String s1,String s2)->(s1.compareTo(s2)));

    }

***使用Lambdas和Streams

Stream是对集合的包装,通常和lambda一起使用。使用lambdas可以支持许多操作,如 map, filter, limit, sorted, count, min, max, sum, collect 等等。同样,Stream使用懒运算,他们并不会真正地读取所有数据,遇到像getFirst() 这样的方法就会结束链式语法。在接下来的例子中,我们将探索lambdas和streams 能做什么。我们创建了一个Person类并使用这个类来添加一些数据到list中,将用于进一步流操作。 Person 只是一个简单的POJO类:

/**
 * Created by sunzhitao on 2018/6/16.
 */
@Data
public class Person {
    private  String firstName,lastName,job,gender;
    private  int salary,age;

//省略getter setter
}

stream中的部分方法：

public class StreamService {

    List<Person> javaProgrammers = new ArrayList<Person>() {
        {
            add(new Person("Elsdon", "Jaycob", "Java programmer", "male",1,2000,43));
            add(new Person("Tamsen", "Brittany", "Java programmer", "female",2, 1500, 23));
            add(new Person("Floyd", "Donny", "Java programmer", "male", 3,1800,33));
            add(new Person("Sindy", "Jonie", "Java programmer", "female",4, 1600,32 ));
            add(new Person("Vere", "Hervey", "Java programmer", "male",5,1200,22));
            add(new Person("Maude", "Jaimie", "Java programmer", "female",6, 1900, 27));
            add(new Person("Shawn", "Randall", "Java programmer", "male",7, 2300, 30));
            add(new Person("Jayden", "Corrina", "Java programmer", "female",8, 1700, 35));
            add(new Person("Palmer", "Dene", "Java programmer", "male", 9,2000, 33));
            add(new Person("Addison", "Pam", "Java programmer", "female", 10,1300, 34));
        }
    };

    List<Person> phpProgrammers = new ArrayList<Person>() {
        {
            add(new Person("Jarrod", "Pace", "PHP programmer", "male", 11, 1550,34));
            add(new Person("Clarette", "Cicely", "PHP programmer", "female",12, 23, 1200));
            add(new Person("Victor", "Channing", "PHP programmer", "male", 13,32, 1600));
            add(new Person("Tori", "Sheryl", "PHP programmer", "female", 14,21, 1000));
            add(new Person("Osborne", "Shad", "PHP programmer", "male", 15,32, 1100));
            add(new Person("Rosalind", "Layla", "PHP programmer", "female",16, 25, 1300));
            add(new Person("Fraser", "Hewie", "PHP programmer", "male", 17,36, 1100));
            add(new Person("Quinn", "Tamara", "PHP programmer", "female", 18,21, 1000));
            add(new Person("Alvin", "Lance", "PHP programmer", "male", 19,38, 1600));
            add(new Person("Evonne", "Shari", "PHP programmer", "female",20, 40, 1800));
        }
    };

    /**
     * forEach 循环
     */
    public void forEachTest(){
        //迭代上述列表
        System.out.println("*****************************所有JAVA程序员的姓名*********************" );
//         javaProgrammers.forEach((java)-> System.out.printf("%s %s; ",java.getFirstName(),java.getLastName()));
        javaProgrammers.forEach((java)-> System.out.println(java.getFirstName()+"-"+java.getLastName()));
        System.out.println("*****************************所有PHP程序员的姓名*********************" );
//         phpProgrammers.forEach((php)-> System.out.printf("%s %s; ",php.getFirstName(),php.getLastName()));
        phpProgrammers.forEach((php)-> System.out.println(php.getFirstName()+"-"+php.getLastName()));
    }


    /**
     * forEach循环加工资
     */
    public void foreachAdd(){
        System.out.println("**********所有的程序员工资添加5%***********");
        Consumer<Person> givaRaise = e -> e.setSalary(e.getSalary()/100*5 +e.getSalary());
        javaProgrammers.forEach(givaRaise);
        phpProgrammers.forEach(givaRaise);
    }

    /**
     * stream 使用过滤器
     */
    public void fifter(){
        System.out.println("***显示月薪超过1000的java程序员***");
        javaProgrammers.stream().filter((p)->p.getSalary()>1000)
                .forEach(person -> System.out.println("person = " + person.getLastName()+"salary:"+person.getSalary()));

    }

    /**
     * 自定义过滤器,然后重用它们来执行其他操作:
     */
    public  void myFifter(){
        // 定义 filters
        Predicate<Person> ageFifter =(p)->(p.getAge() > 25);
        Predicate<Person> salaryFifter = (p)->(p.getSalary()>1200);
        Predicate<Person> genderFifter = (p)->("female".equals(p.getGender()));
        System.out.println("************   myFifter | start ****************");
        javaProgrammers.stream().filter(ageFifter)
                .filter(salaryFifter)
                .filter(genderFifter).forEach((p)-> System.out.println(p.toString()));
        System.out.println("************   myFifter | end ****************");
    }


    /**
     * 使用limit方法,可以限制结果集的个数:
     */
    public  void limitMethod(){
        System.out.println("******  limit start **********");
        javaProgrammers.stream().limit(3).forEach((p)-> System.out.println(p.toString()));
        System.out.println("******  limit end **********");
    }

    /**
     * stream中使用sort排序
     */
    public void  streamSort(){
        System.out.println(" **************  stream 使用sort排序 **************");
        Comparator<Person> comparator = (Person p1,Person p2)->(p1.getFirstName().compareTo(p2.getFirstName()));
        List<Person> collect = javaProgrammers.stream().sorted(comparator)
                .limit(5).collect(Collectors.toList());

//        List<Person> collect = javaProgrammers.stream().sorted((p, p2) -> (p.getFirstName().compareTo(p2.getFirstName())))
//                .limit(5).collect(Collectors.toList());
        collect.forEach((p)-> System.out.println(p.toString()));
    }

    /**
     * stream里面的min max方法
     */
    public  void minAndMax(){
        System.out.println(" *******  选择出工资最低的员工*********");
        Person person = javaProgrammers.stream().min((p, p1) -> (p.getSalary() - p1.getSalary())).get();
        System.out.println("工资最低的程序员是 ：" + person.toString());
        System.out.println(" *******  选择出工资最高的员工*********");
        Person person1 = javaProgrammers.stream().max((p, p1) -> (p.getSalary() - p1.getSalary())).get();
        System.out.println("工资最高的程序员是 ：" + person1.toString());

    }

    /**
     * 使用stream中的map方法
     */
    public  void mapMethod(){
        System.out.println("********** 将java程序员的firstName拼接成字符串************ ");
        String collect1 = javaProgrammers.stream().map(Person::getFirstName).collect(Collectors.joining(";"));
        System.out.println(" *******  放进set中  ***********");
        Set<String> collect = javaProgrammers.stream().map(Person::getFirstName).collect(Collectors.toSet());
        System.out.println(" *******  放进TreeSet中  ***********");
        TreeSet<String> collect2 = javaProgrammers.stream().map(Person::getFirstName).collect(Collectors.toCollection(TreeSet::new));
    }

    /**
     * stream中将list转map的方法
     */
    public void listToMap(){
        Map<Integer, Person> collect = javaProgrammers.stream().collect(Collectors.toMap(Person::getId, Person -> Person));
        //这个方法可能报错 `（java.lang.IllegalStateException: Duplicate key）`
        // 因为name是有可能重复的。`toMap` 有个重载方法，可以传入一个合并的函数来解决key冲突问题：
        Map<Integer, Person> collect1 = javaProgrammers.stream().collect(Collectors.toMap(Person::getId, Function.identity(),(key1,key2)->key2));
        System.out.println("collect = " + JSON.toJSONString(collect));
    }
}

JAVA8-lambda表达式简单使用

猜你喜欢