java进阶打卡37

Function接口的默认方法andThen

用来进行组合操作

需求：
    把String类型的"123"，转化为Integer类型，把转换后的结果加10
    把增加之后的Integer类型的数据，转换为String类型

分析：
    转换了两次
    第一次是把String类型转换为了Integer类型，所以我们可以使用Function<String,Integer> fun1
            Integer i = fun1.apply("123") + 10;
    第二次是把Integer类型转换为String类型，所以我们可以使用Function<Integer,String> fun2
            String s = fun2.apply(i);
    我们可以使用andThen方法，把两次转换组合再一起使用
        String s = fun1.andThen(fun2).apply("123");
        fun1先调用apply方法，把字符串转换为Integer
        fun2再调用apply方法，把Integer转换为字符串

// 定义一个方法：参数传递一个字符串类型的整数和两个Function接口。一个泛型使用Function<String,Integer>，一个泛型使用Function<Integer,String>。
public static void change(String s, Function<String,Integer> fun1,Function<Integer,String> fun2){
	String ss = fun1.andThen(fun2).apply(s);
    System.out.println(ss);
}

public static void main(String[] args) {
	String s = "123";
    // 调用change方法，传递字符串和两个Lambda表达式
    change(s,(String str)->{
    	// 把字符串转换为整数+10
        return Integer.parseInt(str) + 10;
	},(Integer i)->{
        // 把整数转换为字符串
        return i + "";
	});

	// 优化Lambda表达式
    change(s,str->Integer.parseInt(str) + 10,i->i + "");
}

• 练习
  自定义函数模型拼接

题目
请使用Function进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
    String str = "Xxx，20";

分析：
1. 将字符串截取数字年龄部分，得到字符串；
    Function<String,String> "Xxx，20"->"20"
2. 将上一步的字符串转换为int类型的数字；
    Function<String,Integer> "20"->20
3. 将上一步的int数字累加100，得到结果int数字。
    Function<Integer,Integer> 20->120

// 定义一个方法:参数传递包含姓名和年龄的字符串和3个Function接口用于类型转换
public static int change(String s, Function<String,String> fun1,
                             Function<String,Integer> fun2,Function<Integer,Integer> fun3){
	// 使用andThen方法把三个转换组合到一起
    return fun1.andThen(fun2).andThen(fun3).apply(s);
}

public static void main(String[] args) {
	String str = "Xxx，20";
    // 调用change方法，参数传递字符串和3个Lambda表达式
    int num = change(str,(String s)->{
    	// "Xxx，20"->"20"
        return s.split("，")[1];
	},(String s)->{
        // "20"->20
        return Integer.parseInt(s);
	},(Integer i)->{
        // 20->120
        return i + 100;
	});
	System.out.println(num);
}

遍历集合，对集合中的数据进行过滤

• 传统方式

public static void main(String[] args) {
	// 创建一个List集合，存储姓名
    List<String> list = new ArrayList<>();
    list.add("张无忌");
    list.add("周芷若");
    list.add("赵敏");
    list.add("张强");
    list.add("张三丰");

	// 对List集合中的元素进行过滤，只要以张开头的元素，存储到一个新的集合中
    List<String> listA = new ArrayList<>();
    for (String s : list) {
    	if(s.startsWith("张")){
    		listA.add(s);
        }
	}

	// 对listA集合进行过滤，只要姓名长度为3的人，存储到一个新集合中
    List<String> listB = new ArrayList<>();
    for (String s : listA) {
		if(s.length()==3){
        	listB.add(s);
        }
	}

	// 遍历listB集合
    for (String s : listB) {
    	System.out.println(s);
    }
}

• Stream流方式
  Stream流是JDK1.8之后出现的。关注的是做什么，而不是怎么做。

public static void main(String[] args) {
	// 创建一个List集合，存储姓名
    List<String> list = new ArrayList<>();
    list.add("张无忌");
	list.add("周芷若");
    list.add("赵敏");
    list.add("张强");
    list.add("张三丰");

	// 对List集合中的元素进行过滤，只要以张开头的元素，存储到一个新的集合中
	// 对listA集合进行过滤，只要姓名长度为3的人，存储到一个新集合中
	// 遍历listB集合
	list.stream()
		.filter(name->name.startsWith("张"))
		.filter(name->name.length()==3)
        .forEach(name-> System.out.println(name));
}

流式思想

ABCDE--filter->ABCD--map->AaBbCcDd--skip->BbCcDd--count->3
这展示了过滤、映射、跳过、计数等多步操作，这是一种集合元素的处理方案，而方案就是一种“函数模型”。途中的每个方框都是一个流，调用指定的方法，可以从一个流模型转换为另一个流模型。而最右侧的数字3是最终结果。

这里的fliter、map、skip都是在对函数模型进行操作，集合元素并没有真正被处理。只有当终结方法count执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。

备注：“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）。

Stream（流）是一个来自数据源的元素队列
- 元素是特定类型的对象，形成一个队列。Java中的Stream并不会存储元素，而是按需计算。
- 数据源流的来源。可以是集合，数组等。

和以前的Collection操作不同，Stream操作还有两个基础的特征：
- Pipelining：中间操作都会返回流对象本身。这样多个操作可以串联成一个管道，如同流式分格。这样做可以对操作进行优化，比如延迟执行和短路。
- 内部迭代：以前对集合遍历都是通过Iterator或者增强for的方式，显式的在集合外部进行迭代，这叫做外部迭代。Stream提供了内部迭代的方式，流可以直接调用遍历方法。

当使用一个流的时候，通常包含三个基本步骤：获取一个数据源-->数据转换-->执行操作获取想要的结果，每次转换原有Stream对象不改变，返回一个新的Stream对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

流模型的方法可以被分成两种：
- 延迟方法：返回值类型仍然是Stream接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为延迟方法。）
- 终结方法：返回值类型不再是Stream接口自身类型的方法，因此不再支持类似StringBuilder那样的链式调用。终结方法包含count和forEach方法。

获取Stream流的两种方式

java.util.stream.Stream是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）

获取一个流非常简单，有以下两种常用的方式：
- 所有的Collection集合都可以通过Stream默认方法获取流；
	default Stream<E> stream()
- Stream接口的静态方法of可以获取数组对应的流。
	static <T> Stream<T> of(T... values)
	参数是一个可变参数，那么我们就可以传递一个数组

// 把集合转换为Stream流
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();

Set<String> set = new HashSet<>();
Stream<String> stream2 = set.stream();

Map<String,String> map = new HashMap<>();
// 获取键，存储到一个Set集合中
Set<String> keySet = map.keySet();
Stream<String> stream3 = keySet.stream();

// 获取值，存储到一个Collection集合中
Collection<String> values = map.values();
Stream<String> stream4 = values.stream();

// 获取键值对（键与值的映射关系entrySet）
Set<Map.Entry<String, String>> entries = map.entrySet();
Stream<Map.Entry<String, String>> stream5 = entries.stream();

// 把数组转化为Stream流
Stream<Integer> stream6 = Stream.of(1, 2, 3, 4, 5);
// 可变参数可以传递数组
Integer[] arr = {1,2,3,4,5};
Stream<Integer> stream7 = Stream.of(arr);
String[] arr2 = {"a","bb","ccc"};
Stream<String> stream8 = Stream.of(arr2);