java项目 一个标准的出参对象

1 Lambda表达式

1.1 函数式编程思想概述

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以
什么形式做。

做什么，而不是怎么做

我们真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将 run 方法体内的代码传递给 Thread 类知晓。

传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做什么”的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。

1.2 Lambda代码优化

我们前面讲过的多线程的写法是需要接口,实现类最后还需要Thread来启动等等,感觉很是繁琐,我们先看一下我们以前的代码:

public class Demo01 { 
		public static void main(String[] args) { 
			new Thread(new Runnable() { 
			@Override public void run() { 
				System.out.println("多线程任务执行！"); 
			} 
		}).start(); 
	} 
}

Lambda表达式写法,代码如下：

借助Java 8的全新语法，上述 Runnable 接口的匿名内部类写法可以通过更简单的Lambda表达式达到等效：

public class Demo02LambdaRunnable { 
		public static void main(String[] args) { 
			new Thread(() -> System.out.println("多线程任务执行！")).start(); // 启动线程 
		} 
	}

这段用Lambda表达式写成的代码,功能完全与上面的代码一致,这是在jdk1.8之后的新特性,感觉是不是很方便.

不再有“不得不创建接口对象”的束缚，不再有“抽象方法覆盖重写”的负担，就是这么简单！

1.3 Lambda的格式

Lambda省去面向对象的条条框框，格式由3个部分组成：

• 一些参数
• 一个箭头
• 一段代码

Lambda表达式的标准格式为：

(参数类型 参数名称) -> { 代码语句 }

格式说明：

• 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
• -> 是新引入的语法格式，代表指向动作。
• 大括号内的语法与传统方法体要求基本一致。

匿名内部类与lambda对比:

new Thread(new Runnable() { 
		@Override public void run() { 
			System.out.println("多线程任务执行！"); 
		} 
	}).start();

仔细分析这段代码之后,我们真正用到的代码只有run方法体里的内容,其他的像newThread,实现Runnable接口等,是为了run方法不得不创建出来的.

换成Lambda之后,只有run方法体被保留了下来,相比较更加简单

() -> System.out.println("多线程任务执行！")

• 前面的一对小括号即 run 方法的参数（无），代表不需要任何条件；
• 中间的一个箭头代表将前面的参数传递给后面的代码；
• 后面的输出语句即业务逻辑代码。

参数和返回值:

下面举例演示 java.util.Comparator 接口的使用场景代码，其中的抽象方法定义为：

• public abstract int compare(T o1, T o2);

传统写法

/**
 * 请使用Lambda表达式调用Collections的sort()方法，可以实现对一个List<String>集合进行：降序排序。
 * 	编写main()方法，在main()中按以下步骤编写代码：
 * 	1. 定义一个List<String>集合，并存储以下数据：
 * 			“cab”
 * 			“bac”
 * 			“acb”
 * 			“cba”
 * 			“bca”
 * 			“abc”
 * 	2. 使用Lambda表达式调用Collections的sort()方法对集合进行降序排序。
 * 	3. 排序后向控制台打印集合的所有元素。
 */
public class Lambda_Test02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("cab");
        list.add("bac");
        list.add("acb");
        list.add("cba");
        list.add("bca");
        list.add("abc");


        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });

        System.out.println(list);
    }
}

Lambda写法

package com.itcast.HomeWork.Demo01;

import java.util.*;

/**
 * 请使用Lambda表达式调用Collections的sort()方法，可以实现对一个List<String>集合进行：降序排序。
 * 	编写main()方法，在main()中按以下步骤编写代码：
 * 	1. 定义一个List<String>集合，并存储以下数据：
 * 			“cab”
 * 			“bac”
 * 			“acb”
 * 			“cba”
 * 			“bca”
 * 			“abc”
 * 	2. 使用Lambda表达式调用Collections的sort()方法对集合进行降序排序。
 * 	3. 排序后向控制台打印集合的所有元素。
 */
public class Lambda_Test02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("cab");
        list.add("bac");
        list.add("acb");
        list.add("cba");
        list.add("bca");
        list.add("abc");
        
        Collections.sort(list, (o1,o2) -> o1.compareTo(o2));
        System.out.println(list);
    }
}

省略格式:

