Lambda表达式

Lambda

• Lambda表达式，也可称为闭包，他是推动java 8 发布的重要更新特性
• Lambda允许把函数（函数式接口）作为一个方法的参数（函数作为参数传递进方法中）。
• 使用Lambda表达式可以使代码变的更加简洁紧凑，有效避免内部匿名类的出现。

定义接口

public class ch1 {
    public static void main(String[] args) {
        //01 传方式
        int i = 9;
        Tools t = new MyTools();
        System.out.println(t.pf(i));
        Tools tt = new MyUtils();
        System.out.println(tt.pf(i));
        //02 new
        Tools a = new Tools() {
            @Override
            public int pf(int i) {
                return i + 2;
            }
        };
        System.out.println(a.pf(58));
        //Toolsb = (e) -> e + 2;
        // Tools b = e -> e + 2;
        Tools b = e -> {
            return 0;
        };
        System.out.println(b.pf(3));
    }
}

interface Tools {
    int pf(int i);

    default String show(int a, String b) {
        return null;
    }
}

class MyTools implements Tools {
    /*** 返回一个数平方 ** @param i * @return */
    @Override
    public int pf(int i) {
        return i * i;
    }

    @Override
    public String show(int a, String b) {



        return null;
    }
}

class MyUtils implements Tools {
    @Override
    public int pf(int i) {
        return i * i * i;
    }

    @Override
    public String show(int a, String b) {
        return null;
    }
}

lambda表达使用接口，作为参数使用

public class Lamb2 {
   public static void main(String[] args) {
       List<Integer>list=new ArrayList<>(List.of(10,90,80,58,59,55,59,56,58,76));
       //list.stream().map(e->e==58||e==59?60:e).forEach(e-> System.out.println("成绩："+e+"分"));
       //list.stream().map(e->e==58||e==59?60:e).forEach(e-> System.out.println(e));
       //list.stream().map(e -> e == 58 || e == 59 ? 60 : e).forEach(System.out::println);
       list.stream().map(e->e==58||e==59?60:e).forEach(e-> System.out.printf("成绩：%2d分%n",e));
   }
}

lambda集合排序应用

数字排序

public class ListLambda1 {
    public static void main(String[] args) {
        //数字的小数排序
        List<Double> list1=new ArrayList<>(List.of(10d,20d,30d,40d,11d,22d,19d,90d));
        //不排序
        System.out.println(list1);
        //升序
        Collections.sort(list1,(a,b)->(int)(b-a));
        System.out.println(list1);

        //乱序
        Collections.shuffle(list1);
        Collections.shuffle(list1);
        Collections.shuffle(list1);
        System.out.println("-------------");

        //整数排序
        List<Integer> list2=new ArrayList<>(List.of(10,20,30,40,50,11));
        //不排序
        System.out.println(list2);
        //升序
        Collections.sort(list2);
        System.out.println(list2);;
        //降序
        Collections.sort(list2,(a,b)->b-a);
        System.out.println(list2);
        //乱序
        Collections.shuffle(list2);
        Collections.shuffle(list2);
        Collections.shuffle(list2);
        Collections.shuffle(list2);
    }
}

字符串排序

public class ListLambda2 {
    public static void main(String[] args) {
        String[] langs ={"java","javascript","c","go","python"};
        System.out.println(Arrays.toString(langs));

        //升序 Arrays工具类：sort 静态方法
        Arrays.sort(langs);
        System.out.println(Arrays.toString(langs));

        //降序
        //Arrays.sort(langs,(a,b)->b.compareTo(a));
        Arrays.sort(langs, Comparator.reverseOrder());
        System.out.println(Arrays.toString(langs));

        //乱序
        Random rand=new Random();
        Arrays.sort(langs,(a,b)->rand.nextBoolean()?1:-1);
        Arrays.sort(langs,(a,b)->rand.nextBoolean()?1:-1);
        Arrays.sort(langs,(a,b)->rand.nextBoolean()?1:-1);
        Arrays.sort(langs,(a,b)->rand.nextBoolean()?1:-1);

        //根据字母个数
        //Arrays.sort(langs,(a,b)-> a.length()-b.length());
        Arrays.sort(langs,Comparator.comparingInt(String::length));
        System.out.println(Arrays.toString(langs));

        //根据字母个数
        Arrays.sort(langs,(a,b)->b.length()-a.length());
        System.out.println(Arrays.toString(langs));

    }
}

自定义对象排序

public class ListLambda3 {
    //定义use.java
    public class User {
        private int id;
        private String name;
        private int score;

        public User() {
        }

        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 int getScore() {
            return score;
        }

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

        public User(int id, String name, int score) {
            this.id = id;
            this.name = name;
            this.score = score;
        }

        @Override
        public String toString() {
            return "User [id=" + id + "name=" + name + ",score=" + score + "]";
        }
    }

    //演示案例
    public static void main(String[] args) {
        List<User> list = new ArrayList<>(List.of(new User(42, "Andy", 18), new User(600, "张三丰", 72), new User(1, "jack", 80), new User(2, "李四", 45), new User(36, "张三", 60), new User(60, "james", 90)));
        //User a.User b->a.getScore()-b.getSore()
        list.sort((a, b) -> b.getScore() - a.getScore());
        System.out.println(list);
        //根据姓名升序
        list.sort((a, b) -> a.getName().compareTo(b.getName()));
        System.out.println(list);
    }

    public class Book implements Comparable<Book> {
        private int id;
        private String bookName;
        private String author;
        private double price;

        @Override
        public int compareTo(Book o) {
            //默认使用的价格
            //return price - o.price > 0 ? -1 : 1;
            return id - o.id;
        }
    }

    public static void main(String[] args) {
        //建立对象集合 
        List<Book> books = new ArrayList<>(List.of(new Book(1, "《java基础入门》", "李四", 38), new Book(20, "《html基础》", "王四", 28), new Book(15, "《企业项目初步》", "赵四", 18), new Book(33, "《mysql》", "张四", 88), new Book(9, "《数据库视频》", "李四", 55)));
        System.out.println(books);
        //Collections.sort(books); 此排序是默认的排序方式，实现 implements Comparable<Book> 的方法 compareTo(Book o) 
        // 乱 
        Collections.shuffle(books);
        System.out.println(books);
        //根据价格降 
        Collections.sort(books, (a, b) -> b.getPrice() - a.getPrice() > 0 ? 1 : -1);
        System.out.println(books);
    }
}

···