java8 Lambda表达式的学习与测试

关于Lambda表达式，最初只是知道当实现一个接口时，可以使用Lambda表达式来使代码简化。最近看了一些文章，发现自己只是知道了一点皮毛...

Lambda表达式

Lambda表达式的格式大致是这样的：(arguments)-> {body}

线程Runnable接口的实现

		//Runnable匿名类
		new Thread(new Runnable(){
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println(Thread.currentThread().getName());
			}
		}).start();
		
		//使用Lambda表达式
		new Thread(() -> System.out.println(Thread.currentThread().getName())).start();

比较器

		//比较器由小到大
		Integer[] num = {2, 4, 6, 1, 9, 3, 0, 7};
		Arrays.sort(num, new Comparator<Integer>(){

			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO Auto-generated method stub
				return o1 - o2;
			}
			
		});
		System.out.println(Arrays.toString(num));
		//由大到小
		Arrays.sort(num, (o1, o2) -> o2 - o1);
		//Arrays.sort(num, (Integer o1, Integer o2) -> o2 - o1);
		//Arrays.sort(num, (Integer o1, Integer o2) -> {return o2 - o1;});
		System.out.println(Arrays.toString(num));

当然还有过滤器

函数式接口

• Function<T, R> - 函数：输入 T 输出 R
• BiFunction<T, U, R> - 函数：输入 T 和 U 输出 R 对象
• Predicate<T> - 断言/判断：输入 T 输出 boolean
• BiPredicate<T, U> - 断言/判断：输入 T 和 U 输出 boolean
• Supplier<T> - 生产者：无输入，输出 T
• Consumer<T> - 消费者：输入 T，无输出
• BiConsumer<T, U> - 消费者：输入 T 和 U 无输出
• UnaryOperator<T> - 单元运算：输入 T 输出 T
• BinaryOperator<T> - 二元运算：输入 T 和 T 输出 T

方法引用

		//1. 常规方法
		Predicate<Integer> isPosit = new Predicate<Integer>() {
			@Override
			public boolean test(Integer t) {
				// TODO Auto-generated method stub
				return t > 0;
			}};
		System.out.println(isPosit.test(-7));
		
		//2. Lambda表达式
		//Function<T, R> 输入T类型，输出R类型
		Function<String, Integer> strToInt = str -> Integer.valueOf(str);
		System.out.println(strToInt.apply("10085") + 1);
		
		//Predicate<T>断言
		int a = -1;
		Predicate<Integer> isPositive = num -> num > 0;
		Predicate<Integer> isNegative = num -> {return num < 0;};
		System.out.println(isPositive.test(a));
		System.out.println(isNegative.test(a));
		
		//3. 方法引用-只调用一个方法的Lambda表达式的简化
		Function<Integer, String> intToStr = String::valueOf;
//		Function<Integer, String> intToStr = i -> String.valueOf(i);
		System.out.println(intToStr.apply(3*123));

构造方法，构造一个字符串数组

		//传统方法
		Function<Integer, String[]> fixedArray = new Function<Integer, String[]>() {

			@Override
			public String[] apply(Integer t) {
				// TODO Auto-generated method stub
				return new String[t];
			}
			
		};
		System.out.println(fixedArray.apply(10).length);
		
		//Lambda
		Function<Integer, String[]> fixedArray2 = i -> new String[i];
		System.out.println(fixedArray2.apply(15).length);
		
		//方法的引用
		Function<Integer, String[]> fixedArray3 = String[]::new;
		System.out.println(fixedArray3.apply(25).length);

Stream

public class Employee {

    private String name;
    private String sex;
    private int age;

