jdk8新特性（Lambda表达式 + 4大内置接口 + StreamingAPI）

内容

1、Lambda表达式
2、函数式接口
3、StreamingAPI

Lambda表达式

1、是对匿名内部类对象的一种格式的简化
2、Java8中引入了一个新的操作符“->”，称为箭头运算符，或者Lambda运算符
3、作用：就是用于分隔前后两部分的
4、左边：表示Lambda表达式的参数列表（接口中，定义的抽象方法的参数）
5、右边：表示的是方法的方法体，Lambda体

格式

语法格式1：没有参数，也没有返回值
 	() -> System.out.println(“Hello Lambda”);
 	
语法格式2：有一个参数，没有返回值
 	(x) -> System.out.println(x * x);
 	说明：如果只有一个参数，那么小括号可以省略
 	
语法格式3：有多个参数，没有返回值，格式和语法格式2相同
 	(x, y) -> System.out.println(x + y);
 	
语法格式4：接口中需要重写的方法，方法内容有多句，需要给多句话加上大括号
 	例如：(x, y) -> {int result = x + y; return result;}

注意事项：如果Lambda体中语句只有一句，那么大括号可以省略不写；
如果大括号中只有一条语句，并且是return语句，
那么return关键字也可以省略不写（如果要省略return关键字，就必须省略大括号）

public class Demo01_Lambda表达式的好处 {

	public static void main(String[] args) {
		test2_有Lambda表达式的形式();
	}

	private static void test2_有Lambda表达式的形式() {
		MyInter1 mi2 = () -> System.out.println("test1方法被调用了");
		mi2.test1();
	}

	private static void test1_没有Lambda表达式的方式() {
		MyInter1 mi1 = new MyInter1() {
			@Override
			public void test1() {
				System.out.println("test1方法被调用了");
			}
		};
		mi1.test1();
	}
}

interface MyInter1 {
	public abstract void test1();
}

函数式接口（默认的，拿过来就用，在括号参数的位置实现方法重写，不需要再new接口了）

	整理：
	
	Consumer<T>:消费型接口（有钱咱就花）
	接收一个数据，并且处理这个数据，处理完成之后，
	不需要返回任何数据，直接输出
	con.accept();

	Supplier<T>:供给型接口（后勤）
	提供需要用到的数据
	sup.get();
	
	Function<T, R>:函数型接口（乾坤大挪移）
	接收T类型转换为R类型
	fun.apply();
	
	Predicate<T>:断言型接口（包公断案）
	判断对与错，把控if关卡
	
	boolean    test(T t);
	Predicate  and(Predicate pre)：返回两个条件的都满足的判断对象
 	Predicate  or(Predicate pre)：返回两个条件任意一个满足的判断对象
 	Predicate  negate()：返回的是调用者判断条件的取反

//消费型接口
//
import java.util.function.Consumer;

public class Demo01 {
	public static void main(String[] args) {
		test(2000, t -> System.out.println("做了个：" + t), "大宝剑");

	}

	public static void test(int money,Consumer<String> con,String str) {
		System.out.println("花了"+money+"钱");
		con.accept(str);
	}

}

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;

//供给型接口
//生成10个100以内的随机数存储到List集合中
public class Demo01 {
	public static void main(String[] args) {
		Random rd = new Random();
		List<Integer> list = new ArrayList<Integer>();

		list = getRandom(10, () -> rd.nextInt(100));

		System.out.println(list);
	}

	//
	public static List<Integer> getRandom(int n, Supplier<Integer> sup) {
		List<Integer> list1 = new ArrayList<Integer>();

		for (int i = 0; i < n; i++) {
			list1.add(sup.get());
		}

		return list1;
	}
}

import java.util.function.Function;

//函数式接口

public class Demo01 {
	public static void main(String[] args) {
		String str = conver(666, t -> String.valueOf(t));
		System.out.println(str);
	}

	public static String conver(int num, Function<Integer, String> fun) {

		return fun.apply(num);
	}
}

import java.util.ArrayList;
import java.util.function.Predicate;

//函数式接口之断言型接口
public class Demo {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<>();
		list.add(10);
		list.add(66);
		list.add(666);
		list.add(35);
		list.add(-20);
		list.add(0);
		list.add(33);
		
		// 筛选出list集合中大于100的数字
		ArrayList<Integer> result = filtneg(list, t -> t % 2 == 0);
		System.out.println(result);

