第十章 Lambda 表达式 #yyds干货盘点#-CFANZ编程社区

10.1 lambda概念

Lambda 表达式”(lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包（注意和数学传统意义上的不同）

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

()->

()->{}

a->a

a->a*a

()->a

a->System.out::println;

10.2 排序实例

package part10;
import java.util.Arrays;
import java.util.Comparator;
public class Lam2 {
    public static void main(String[] args) {
        Integer[] num = new Integer[] { 1, 6, 2, 5, 10, 4 };
        System.out.println(Arrays.toString(num));

        Arrays.sort(num);
        System.out.println(Arrays.toString(num));

        //Arrays.sort(num, (a, b) -> a - b);
        Arrays.sort(num,new Comparator<Integer>() {
            public int compare(Integer a, Integer b) {
                return a-b;
            }
        });

        System.out.println(Arrays.toString(num));

        Arrays.sort(num, (a, b) -> b - a);
        /*
        Arrays.sort(num,new Comparator<Integer>() {
            public int compare(Integer a, Integer b) {
                return a-b;
            }
        }.reversed());
        */
        System.out.println(Arrays.toString(num));
    }
}

字符串排序方法

/**
 * 
 */
package part10;

import java.util.ArrayList;
import java.util.List;

/**
 * 字符串数组排序实现
 * 
 * @author webrx
 *
 */
public class Lam2 {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("java", "B", "c", "jcva", "basic", "javascript", "python", "go", "perl", "php"));
        // 没有排序
        System.out.println(list);

        // 降序
        list.sort((a, b) -> b.compareTo(a));
        System.out.println(list);

        // 升序
        list.sort((a, b) -> a.compareTo(b));
        System.out.println(list);

        //根据字符串字符的个数，按大到小排序
        list.sort((a, b) -> b.length() - a.length());
        System.out.println(list);

    }

}

对象排序方法

User.java
/**
 * 
 */
package part10;

public class User {
    private int id;
    private String name;
    private int score;
    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) {
        super();
        this.id = id;
        this.name = name;
        this.score = score;
    }
    public User() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", score=" + score + "]";
    }

}

/**
 * 
 */
package part10;

import java.util.ArrayList;
import java.util.List;

/**
 * 对象排序
 * 
 * @author webrx
 *
 */
public class Lam4 {

    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(35, "张三", 60), new User(60, "james", 90)));
        System.out.println(list);

        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);

    }

}

10.3 函数式接口

接口	参数	返回内容	描述
Predicate<T> java.util.function.Predicate	T	boolean	用于判别一个对象。比如求一个人是否为男性
Consumer<T> 消费型	T	void	用于接收一个对象进行处理但没有返回，比如接收一个人并打印他的名字
Function<T, R> 函数型	T	R	转换一个对象为不同类型的对象
Supplier<T> 供给型	None	T	提供一个对象
UnaryOperator<T>	T	T	接收对象并返回同类型的对象
BinaryOperator<T>	(T, T)	T	接收两个同类型的对象，并返回一个原类型对象

/**
 * 
 */
package part10;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.IntStream;

/**
 * 显示及格的学生信息
 * 
 * @author webrx
 *
 */
public class Lam5 {

    public static void main(String[] args) {

        List<User> list = new ArrayList<>(List.of(new User(42, "Andy", 18), new User(600, "张三丰", 52), new User(1, "jack", 80), new User(2, "李四", 45), new User(35, "张三", 60), new User(60, "james", 90)));
        // System.out.println(list);

        //list.stream().filter(e -> e.getScore() < 60).forEach(System.out::println);
        //list.stream().filter(e -> e.getScore() < 60).forEach(e -> System.out.println(e));

        //list.stream().filter(e -> e.getScore() < 60 && !e.getName().startsWith("李")).forEach(System.out::println);

        Random rand = new Random();
        IntStream.generate(()->rand.nextInt(100)+1).limit(10).forEach(System.out::println);

    }

}

10.4 Stream流技术

IntStream

/**
 * 
 */
package part10;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.IntConsumer;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * IntStream
 * 
 * @author webrx
 *
 */
public class IntStreamTest {

    public static void main(String[] args) {

        IntStream is = IntStream.of(10, 20, 30, 40, 50);
        is.forEach(System.out::println);

        System.out.println(IntStream.rangeClosed(1, 100).sum());
        System.out.println(IntStream.generate(() -> 5).limit(3).count());

        IntStream i2 = IntStream.generate(() -> {
            Random rand = new Random();
            return rand.nextInt(100) + 1;
        }).limit(10);

        IntConsumer ic = (a) -> {
            System.out.printf("%d ", a);
        };

        i2.forEach(ic);
        System.out.println();

        IntStream.iterate(1, a -> a + 2).limit(5).forEach(ic);
        System.out.println();

        IntStream.iterate(2, a -> a + 2).skip(3).limit(15).forEach(ic);

        // IntStream 转换为 List<Integer>
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(1);
        list.add(1);

        System.out.println();
        // list.stream().forEach(System.out::println); //Stream<Integer>

        //Stream<Integer> ss = list.stream();
        IntStream ii2 = list.stream().mapToInt(i -> i);

        //Stream<Integer> sa = ii2.boxed();
        List<Integer> lis = ii2.boxed().collect(Collectors.toList());
        System.out.println(lis.size());

        // IntStream.iterate(1, a->a+2).limit(5).col

        List<String> as = List.of("java","php");
        Stream<String> sss = as.stream();

    }

}

