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 (出处: 解放号论坛)