		// 筛选出list集合中偶数且大于100的数字
	}

	//
	public static ArrayList<Integer> filt(ArrayList<Integer> list, Predicate<Integer> pre, Predicate<Integer> pre2) {
		ArrayList<Integer> result = new ArrayList<Integer>();
		for (Integer i : list) {
			if (pre.and(pre2).test(i)) {
				result.add(i);
			}
		}
		
		return result;
	}

	public static ArrayList<Integer> filtor(ArrayList<Integer> list, Predicate<Integer> pre, Predicate<Integer> pre2) {
		ArrayList<Integer> result = new ArrayList<Integer>();
		for (Integer i : list) {
			if (pre.or(pre2).test(i)) {
				result.add(i);
			}
		}

		return result;
	}

	public static ArrayList<Integer> filtneg(ArrayList<Integer> list, Predicate<Integer> pre) {
		ArrayList<Integer> result = new ArrayList<Integer>();
		for (Integer i : list) {
			if (pre.negate().test(i)) {
				result.add(i);
			}
		}

		return result;
	}
}

StreamingAPI

概述

1、在jdk1.8中，提供了一个Stream类型，可以对数据进行过滤
2、好处：
 	比不断的自定义循环，要简单很多

常用方法

 	Stream<T>  filter(Predicate<? super T> pre)
 		根据pre描述的判断条件，对流中的数据进行过滤

 	Stream<T>  limit(long maxSize)
 	 	根据参数maxSize描述的个数，对流中的数据进行截取

 	Stream<T>  skip(long n)
 	 	跳过参数n描述的个数，流中剩余的是n之后的内容
 	 	
 	Stream<R>  map(Function<? super T, R> fun )
 	 	将流中的所有T类型数据，都根据fun这个函数型接口，转换成其他的R类型数据

 	forEach(Consumer<? super T>  con)
 	 	将流中的数据，根据con描述的处理方式，进行处理

 	long count()
 	 	返回流中的元素数

import java.util.ArrayList;

public class Demo {
	public static void main(String[] args) {
		ArrayList<String> names = new ArrayList<>();
		names.add("张无忌");
		names.add("张三丰");
		names.add("周芷若");
		names.add("时哥");
		names.add("赵云");
		names.add("苇名一心");

		// 截取
		testLimit(names);

		// 跳过
		testSkip(names);

		// 转换
		testMap(names);
	}

	private static void testMap(ArrayList<String> names) {
		names.stream().map(t -> t.length()).forEach(System.out::println);
	}

	private static void testSkip(ArrayList<String> names) {
		names.stream().skip(3).forEach(System.out::println);
	}

	private static void testLimit(ArrayList<String> names) {
		names.stream().limit(3).forEach(System.out::println);
	}
}

Stream类型数据的获取

1、Collection的获取：
 	调用stream()方法即可，返回Stream类型的对象
2、Map的获取：不能直接获取Stream类型
 	1、keySet().stream()
 	2、values().stream()
 	3、entrySet().stream()
3、数组的获取
 	Stream中的of方法，Stream.of(数组)

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;

public class Demo {
	public static void main(String[] args) {
		int[] num = { 1, 2, 3, 4, 5, 6 };
		
		//数组型的stream对象获取
		Stream<int[]> num_Stream = Stream.of(num);
		
		//map类型的
		Map<String, String> map = new HashMap<String, String>();
		map.put("CN", "中国");
		map.put("US", "美国");
		map.put("JP", "日本");
		Stream keyStream = map.keySet().stream();
		map.values().stream();
		map.entrySet().stream();
	}
}

作业

有两个Arraylist集合，存储队伍中的多个成员姓名，使用Stream方式，对以下步骤进行操作
1、第一个队伍只要名字为3个字的成员姓名
2、第一个队伍只要筛选之后的前三个人

3、第二个队伍只要姓张的
4、第二个队伍筛选之后不要前两个人

5、将两个队伍合并成一个队伍
6、合并之后的队伍中的所有人的Person（自定义类型）对象，存储到一个ArrayList集合中

队伍1：宫本武藏、宋公明、苏有朋、石头人、时传祥、李耳、庄子、洪七公
队伍2：帕瓦罗蒂、张三疯、赵薇薇、张自忠、孛儿只斤铁木真、张天爱、张翠花

答案

累了，不想写