Stream

/**
* 
*/
package part10;

import java.io.BufferedReader;
import java.util.Arrays;
import java.util.stream.Stream;

/**
* 显示及格的学生信息
* 
* @author webrx
*
*/
public class Stream1 {

public static void main(String[] args) {

    int[] nums = new int[] { 1, 2, 3, 10, 20, 30, 50 };
    System.out.println(Arrays.stream(nums).min().getAsInt());
    System.out.println(Arrays.stream(nums).max().getAsInt());
    System.out.println(Arrays.stream(nums).count());// 3
    System.out.println(Arrays.stream(nums).sum());// 6
    System.out.printf("%.2f%n",Arrays.stream(nums).average().getAsDouble());

    Arrays.stream(nums).forEach(e -> System.out.printf("%02d ", e));

    //BufferedReader br = null;
    //Stream<String> c = br.lines();
}

}

/**
* 
*/
package part10;

import java.util.Arrays;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
* 显示及格的学生信息
* 
* @author webrx
*
*/
public class Stream2 {

public static void main(String[] args) {

    // Stream<String> ss = Stream.of("java", "javascript", "mysql", "php",
    // "python");

    // ss.filter(e -> e.startsWith("java")).map(e ->
    // e.toUpperCase()).forEach(System.out::println);;

    int[] nums = new int[] { 30,1, 3, 5 ,20,15,100};
    // IntStream is = Arrays.stream(nums).map(e -> e + 5);
    IntStream is = Arrays.stream(nums).map(e -> e % 5 == 0 ? e + 5 : e);
    is.forEach(System.out::println);

    double[] dd = new double[10];
    Arrays.stream(dd).map(e->Math.random()).forEach(e->System.out.printf("%.2f ",e));

    System.out.println();
    System.out.println(Stream.of(1,2,3,1,6,8,1,9,10,1,22).distinct().count());

}

}

/**
* 
*/
package part10;

import java.util.Arrays;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
* 显示及格的学生信息
* 
* @author webrx
*
*/
public class Stream3 {

public static void main(String[] args) {

    int num = 6;
    IntStream is = IntStream.rangeClosed(1, 6);
    int ok = is.reduce(1, (a, b) -> a * b);
    System.out.println(ok);

    System.out.println(1 * 1 * 2 * 3 * 4 * 5 * 6);

    Stream<String> aa = Stam.of("mysql","php","java","javascript");
    System.out.println(aa.reduce("", (a,b)->a.concat(b)));

}

}

10.5 表达式双冒号

package cn.exam;

import java.util.Random;

public class User {
    private String name;
    private String sex;
    private boolean isMan;

    public User(String name,String sex){
        this.name = name;
        this.sex =sex;
        this.isMan = "男".equals(this.sex) ? true : false;
    }

    public static void println(User u){
        System.out.println(u);
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public boolean isMan() {
        return isMan;
    }

    public void setMan(boolean man) {
        isMan = man;
    }

    private static Random rand = new Random();
    public static int rand(){
        return rand.nextInt(100)+1;
    }

    public static void println(int i) {
        System.out.printf("%02d ",i);
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", isMan=" + isMan +
                '}';
    }
}

package cn.exam;
import java.io.*;
import java.net.InetAddress;
import java.util.Random;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class My {
    public static void main(String[] args) throws IOException {
        DoubleStream ds1 = DoubleStream.generate(Math::random).limit(5);
        DoubleStream ds2 = DoubleStream.generate(()->Math.random()).limit(5);

        Stream<Random> sr1 = Stream.generate(Random::new).limit(5);
        Stream<Random> sr2 = Stream.generate(()->new Random()).limit(5);

        IntStream is = IntStream.generate(User::rand).limit(10);

        is.forEach(User::println);

        //Stream<User> su1 = Stream.generate(User::new).limit(5);
        Random ran = new Random();
        Stream<User> su2 = Stream.generate(()->new User("jack"+Math.random(),ran.nextBoolean() ? "男":"女")).limit(15);
        //su2.filter((u)->u.isMan()).forEach(System.out::println);
        //su2.filter(User::isMan).forEach(User::println);
        su2.filter(User::isMan).forEach(e->e.println(e));

    }
}

作业：

求1+2+3+…+100 = ? 不使用循环和递归