Day013-2021-08-16 Lambda表达式 集合的stream操作 多线程

第十三天，学习几个对编程十分有帮助的知识点，可以大大减少编程过程中的多余操作

一、lambda表达式

lambad表达式是函数式编程理念的一种表达方式，它可以简化编程中的许多代码。

1.1 lambda表达式的几种基本形式

lambda 表达式左侧是参数，右侧是操作,中间用 -> 连接。
左侧：

1. 无参：()
2. 一参：o
3. 多参：( o1, o2, …)

右侧：

1. o.col()
2. o1.col()==?
3. {表达式;}
   其中 o->o.col() 可以简化为 类::col

1.2 lambda表达式的条件

1. 一个接口有且仅有一个抽象方法。
2. 接口有 @FunctionalInterface 标签

二、集合的stream操作

建立一个员工类：

public class Employee {
	private int id;
	private String name;
	private int age;
	private String dept;

	public Employee(int id, String name, int age, String dept) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.dept = dept;
	}

	public int getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getDept() {
		return dept;
	}

	public void setDept(String dept) {
		this.dept = dept;
	}

	@Override
	public String toString() {
		return id + "|" + name + "|" + age + "|" + dept;
	}
}

建立一个集合：

	public static List<Employee> list = new ArrayList<Employee>();

	static {
		list.add(new Employee(1, "Jack", 19, "DepartmentA"));
		list.add(new Employee(2, "Rose", 21, "DepartmentC"));
		list.add(new Employee(3, "Kitty", 23, "DepartmentA"));
		list.add(new Employee(4, "Tom", 34, "DepartmentB"));
		list.add(new Employee(5, "Lucy", 28, "DepartmentC"));
	}

2.1 单字段投影

map() 方法
输出集合里所有人名：

public static void main(String[] args) {
	list.stream().map(Employee::getName).forEach(System.out::println);
}

运行结果：

Employee::getName

这里是简化写法，等效于：

o -> o.getName()

2.2 筛选

filter() 方法
输出集合里所有大于22岁的人员信息：

public static void main(String[] args) {
	list.stream().filter(o -> o.getAge() > 22).forEach(System.out::println);
}

运行结果：

2.3 判断

noMatch() 没有
anyMatch() 存在
allMatch() 全部
判断集合里的人是否全是18岁以上：

public static void main(String[] args) {
	boolean flag = list.stream().allMatch(o -> o.getAge() > 18);
	System.out.println(flag);
}

运行结果：

2.4 分页

skip() 跳过
limit() 截取
截取2到4号信息：

public static void main(String[] args) {
	list.stream().skip(1).limit(3).forEach(System.out::println);
}

运行结果：

2.5 排序

sorted()方法
将集合按年龄排序输出：

public static void main(String[] args) {
	list.stream().sorted((o1, o2) -> {
		return o1.getAge() - o2.getAge();
	}).forEach(System.out::println);
}

运行结果：

2.6 收集

collect()方法
收集小于24岁的人：

public static void main(String[] args) {
	List<Employee> employeeList = list.stream().filter(o -> o.getAge() < 24).collect(Collectors.toList());
	employeeList.forEach(System.out::println);
}

运行结果：

按部门分组收集人员信息：

public static void main(String[] args) {
	Map<String, List<Employee>> employeeMap = list.stream().collect(Collectors.groupingBy(Employee::getDept));
	employeeMap.entrySet().forEach(System.out::println);
}

运行结果：

三、线程

3.1 线程的概念

一个程序包含一到多个进程，
一个进程包含一到多个线程，
一个线程包含一到多个协程。
一般代码运行只有一个 main 主线程，这种通常被称为 串行/阻塞式/同步，
开启多线程可以让不同的代码同时执行，多线程又被称为 并行/非阻塞式/异步。

3.2 实现多线程

实现多线程的方法：
继承Thread父类 或 实现Runnable接口 并 重写其中的 run() 方法。
具体操作可以用外部类重写，也可以用匿名内部类重写，Runnable接口 还可以通过 lambda表达式 重写。

1. Thread 类：

// 0号
Thread thread0 = new Thread() {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			try {
				System.out.println(Thread.currentThread().getName() + ":这是0号线程的动作!" + i);
				Thread.sleep(1000);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
};
// 1号
Thread thread1 = new Thread() {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			try {
				System.out.println(Thread.currentThread().getName() + ":这是1号线程的动作!" + i);
				Thread.sleep(1000);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
};
// 开始执行
thread0.start();
thread1.start();

运行结果：

Thread.sleep(1000);

这句是系统休眠，括号里填入时间，单位是毫秒。

Thread.currentThread().getName()

这句用于显示当前线程的名字，线程的名字可以修改，在创建对象时在括号中增加一个字符串即可。

thread0.start();

这句用于启动线程。
2. Runnable接口

// 0号
Runnable runnable0 = () -> {
	for (int i = 0; i < 10; i++) {
		try {
			System.out.println(Thread.currentThread().getName() + ":这是0号线程的动作!" + i);
			Thread.sleep(1000);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
};
// 1号
Runnable runnable1 = () -> {
	for (int i = 0; i < 10; i++) {
		try {
			System.out.println(Thread.currentThread().getName() + ":这是1号线程的动作!" + i);
			Thread.sleep(1000);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
};
// 开始执行
new Thread(runnable0).start();
new Thread(runnable1).start();
}

运行结果：

new Thread(runnable0).start();

这句用于启动线程，重写Runnable接口需要通过创建一个Thread对象来启动。