Java 8 新特性：Lambda、Stream和日期处理

1. Lambda

• 简介
  
    Lambda表达式（Lambda Expression）是匿名函数，Lambda表达式基于数学中的λ演算得名，对应于其中的Lambda抽象（Lambda Abstraction），它是一个匿名函数，即没有函数名的函数。
• 示例

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

/**
 * 测试Java8 Lambda
 *
 * @author CL
 *
 */
public class TestLambda {

	/**
	 * 遍历
	 */
	@Test
	@SuppressWarnings("serial")
	public void print() {
		// 1. 遍历List
		List<Integer> list = new ArrayList<Integer>() {
			{
				add(1);
				add(2);
				add(3);
			}
		};

		list.forEach(n -> {
			System.out.println(n);
		});

		System.out.println("------------");

		list.forEach(System.out::println);

		System.out.println("------------");

		// 2. 遍历Set
		Set<Integer> set = new HashSet<Integer>() {
			{
				add(1);
				add(2);
				add(3);
			}
		};

		set.forEach(n -> {
			System.out.println(n);
		});

		System.out.println("------------");

		set.forEach(System.out::println);

		System.out.println("------------");

		// 3. 遍历Map
		Map<String, Object> map = new HashMap<String, Object>() {
			{
				put("id", 1);
				put("name", "张三");
				put("age", 18);
			}
		};

		map.forEach((k, v) -> {
			System.out.println(k + " -> " + v);
		});
	}

	/**
	 * 创建线程
	 */
	@Test
	public void create() {
		Runnable r1 = new Runnable() {

			@Override
			public void run() {
				System.out.println("r1");
			}
		};

		r1.run();

		System.out.println("------------");

		Runnable r2 = () -> {
			System.out.println("r2");
		};
		r2.run();
	}

}

2. Stream

• 简介
  
    Stream使用一种类似于SQL语句方式来提供对Java集合运算和表达的抽象。Stream API可以使代码更加高效、干净、简洁。这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，如筛选、 排序、聚合等。
• 示例

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.Stack;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.junit.Test;

/**
 * 测试Java8 Stream
 *
 * @author CL
 *
 */
public class TestStream {

	/**
	 * 过滤
	 */
	@Test
	@SuppressWarnings("serial")
	public void filter() {
		List<Integer> list = new ArrayList<Integer>() {
			{
				add(1);
				add(2);
				add(2);
				add(3);
				add(4);
			}
		};

		// 过滤3
		list = list.stream().filter(n -> (n != 3)).collect(Collectors.toList());
		list.forEach(System.out::println);
	}

	/**
	 * 构造流
	 */
	@Test
	@SuppressWarnings({ "rawtypes", "unused" })
	public void build() {
		// 第一种
		Stream s1 = Stream.of("a", "b", "c");

		// 第二种
		String[] strArray = new String[] { "a", "b", "c" };
		Stream s2 = Stream.of(strArray);

		// 第三种
		Stream s3 = Arrays.stream(strArray);

		// 第四种
		List<String> strList = Arrays.asList(strArray);
		Stream s4 = strList.stream();
	}