省略规则
在Lambda标准格式的基础上，使用省略写法的规则为：

1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

可推导即可省略
Lambda强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。例如上例还可以使用Lambda的省略写法：

Runnable接口简化: 
	1. () -> System.out.println("多线程任务执行！") 
	Comparator接口简化: 
	2. Arrays.sort(array, (a, b) -> a.getAge() - b.getAge());

1.4 Lambda的前提条件

Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：

1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。 无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
2. 使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

Stream

在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。

2.1 流式思想概述

注意：请暂时忘记对传统IO流的固有印象！

整体来看，流式思想类似于工厂车间的“生产流水线”。

2.2 获取流方式

java.util.stream.Stream 是Java 8新加入的最常用的流接口。（这并不是一个函数式接口。）
获取一个流非常简单，有以下几种常用的方式：

• 所有的 Collection 集合都可以通过 stream 默认方法获取流；
• Stream 接口的静态方法 of 可以获取数组对应的流。

方式1 : 根据Collection获取流

首先， java.util.Collection 接口中加入了default方法 stream 用来获取流，所以其所有实现类均可获取流。

public class Demo04 { 
		public static void main(String[] args) { 
			List<String> list = new ArrayList<>(); 
			// ... 
			Stream<String> stream1 = list.stream(); 
			Set<String> set = new HashSet<>();
			// ... 
			Stream<String> stream2 = set.stream(); 
			Vector<String> vector = new Vector<>(); 
			// ... 
			Stream<String> stream3 = vector.stream(); 
		} 
	}

方式2 : 根据Map获取流

public class Demo05 { 
		public static void main(String[] args) { 
			Map<String, String> map = new HashMap<>(); 
			// ... 
			Stream<String> keyStream = map.keySet().stream(); 
			
			Stream<String> valueStream = map.values().stream(); 
			Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream(); 
		} 
	}

方式3 : 根据数组获取流

如果使用的不是集合或映射而是数组，由于数组对象不可能添加默认方法，所以 Stream 接口中提供了静态方法of ，使用很简单：

public class Demo06 { 
		public static void main(String[] args) { 
			String[] array = { "张无忌", "张翠山", "张三丰", "张一元" }; 
			Stream<String> stream = Stream.of(array); 
		} 
	}

备注： of 方法的参数其实是一个可变参数，所以支持数组。

2.3 常用方法

函数拼接与终结方法

方法名	方法作用	方法种类	是否支持链式调用
count	统计个数	终结	否
forEach	逐一处理	终结	否
filter	过滤	函数拼接	是
limit	取用前几个	函数拼接	是
skip	跳过前几个	函数拼接	是
map	映射	函数拼接	是
concat	组合	函数拼接	是

forEach : 逐一处理

虽然方法名字叫 forEach ，但是与for循环中的“for-each”昵称不同，该方法并不保证元素的逐一消费动作在流中是被有序执行的。

void forEach(Consumer<? super T> action);

public class Stream_forEach {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三丰,王思聪,张飞.刘晓敏,张靓颖");

        Stream<String> stream = list.stream();
//        stream.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(list);
//            }
//        });

        System.out.println("=============Lambda表达式改造=============");
        stream.forEach( s -> System.out.println(s));
    }
}

count：统计个数

正如旧集合 Collection 当中的 size 方法一样，流提供 count 方法来数一数其中的元素个数：

long count();

public class Stream_count {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("王思聪");
        list.add("张飞");
        list.add("刘晓敏");
        list.add("张靓颖");

        Stream<String> stream = list.stream();
        Stream<String> stream1 = stream.filter(s -> s.startsWith("张"));
        System.out.println(stream1.count());
    }
}

filter：过滤

可以通过filter将一个流转换成另一个子集流,方法声明:

Stream filter(Predicate<? super T> predicate);

public class Stream_filter {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("王思聪");
        list.add("张飞");
        list.add("刘晓敏");
        list.add("张靓颖");
       // Collections.addAll(list,"张三丰,王思聪,张飞.刘晓敏,张靓颖");
        Stream<String> stream = list.stream();
        Stream<String> stream1 = stream.filter(s -> s.startsWith("张"));
        stream1.forEach(s -> System.out.println(s));
    }
}

