java8的新特性:函数式编程，Lambda表达式

java8的新特性

1.接口的默认方法

1)在接口中添加一个非抽象方法，只需要使用default关键字就可以
2)我们把这个非抽象方法理解成一个扩展方法
3)将来在实现类可以直接访问此默认方法

2.函数式编程

1)概念：一切皆函数
2)将处理问题的粒度从类变成函数，从而可以更好的满足系统对可重用性和可扩展性的支持
3)可以将函数作为参数传递给另外一个函数
4)可以简化代码的操作,函数运行的结果只依赖于输入的参数
5)优点：开发速度快，易于并发编程（不需要考虑死锁）
6)缺点：函数式编程比较耗费CPU资源，学习难度高，代码维护性差

3.Lambda表达式

1)是一种新的语法形式，简化了开发的编码操作，由编译器转化为常规的代码
2)可以理解成函数式编程的体现方式
3)允许通过表达式代替功能接口，就类似于匿名方法（有参数列表和代码块）
4)语法：-> 称为lambda表达式的操作符
结构：（parameters） -> expression|{statements}；可以看成两个部分，左侧是参数列表，右侧是表达式所要执行的代码块（主体结构）

String[] arrays = {"c","a","d","b"};
//使用函数式编程
//Arrays.sort(arrays, String::compareTo);
Arrays.sort(arrays,(x,y) -> x.compareTo(y));
// 通过asList()方法将一个数组转化为集合
List<String> names = Arrays.asList("jack","tina","cinda","tom");
//使用lambda表达式及函数操作
names.forEach((name) -> {System.out.println(name);});
// 使用：：操作符(一个参数，一个输出)
names.forEach(System.out::println);
// 查询集合中带有tina的元素
System.out.println("----------------------");
names.forEach(item -> {
	if("tina".equals(item)) {
		System.out.println(item);
	}
});

不管数组还是自定义类的List，都有相应的sort()方法，都可以用lambda表达式。集合也可以用Collections工具类的sort()方法，不过参数需要注意。

List<Person> persons = new ArrayList<>();
persons.add(new Person("a",22));
persons.add(new Person("d",20));
persons.add(new Person("r",22));
persons.add(new Person("c",21));
persons.add(new Person("b",22));
//persons.sort((x,y) -> x.compareTo(y));
//使用Collections提供的方法进行排序
//对于函数题只有一行代码的，可以去掉{}以及return关键字，Java编译器自动检测参数类型
Comparator<Person> comparator = (a,b) -> a.compareTo(b);
Collections.sort(persons,comparator);
for (Person person : persons) {
	System.out.println(person);
}

5)应用场景：
— 使用内部迭代取代外部迭代。
外部迭代：描述怎么干，只能顺序处理List集合中的元素
内部迭代：描述干什么，不一定按照顺序处理List中的元素，使用foreach
— 以流水线的方式处理数据：使用Stream ，Stream对集合的包装，通 常和lambda表达式一起使用。
支持很多操作：filter,limit,sort,max,min,collect,sum,map

		List<Person> list = new ArrayList<>();
		list.add(new Person("a",22));
		list.add(new Person("d",19));
		list.add(new Person("r",22));
		list.add(new Person("c",21));
		list.add(new Person("b",24));
		//对集合中的每个人年龄增加
		list.forEach(p -> p.setAge(p.getAge()+1));
		for (Person person : list) {
			System.out.println(person);
		}
		//集合中年龄大于22岁的:使用过滤器filter（）
		list.stream()
			.filter(p -> p.getAge()>22)
			.forEach(p -> System.out.println(p));
		System.out.println("----------------");
		//获取前三元素
		list.stream()
			.sorted((p1,p2) -> p1.compareTo(p2))
			.limit(3)
			.forEach(p -> System.out.println(p));
		//取得最大年龄最小年龄
		//获取最大最小max(),min()
		//获取一个对象用get()
		System.out.println("---------------------");
		Person p = list.stream()
				.max((p1,p2) -> p1.getAge()-p2.getAge())
				.get();
		System.out.println(p);
			
	}

另外：

			List<Integer> list = Arrays.asList(4,5,6,1,2,3,10,11);
			//查询偶数列表
			List<Integer> evens = list.stream()
					.filter(i -> i%2==0)
					.collect(Collectors.toList());
			System.out.println(evens);
			// 排序并取得前五个元素
			List<Integer> sort = list.stream()
					.sorted((x,y) -> y-x)
					.limit(5)
					.collect(Collectors.toList());
			System.out.println(sort);
			// 取得集合中的元素平方值
			list.stream()
				.map(i -> (int)Math.pow(i, 2))//指定规则
				.filter(i -> i>20)
				.forEach(x -> System.out.println(x));			
			//将集合中的元素按照奇数偶数分组
			Map<Boolean, List<Integer>> map = list.stream()
					.collect(Collectors.groupingBy(i -> i%2==0));
		}