    public Employee(String name, String sex, int age) {
        super();
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    public String getSex() {
        return sex;
    }
    public int getAge() {
        return age;
    }
    
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("Employee:[name=").append(name).append(", sex=").append(sex).append(", age=").append(age)
                .append("]");
        return builder.toString();
    }        
}

	@Test
	/**
	 * Stream测试
	 */
	public void StreamTEST() {
		
		List<Employee> employs = new ArrayList<>();
		
		employs.add(new Employee("张三", "男", 25));
		employs.add(new Employee("李四", "女", 24));
		employs.add(new Employee("王五", "女", 23));
		employs.add(new Employee("赵六", "男", 22));
		employs.add(new Employee("孙七", "女", 21));
		employs.add(new Employee("周八", "男", 20));
		employs.add(new Employee("吴九", "女", 19));
		employs.add(new Employee("郑十", "男", 18));
		
		Consumer<Employee> printAction = System.out::println;
		
		//打印所有员工
		System.out.println("打印所有员工");
		employs.stream().forEach(printAction);
		//employs.forEach(printAction);
		
		//按年龄排序
		System.out.println("按照年龄排序");
		//Collections.sort(employs, (e1, e2)-> e1.getAge()-e2.getAge());
		//employs.forEach(printAction);
		employs.stream()
			.sorted((e1, e2) -> e1.getAge() - e2.getAge())
			.forEach(printAction);
		
		//打印年龄最大女工
		System.out.println("打印年龄最大女工");
		Employee maxAgeWoman = employs.stream()
				.filter(e -> "女".equals(e.getSex())).max((e1, e2) -> e1.getAge()-e2.getAge())
				.get();
		printAction.accept(maxAgeWoman);
		
		//打印年龄大于20的男员工
		System.out.println("打印所有年龄大于20的男员工");
		employs.stream().filter(e -> e.getAge() > 20 && "男".equals(e.getSex())).forEach(printAction);
		
		//打印年龄最大的2名员工
		System.out.println("打印所有年龄最大的两名男员工");
		employs
			.stream()
			.filter(e -> "男".equals(e.getSex()))
			.sorted((e1, e2) -> e2.getAge()-e1.getAge())
			.limit(2)
			.forEach(printAction);
		
		//打印所有员工姓名，使用", "分割
		Collector<CharSequence, ?, String> collByComma =  Collectors.joining(", ");
		String s = employs.stream().map(Employee::getName).collect(collByComma);
		System.out.println("所有员工:" + s);
		
		//统计信息
		IntSummaryStatistics summary = employs.stream().mapToInt(Employee::getAge).summaryStatistics();
		System.out.println("员工个数:" + summary.getCount());
		System.out.println("平均年龄:" + summary.getAverage());
		System.out.println("最大年龄:" + summary.getMax());
		System.out.println("最小年龄:" + summary.getMin());
		System.out.println("年龄总和:" + summary.getSum());
		
		//分组
		System.out.println("男士");
		Collector<Employee, ?, Map<String, List<Employee>>> collBySex = Collectors.groupingBy(Employee::getSex);
		Map<String, List<Employee>> map = employs.stream().collect(collBySex);
		map.get("男").forEach(printAction);
		System.out.println("女士");
		map.get("女").forEach(printAction);
		
		Collector<Employee, ?, Integer> totalAges = Collectors.summingInt(Employee::getAge);
		Collector<Employee, ?, Map<String, Integer>> totalAgesBySex = Collectors.groupingBy(Employee::getSex, totalAges);
		Map<String, Integer> totalBySex = employs.stream().collect(totalAgesBySex);
		System.out.println("男生年龄总和:" + totalBySex.get("男"));
		System.out.println("女生年龄总和:" + totalBySex.get("女"));
		
		
		Collector<Employee, ?, Map<Boolean, List<Employee>>> partByAgeSize = Collectors.partitioningBy(e -> e.getAge()> 20);
		Map<Boolean, List<Employee>> mapByAgeSize = employs.stream().collect(partByAgeSize);
		System.out.println("年龄大于20");
		mapByAgeSize.get(true).forEach(printAction);
		System.out.println("年龄小于等于20");
		mapByAgeSize.get(false).forEach(printAction);
		
		//
	}
	

详细请看，Java Lambda 表达式学习笔记 http://bbs.jointforce.com/topic/20028 (出处: 解放号论坛)