limit：取用前几个

limit 方法可以对流进行截取，只取用前n个。方法声明：

Stream limit(long maxSize);

ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("王思聪");
        list.add("张飞");
        list.add("刘晓敏");
        list.add("张靓颖");
        list.add("王多鱼");
        Stream<String> stream = list.stream();
        Stream<String> stream1 = stream.filter(s -> s.startsWith("张")).limit(2);
        stream1.forEach(s -> System.out.println(s));

skip：跳过前几个

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

Stream skip(long n);

public class Stream_skip {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("王思聪");
        list.add("张飞");
        list.add("刘晓敏");
        list.add("张靓颖");
        list.add("王多鱼");
        

        Stream<String> stream2 = list.stream();
        Stream<String> stream3 = stream2.filter(s -> s.startsWith("王")).skip(1);
        stream3.forEach(s -> System.out.println(s));
    }
}

map：映射

如果需要将流中的元素映射到另一个流中，可以使用 map 方法。方法声明：

Stream map(Function<? super T, ? extends R> mapper);

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public Person() {

    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * 1.定义一个Person类，包含一个属性：姓名(String)
 * 	  	定义无参、全参构造方法
 * 		定义get/set方法
 * 	2.定义main()方法，按依稀顺序编写程序：
 * 定义集合List<String>，添加以下数据：
 * 		“王佳乐”
 * 		“张三丰”
 * 		“王思聪”
 * 		“张飞”
 * 使用Stream流的map()方法，将每个元素封装为一个Person对象。
 * 将新流中的元素提取为List集合。
 * 遍历、打印集合中所有的Person对象信息。
 */
public class Stream_map {
    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("王佳乐"));
        list.add(new Person("张三丰"));
        list.add(new Person("王思聪"));
        list.add(new Person("张飞"));

        Stream<Person> stream = list.stream();
        Stream<ArrayList<Person>> stream1 = stream.map(s -> list);
        stream1.forEach(s -> System.out.println(s));
    }
}

concat：组合

如果有两个流，希望合并成为一个流，那么可以使用 Stream 接口的静态方法 concat ：

static Stream concat(Stream<? extends T> a, Stream<? extends T> b)

/**
 * 定义main()方法，按以下顺序编写程序：
 * 定义集合List<String>，添加以下数据：
 * 	        “王佳乐”
 * 			“张三丰”
 * 			“王思聪”
 * 			“张飞”
 * 			“刘晓敏”
 * 			“张靓颖”
 * 			“王敏”
 * 先筛选出所有的“张”姓学员；
 * 再筛选出所有的“王”姓学员；
 * 将两个流合并为一个流
 * 打印合并后的每个元素。
 */
public class Stream_concat {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("王思聪");
        list.add("张飞");
        list.add("刘晓敏");
        list.add("张靓颖");
        list.add("王多鱼");

        Stream<String> stream1 = list.stream().filter(s -> s.startsWith("张"));

        Stream<String> stream2 = list.stream().filter(s -> s.startsWith("王"));

        Stream<String> concat = Stream.concat(stream1, stream2);
        concat.forEach(s -> System.out.println(s));
    }
}

2.4 收集Stream结果

收集到集合中

Stream流提供 collect 方法，其参数需要一个 java.util.stream.Collector<T,A, R> 接口对象来指定收集到哪种集合中。幸运的是， java.util.stream.Collectors 类提供一些方法，可以作为 Collector 接口的实例：

• public static Collector<T, ?, List> toList() ：转换为 List 集合。
• public static Collector<T, ?, Set> toSet() ：转换为 Set 集合。

public class Demo1 { 
		public static void main(String[] args) { 
			Stream<String> stream = Stream.of("10", "20", "30", "40", "50"); 
			List<String> list = stream.collect(Collectors.toList()); 
			Set<String> set = stream.collect(Collectors.toSet()); 
		} 
	}

收集到数组中

Stream提供 toArray 方法来将结果放到一个数组中，返回值类型是Object[]的：

Object[] toArray();

public class Demo1 { 
		public static void main(String[] args) { 
			Stream<String> stream = Stream.of("10", "20", "30", "40", "50"); 
			Object[] objArray = stream.toArray(); 
		} 
	}