	/**
	 * 转换
	 */
	@Test
	@SuppressWarnings({ "rawtypes", "unused" })
	public void transfer() {
		Stream<String> stream = Stream.of("a", "b", "c");

		// 转换成String数组
		String[] array = stream.toArray(String[]::new);

		// 转换成String
		String str = stream.collect(Collectors.joining(",")).toString();

		// 转换成List
		List<String> list1 = stream.collect(Collectors.toList());
		List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));

		// 转换成Set
		Set<String> set = stream.collect(Collectors.toSet());

		// 转换成堆
		Stack stack = stream.collect(Collectors.toCollection(Stack::new));
	}

	/**
	 * Stream.map方法，映射元素结果（一对一）
	 */
	@Test
	@SuppressWarnings("serial")
	public void map() {
		// 转换大写
		List<String> list = Arrays.asList("a", "b", "c");
		list = list.stream().map(String::toUpperCase).collect(Collectors.toList());
		list.forEach(System.out::println);

		System.out.println("------------");

		// 转换数据类型
		List<String> list2 = Arrays.asList("1", "2", "3");
		List<Integer> list3 = list2.stream().map(Integer::valueOf).collect(Collectors.toList());
		list3.forEach(System.out::println);

		System.out.println("------------");

		// 计算结果
		List<Integer> list4 = Arrays.asList(1, 2, 3);
		list4 = list4.stream().map(n -> (n * 2)).collect(Collectors.toList());
		list4.forEach(System.out::println);

		System.out.println("------------");

		// 计算除去3之后的和及个数
		List<Integer> list5 = Arrays.asList(1, 2, 3, 4, 5);
		int sum = list5.stream().filter(n -> (n != 3)).mapToInt(n -> n).sum();
		long count = list5.stream().filter(n -> (n != 3)).mapToInt(n -> n).count();
		System.out.println(sum);
		System.out.println(count);

		System.out.println("------------");

		// 统计员工的工资和
		List<User> userList = new ArrayList<User>() {
			{
				add(new User(1, "张三", 1203.12));
				add(new User(2, "李四", 2856.43));
				add(new User(3, "王五", 947.63));
			}
		};
		double sum2 = userList.stream().mapToDouble(u -> u.getSalary()).sum();
		System.out.println(sum2);

		System.out.println("------------");

		// 统计工资大于1000的人数
		long count2 = userList.stream().filter(u -> (u.getSalary() > 1000)).mapToInt(u -> u.getId()).count();
		System.out.println(count2);
	}

	/**
	 * Stream.flatMap方法，映射元素结果（一对多）
	 */
	@Test
	@SuppressWarnings("serial")
	public void flatMap() {
		List<String> list = new ArrayList<String>() {
			{
				add("Knowledge is power");
			}
		};

		// 分割单词
		list = list.stream().flatMap(str -> Stream.of(str.split(" "))).filter(s -> s.length() > 0)
				.collect(Collectors.toList());
		list.forEach(System.out::println);
	}

	/**
	 * 限制
	 */
	@Test
	public void limit() {
		List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

		// 取前3条数据
		List<Integer> list1 = list.stream().limit(3).collect(Collectors.toList());
		list1.forEach(System.out::println);

		System.out.println("------------");

		// 从第2条数据开始取3条数据
		List<Integer> list2 = list.stream().skip(2).limit(3).collect(Collectors.toList());
		list2.forEach(System.out::println);
	}

	/**
	 * 排序
	 */
	@Test
	@SuppressWarnings("serial")
	public void sort() {
		List<Integer> list = Arrays.asList(4, 2, 6, 1, 7, 3, 8, 5);

		// 默认升序
		List<Integer> list1 = list.stream().sorted().collect(Collectors.toList());
		list1.forEach(System.out::println);

		System.out.println("------------");

		// 按照员工工资降序排序
		List<User> userList = new ArrayList<User>() {
			{
				add(new User(1, "张三", 1203.12));
				add(new User(2, "李四", 2856.43));
				add(new User(3, "王五", 947.63));
			}
		};

		List<User> list2 = userList.stream().sorted((u1, u2) -> (u2.getSalary().compareTo(u1.getSalary())))
				.collect(Collectors.toList());
		list2.forEach(System.out::println);
	}

	/**
	 * Stream.peek方法，返回新的Stream
	 */
	@Test
	public void peek() {
		List<Integer> list = Arrays.asList(1, 2, 2, 3, 4);

		// 过滤掉不等于2和大于3的数后计算和
		int sum = list.stream().filter(n -> (n != 2)).peek(n -> {
			// 中间处理
		}).filter(n -> (n > 3)).peek(n -> {
			// 中间处理
		}).mapToInt(n -> n).sum();
		System.out.println(sum);
	}

	/**
	 * 并行流
	 */
	@Test
	public void parallelStream() {
		List<Integer> list = Arrays.asList(1, 2, 2, 3, 4);

		// 统计2的个数
		long count = list.parallelStream().filter(n -> (n == 2)).count();
		System.out.println(count);
	}

	/**
	 * 最大、最小、去重
	 */
	@Test
	public void maxAndMinAndDistinct() {
		List<Integer> list = Arrays.asList(1, 2, 2, 3, 4);

		// 最大值
		Integer max = list.stream().max((a, b) -> a.compareTo(b)).get();
		System.out.println(max);

		System.out.println("------------");

		// 最小值
		Integer min = list.stream().min((a, b) -> a.compareTo(b)).get();
		System.out.println(min);

		System.out.println("------------");

		// 去重
		list = list.stream().distinct().collect(Collectors.toList());
		list.forEach(System.out::println);
	}

	/**
	 * 匹配<br/>
	 * allMatch：全部元素符合则返回 true <br/>
	 * anyMatch：只要有一个元素符合则返回 true <br/>
	 * noneMatch：没有一个元素符合则返回 true <br/>
	 */
	@Test
	@SuppressWarnings("serial")
	public void match() {
		List<User> userList = new ArrayList<User>() {
			{
				add(new User(1, "张三", 1203.12));
				add(new User(2, "李四", 2856.43));
				add(new User(3, "王五", 947.63));
			}
		};

		// 判断所有人的工资都大于2000
		boolean allMatch = userList.stream().allMatch(u -> (u.getSalary() > 2000));
		System.out.println(allMatch);

		System.out.println("------------");

		boolean anyMatch = userList.stream().anyMatch(u -> (u.getSalary() > 2000));
		System.out.println(anyMatch);

		System.out.println("------------");

		boolean noneMatch = userList.stream().noneMatch(u -> (u.getSalary() > 2000));
		System.out.println(noneMatch);
	}

	/**
	 * reduce和Stream组合使用
	 */
	@Test
	public void reduce() {
		// 拼接
		List<String> list = Arrays.asList("Knowledge", " ", "is", " ", "power");
		String str = list.stream().reduce("", String::concat);
		System.out.println(str);

		System.out.println("------------");

		// 求和
		List<Integer> list2 = Arrays.asList(1, 2, 3, 4);
		Integer sum = list2.stream().reduce(Integer::sum).get();
		System.out.println(sum);
	}

	/**
	 * Stream.iterate方法
	 */
	@Test
	public void iterate() {
		// 生成等差2的数列
		Stream.iterate(2, n -> n + 2).limit(5).forEach(System.out::println);
	}

	/**
	 * 分组排序和分区排序 <br/>
	 * groupingBy：分组排序 <br/>
	 * partitioningBy：分区排序 <br/>
	 */
	@Test
	@SuppressWarnings("serial")
	public void groupyAndPartition() {
		List<User> userList = new ArrayList<User>() {
			{
				add(new User(1, "张三", 1203.12));
				add(new User(2, "李四", 2856.43));
				add(new User(3, "王五", 947.63));
				add(new User(3, "张六", 2417.05));
			}
		};

		// 分组排序
		Map<String, List<User>> resultMap = userList.stream().collect(Collectors.groupingBy(User::getName));
		for (Map.Entry<String, List<User>> entry : resultMap.entrySet()) {
			entry.getValue().forEach(v -> System.out.println(entry.getKey() + " -> " + v));
		}

		System.out.println("------------");

		// 分区排序
		Map<Boolean, List<User>> resultMap2 = userList.stream()
				.collect(Collectors.partitioningBy(u -> (u.getSalary() > 2000)));
		// 大于2000
		System.out.println(resultMap2.get(true));

		System.out.println("------------");

		// 不大于2000
		System.out.println(resultMap2.get(false));
	}

	/**
	 * 收集统计
	 */
	@Test
	public void summaryStatistics() {
		List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
		IntSummaryStatistics summaryStatistics = list.stream().mapToInt(n -> n).summaryStatistics();

		// 最大值
		System.out.println(summaryStatistics.getMax());

		// 最小值
		System.out.println(summaryStatistics.getMin());

		// 求和
		System.out.println(summaryStatistics.getSum());

		// 平均值
		System.out.println(summaryStatistics.getAverage());

		// 数量
		System.out.println(summaryStatistics.getCount());
	}

	/**
	 * 自定义流
	 */
	@Test
	public void supplier() {
		/**
		 * 自定义用户流处理类
		 *
		 * @author CL
		 *
		 */
		class UserSupplier implements Supplier<User> {
			private Integer index = 1;
			private String[] names = new String[] { "张三", "李四", "王五" };
			private Random random = new Random();

			@Override
			public User get() {
				return new User(index++, names[index - 2],
						new BigDecimal(random.nextDouble() * 1000).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue());
			}

		}
		Stream.generate(new UserSupplier()).limit(3).collect(Collectors.toList()).forEach(System.out::println);
	}
}

/**
 * 用户类
 *
 * @author CL
 *
 */
class User {
	/**
	 * ID
	 */
	private Integer id;

	/**
	 * 用户名
	 */
	private String name;

	/**
	 * 工资
	 */
	private Double salary;

	public User() {
		super();
	}

	public User(Integer id, String name) {
		super();
		this.id = id;
		this.name = name;
	}

	public User(Integer id, String name, Double salary) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
	}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public Double getSalary() {
		return salary;
	}

	public void setSalary(Double salary) {
		this.salary = salary;
	}

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

3. 日期处理

  Java 8 新特性：日期处理