Java总结 - 基础知识
文章目录
- - - -计算机技术演化- - -
- 1 编程语言演化
-
- 1.1 写在最前
- 1.2 汇编
- 1.3 VB－＞C－＞C++
- 1.4 Java(Sun公司)
- 1.5 Java演变
- 2 技术思想
- - - -Java技术基础- - -
- 1 知识拓扑
- 2 面向对象
-
- 2.1 面向对象
- 2.2 类&对象
- 2.3 封装
- 2.4 继承
- 2.5 多态
- 3 反射
-
- 3.1 反射机制
-
- 3.1.1 Java代码运行过程
- 3.1.2 反射机制概念
- 3.2 Class对象及其方法
-
- 3.2.1 获取字节码对象
- 3.2.2 常用方法
- 3.3 反射机制应用a
-
- 3.3.1 案例分析
- 3.3.2 代码实现
- 3.4 反射机制应用b
- 4 异常&泛型&序列化&复制
-
- 4.1 异常
-
- 4.1.1 异常概念
- 4.1.2 异常分类
- 4.1.3 异常处理
- 4.1.4 使用@controllerAdvice处理异常
- 4.2 泛型
-
- 4.2.1 泛型概述
- 4.2.2 泛型使用
- 4.3 序列化
- 4.4 复制
- 5 数据结构与集合
-
- 5.1 数据结构
- 5.2 Java集合
-
- 5.2.1 集合类型及其特性
- 5.2.2 常见集合的特点
- 6 Java8新特性
-
- 6.1 Lambda表达式
-
- 6.1.1 概述
- 6.1.2 语法
- 6.1.3 函数式接口
- 6.1.4 Lambda表达式基本使用
- 6.1.5 变量捕获
- 6.1.6 Lambda表达式与集合
- 6.2 Stream
-
- 6.2.1 Stream概述
- 6.2.2 Stream的创建
- 6.2.3 类型说明
- 6.2.4 遍历/匹配（foreach/find/match）
- 6.2.5 筛选（filter）
- 6.2.6 聚合（max/min/count)
- 6.2.7 映射(map/flatMap)
- 6.2.8 归约(reduce)
- 6.2.9 收集(collect)
-
- 6.2.9.1 归集(toList/toSet/toMap)
- 6.2.9.2 统计(count/averaging)
- 6.2.9.3 分组(partitioningBy/groupingBy)
- 6.2.9.4 接合(joining)
- 6.2.9.5 归约(reducing)
- 6.2.10 排序(sorted)
- 6.2.11 提取/组合
- - -计算机技术演化- - -
1 编程语言演化
1.1 写在最前
此文用于个人总结，串接知识点，其整体结构为：
① 计算机技术演化；
② Java技术基础；
③ Java技术深入；
④ Spring技术；
⑤ DataBase；
⑥ 常用中间件。
1.2 汇编
举例：mov 、add
特点：程序量很大，几百行、几千行乃至几万行
1.3 VB－＞C－＞C++
面向过程－＞面向对象
特点：goto关键字、指针、内存管理、数据类型
1.4 Java(Sun公司)
特性：封装(封装成class)、继承(object)、多态(工厂模式、代理模式等)
JVM：编译流程、堆栈、类生成过程
GC：新生代、老年代、GC算法
1.5 Java演变
Applet，C/S架构的桌面程序
JSP + servlet，B/S架构
JavaEE、JavaSE，比较笨重，体量大
Spring，轻量化(高内聚 + 低耦合)
SSH，Struts、Spring和Hibernate(ORM框架)
SSI，Struts、Spring和iBatis(半ORM框架、轻量、灵活)
SSM，Spring、SpringMVC、Mybatis
SpringBoot
SpingCloud
2 技术思想
NoSQL思想：Redis、MongoDB
微服务思想：RPC、SpringCloud、Dubbo、Zookeeper
MQ思想：RocketMQ、RabbitMQ
心跳思想：Socket
- - -Java技术基础- - -
1 知识拓扑
Java知识拓扑
2 面向对象
2.1 面向对象
① 事物 -> 对象，万物皆对象；
② 把数据及其操作方法封装成一个整体，即对象；
③ 面向对象的思想为：A做XX事、B做XX事、C做XX事；
④ 面向过程的思想为：第1步做XX事、第2步做XX事、第3步做XX事。
2.2 类&对象
① 同类对象抽象出其共性，形成类；
② 类是对象的模板；
③ 对象是类的实例。
2.3 封装
① 定义：将对象的属性和行为封装成一个整体；
② 作用：封装私有成员数据，提供成员方法修改数据。
2.4 继承
① 定义：子类继承父类的特征和行为，class 子类 extends 父类 { }；
② 特点：Java不支持多继承，支持多重继承；
③ 作用：提高了代码的复用性和维护性；
④ 作用：类和类产生了关系，是多态的前提。
2.5 多态
① 定 义：同一行为具有不同的表现形式，包括“方法多态”与“对象多态”；；
② 方法多态：包括“重载”和“重写”；
重载：单个类中，相同方法，参数不同，其功能不同；
重写：继承父类的多个子类中，相同方法，子类不同，其功能不同；
③ 对象多态：父类子类对象的转换，具体有“向上转型”和“向下转型”；
向上转型：子类对象变为父类对象，格式：父类 父类对象 = 子类实例；
向下转型：父类对象变为子类对象，格式：子类 子类对象 = (子类)父类实例；
④ 多态条件：继承、重写、父类引用指向子类对象；
⑤ 实现方式：重载与重写，抽象类与抽象方法，接口。
3 反射
3.1 反射机制
3.1.1 Java代码运行过程
如上图，Java代码在计算机中运行的三个阶段
① Source源代码阶段，java被编译成class文件；
② Class类对象阶段，类加载器将class文件加载进内存，并封装成Class类对象，将成员变量封装成Field[]，将构造函数封装成Construction[]，将成员方法封装成Method[]；
③ RunTime运行时阶段，使用new创建对象的过程。
3.1.2 反射机制概念
1. 定义
在程序运行状态中，对于任意类或对象，都能获取其属性和方法(包括私有属性和方法)，这种动态获取信息以及动态调用对象方法的功能就称为反射机制。
2. 优点
① 可以在程序运行过程中，操作这些对象；
② 可以解耦，提高程序的可扩展性。
3.2 Class对象及其方法
3.2.1 获取字节码对象
【Source源代码阶段】Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象，多用于配置文件，将类名定义在配置文件中，读取配置文件加载类；
【Class类对象阶段】类名.class：通过类名的属性class获取，多用于参数的传递；
【Runtime运行时阶段】对象.getClass()：该方法定义在Objec类中，所有的类都会继承此方法，多用于对象获取字节码。
3.2.2 常用方法
1. 获取包名 类名
clazz.getPackage().getName()//包名
clazz.getSimpleName()//类名
clazz.getName()//完整类名
2. 获取成员变量
getFields()//获取所有公开的成员变量,包括继承变量
getDeclaredFields()//获取本类定义的成员变量,包括私有,但不包括继承的变量
getField(变量名)
getDeclaredField(变量名)
3. 获取构造方法
getConstructor(参数类型列表)//获取公开的构造方法
getConstructors()//获取所有的公开的构造方法
getDeclaredConstructors()//获取所有的构造方法,包括私有
getDeclaredConstructor(int.class,String.class)
4. 获取成员方法
getMethods()//获取所有可见的方法,包括继承的方法
getMethod(方法名,参数类型列表)
getDeclaredMethods()//获取本类定义的的方法,包括私有,不包括继承的方法
getDeclaredMethod(方法名,int.class,String.class)
5. 反射新建实例
clazz.newInstance();//执行无参构造创建对象
clazz.newInstance(666,”海绵宝宝”);//执行含参构造创建对象
clazz.getConstructor(int.class,String.class)//获取构造方法
6. 反射调用成员变量
clazz.getDeclaredField(变量名);//获取变量
clazz.setAccessible(true);//使私有成员允许访问
f.set(实例,值);//为指定实例的变量赋值,静态变量,第一参数给null
f.get(实例);//访问指定实例变量的值,静态变量,第一参数给null
7. 反射调用成员方法
Method m = Clazz.getDeclaredMethod(方法名,参数类型列表);
m.setAccessible(true);//使私有方法允许被调用
m.invoke(实例,参数数据);//让指定实例来执行该方法
3.3 反射机制应用a
3.3.1 案例分析
1. 需求
实现"框架"，要求不改变该类的任何代码，可以创建任意类的对象，并且执行类的任意方法。
2. 实现
① 配置文件;
② 反射机制.
3. 步骤
① 将需要创建的对象的全类名和需要执行的方法定义在配置文件中;
② 在程序中加载读取配置文件;
③ 使用反射技术把类文件加载进内存;
④ 创建对象;
⑤ 执行方法.
3.3.2 代码实现
1. 实体类
public class Person {
public void eat(){
System.out.println("eat...");
}
}
public class Student {
public void study(){
System.out.println("I am a Student");
}
}
2. 两种配置文件
//配置文件1
className = zzuli.edu.cn.Person
methodName = eat
//配置文件2
//className = zzuli.edu.cn.Student
//methodName = study
3. 框架
public class ReflectTest {
public static void main(String[] args) throws Exception {
//1.加载配置文件
//1.1创建Properties对象
Properties pro = new Properties();
//1.2加载配置文件
//1.2.1获取class目录下的配置文件(使用类加载器)
ClassLoader classLoader = ReflectTest.class.getClassLoader();
InputStream inputStream = classLoader.getResourceAsStream("pro.properties");
pro.load(inputStream);
//2.获取配置文件中定义的数据
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//3.加载该类进内存
Class cls = Class.forName(className);
//4.创建对象
Object obj = cls.newInstance();
//5.获取方法对象
Method method = cls.getMethod(methodName);
//6.执行方法
method.invoke(obj);
}
}
4. 两种运行结果
3.4 反射机制应用b
通过反射创建任意类的对象，并且执行类的任意方法。
package com.yuEntity;
import lombok.Data;
@Data
public class Student {
public Student() {
}
public void show(){
System.out.println("I am a student!");
}
}
package com.yuEntity;
import lombok.Data;
@Data
public class Teacher {
private String name;
private int age;
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
public void show(){
System.out.println("I am a teacher!");
}
}
public class TestReflection {
@Test
public void testReflection() throws Exception {
System.out.println("通过Class.forName() 获取字节码对象");
Class clsStudent = Class.forName("com.yuEntity.Student");
System.out.println("通过newInstance() 创建对象实例");
Object student = clsStudent.newInstance();
System.out.println("student对象：" + student);
System.out.print("通过getMethod() 获取对象show()方法并执行： ");
Method method = clsStudent.getMethod("show");
method.invoke(student);
System.out.println("");
System.out.println("通过Class.forName() 获取字节码对象");
Class clsTeacher = Class.forName("com.yuEntity.Teacher");
Class[] teacherCls = new Class[]{String.class, int.class};
System.out.println("通过getConstructor() 创建对象实例");
Object teacher = clsTeacher.getConstructor(teacherCls).newInstance("张珊",20);
System.out.println("teacher对象： " + teacher);
System.out.print("通过getMethod() 获取对象show()方法并执行： ");
method = clsTeacher.getMethod("show");
method.invoke(teacher);
}
}
4 异常&泛型&序列化&复制
4.1 异常
4.1.1 异常概念
定义：程序运行过程中出现的错误，称为异常。
原因：
输入非法数据；
要打开的文件不存在；
网络通信时连接中断，或者JVM内存溢出。
4.1.2 异常分类
1. 分类
2. Error
JVM相关错误，无法处理，如系统崩溃，内存不足，方法调用栈溢等。
3. Exception
可处理的异常，可捕获且可能恢复。
4.1.3 异常处理
注意：
try/catch后面的finally块非强制性要求；
try后不能既没catch也没finally；
try, catch, finally块之间不能添加任何代码；
finally代码一定会执行（除了JVM退出）。
4.1.4 使用@controllerAdvice处理异常
4.2 泛型
4.2.1 泛型概述
1. 定义
泛型，即参数化类型。定义类、接口和方法时，其数据类型可被指定为参数。
2. 类型擦除
泛型在编译阶段有效，不进入运行阶段，编译生成的字节码文件不包含泛型中的类型信息，该过程称为类型擦除。如定义List< Object >和 List< String >，编译后变成List。
4.2.2 泛型使用
1. 泛型类
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{
private T key;
public Generic(T key) {
this.key = key;
}
public T getKey(){
return key;
}
}
//泛型的类型参数是类类型（包括自定义类）
Generic<Integer> genericInteger = new Generic<Integer>(123456);
Generic<String> genericString = new Generic<String>("key_vlaue");
2. 泛型接口
//泛型接口
public interface Generator<T> {
public T next();
}
//未传入泛型实参，需将泛型的声明加到类中
class FruitGenerator<T> implements Generator<T>{
@Override
public T next() {
return null;
}
}
//传入泛型实参，T换成实参类型
public class FruitGenerator implements Generator<String> {
private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
@Override
public String next() {
Random rand = new Random();
return fruits[rand.nextInt(3)];
}
}
3. 泛型通配符
操作类型时，若不使用类型具体功能，只使用Object类的功能，可用通配符“?”定义未知类型。
public void showKeyValue(Generic<Number> obj){
Log.d("泛型测试","key value is " + obj.getKey());
}
public void showKeyValue1(Generic<?> obj){
Log.d("泛型测试","key value is " + obj.getKey());
}
//Integer是Number的子类
Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);
showKeyValue(gNumber);
showKeyValue(gInteger);// 报错
showKeyValue1(gNumber);
showKeyValue1(gInteger);
4. 泛型方法
①基本泛型方法
public class GenericTest {
//泛型类
public class Generic<T>{
private T key;
public Generic(T key) {
this.key = key;
}
//getKey使用泛型，但不是泛型方法，普通的成员方法
public T getKey(){
return key;
}
/* setKey错误，类中并未声明泛型E
public E setKey(E key){
this.key = keu
}*/
}
/* showKeyName为泛型方法
public与返回值之间的必不可少，泛型数量可为多个，如：
public K showKeyName(Generic container){
}*/
public <T> T showKeyName(Generic<T> container){
System.out.println("container key :" + container.getKey());
T test = container.getKey();
return test;
}
//showKeyValue1为普通方法
public void showKeyValue1(Generic<Number> obj){
Log.d("泛型测试","key value is " + obj.getKey());
}
//showKeyValue2为普通方法
public void showKeyValue2(Generic<?> obj){
Log.d("泛型测试","key value is " + obj.getKey());
}
/*showKeyName错误，未声明泛型E
public T showKeyName(Generic container){
...
}*/
/*showkey错误，未声明泛型T
public void showkey(T genericObj){
...
}*/
public static void main(String[] args) {
}
}
②泛型类中的泛型方法
//泛型类
public class Generic<T>{
public void show_1(T t){
System.out.println(t.toString());
}
//泛型类中泛型方法，泛型E可与类中T不同
public <E> void show_2(E e){
System.out.println(e.toString());
}
//泛型类中泛型方法，泛型T是新类型，可以和泛型类中T不同
public <T> void show_3(T t){
System.out.println(t.toString());
}
}
③泛型方法的可变参数
public <T> void printMsg( T... args){
for(T t : args){
Log.d("泛型测试","t is " + t);
}
}
printMsg("111",222,"aaaa","2323.4",55.55);
④静态方法要使用泛型，必须定义成泛型方法
public class StaticGenerator<T> {
public static <T> void show1(T t){
}
//show2方法错误
public static void show2(T t){
}
}
5. 泛型上下边界
① 泛型方法的上下边界，必须与泛型声明在一起
//泛型方法添加上下边界时，必须在上添加上下边界
public <T extends Number> T showKeyName(Generic<T> container){
System.out.println("container key :" + container.getKey());
T test = container.getKey();
return test;
}
②泛型上边界，例1
public class Generic<T>{
private T key;
public Generic(T key) {
this.key = key;
}
public T getKey(){
return key;
}
}
public void showKeyValue1(Generic<? extends Number> obj){
Log.d("泛型测试","key value is " + obj.getKey());
}
Generic<String> generic1 = new Generic<String>("11111");
Generic<Integer> generic2 = new Generic<Integer>(2222);
Generic<Float> generic3 = new Generic<Float>(2.4f);
Generic<Double> generic4 = new Generic<Double>(2.56);
showKeyValue1(generic1);//报错，String不是Number的子类
showKeyValue1(generic2);
showKeyValue1(generic3);
showKeyValue1(generic4);
②泛型上边界，例2
public class Generic<T extends Number>{
private T key;
public Generic(T key) {
this.key = key;
}
public T getKey(){
return key;
}
}
Generic<String> generic1 = new Generic<String>("11111");//报错，String不是Number子类
4.3 序列化
1. 定义
Java序列化是指把Java对象转换为字节流，便于传输和保存；Java反序列化是指把字节流恢复为Java对象。
2. 实现
实现 java.io.Serializable接口。
4.4 复制
1. 直接赋值复制
直接赋值时， A a1 = a2; 实际上复制的是引用，也就是说a1和a2指向的是同一个对象，当a1变化时，a2的成员变量也会跟着变化。
@Data
public class NanjPerson{
private String name;
private int age;
private int sex;
public NanjPerson(String name, int age, int sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
}
/*@description 一般复制*/
@Test
public void testNanjPersonClone(){
NanjPerson person1 = new NanjPerson("Spring1",20,0);
NanjPerson person2 = person1;
System.out.println("南京人1: " + person1.toString());
System.out.println("南京人2: " + person2.toString());
person2.setName("Spring2");
System.out.println("修改南京人2属性，南京人1的属性也被修改");
System.out.println("南京人1: " + person1.toString());
System.out.println("南京人2: " + person2.toString());
System.out.print( person1 == person2);
if(person1 == person2){
System.out.println(" 直接赋值复制 南京人1和南京人2指向同一个对象");
}else {
System.out.println(" 直接赋值复制 南京人1和南京人2指向不同的对象");
}
}
2. 浅拷贝
浅拷贝中，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。
@Data
public class AddressA{
private String addr;
public AddressA(String addrIn) {
this.addr = addrIn;
}
}
@Data
public class WuxPersonA implements Cloneable{
private String name;
private int age;
private int sex;
private AddressA address;
public WuxPersonA(String name, int age, int sex, AddressA address) {
this.name = name;
this.age = age;
this.sex = sex;
this.address = address;
}
@Override
public Object clone() {
WuxPersonA person = null;
try {
person = (WuxPersonA)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return person;
}
}
/*浅拷贝*/
@Test
public void testWuxPersonAClone(){
WuxPersonA personA1 = new WuxPersonA("SpringA1",20,0,new AddressA("无锡A1"));
WuxPersonA personA2 = (WuxPersonA) personA1.clone();
System.out.println("无锡人A1: " + personA1.toString());
System.out.println("无锡人A2: " + personA2.toString());
personA2.setName("SpringA2");
personA2.address.setAddr("无锡A2");
System.out.println("修改无锡人A2属性 ，无锡人A1的属性里 WuxPersonA中AddressA类有问题 其他属性无问题");
System.out.println("无锡人A1: " + personA1.toString());
System.out.println("无锡人A2: " + personA2.toString());
System.out.print( personA1 == personA2);
if(personA1 == personA2){
System.out.println(" 浅拷贝 对象里面含有另一对象 无锡人A1和无锡人A2指向同一个对象");
}else {
System.out.println(" 浅拷贝 对象里面含有另一对象 无锡人A1和无锡人A2的WuxPersonA不是同一个对象 AddressA是同一个对象 ");
}
}
3. 深拷贝
深拷贝中，除了对象本身被复制外，对象所包含的所有成员变量也将复制。
@Data
public class AddressB implements Cloneable{
private String addr;
public AddressB(String addrIn) {
this.addr = addrIn;
}
@Override
public Object clone() {
AddressB addr = null;
try {
addr = (AddressB) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return addr;
}
}
@Data
public class WuxPersonB implements Cloneable{
private String name;
private int age;
private int sex;
private AddressB addressB;
public WuxPersonB(String name, int age, int sex, AddressB addressB) {
this.name = name;
this.age = age;
this.sex = sex;
this.addressB = addressB;
}
@Override
public Object clone() {
WuxPersonB person = null;
try {
person = (WuxPersonB)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
person.addressB = (AddressB) addressB.clone();
return person;
}
}
/*深拷贝*/
@Test
public void testWuxPersonBClone(){
WuxPersonB personB1 = new WuxPersonB("SpringB1",20,0,new AddressB("无锡B1"));
WuxPersonB personB2 = (WuxPersonB) personB1.clone();
System.out.println("无锡人B1: " + personB1.toString());
System.out.println("无锡人B2: " + personB2.toString());
personB2.setName("SpringB2");
personB2.addressB.setAddr("无锡B2");
System.out.println("修改无锡人B2属性，无锡人B1的属性保持不变 包括WuxPersonA中AddressA类无问题");
System.out.println("无锡人B1: " + personB1.toString());
System.out.println("无锡人B2: " + personB2.toString());
System.out.print( personB1 == personB2);
if(personB1 == personB2){
System.out.println(" 深拷贝 无锡人B1和无锡人B2指向同一个对象");
}else {
System.out.println(" 深拷贝 无锡人B1和无锡人B2指向不同的对象 包括WuxPersonA对象中AddressA对象");
}
}
4. 序列化深拷贝
@Data
public class Car implements Serializable{
private static final long serialVersionUID = -4694790051431625830L;
private String brand;
private int price;
public Car(String brand, int price) {
this.brand = brand;
this.price = price;
}
}
@Data
public class Person implements Serializable{
private static final long serialVersionUID = 7913723651426251020L;
private String name;
private int age;
private int sex;
private Car car;
public Person(String name, int age, int sex, Car car) {
this.name = name;
this.age = age;
this.sex = sex;
this.car = car;
}
}
/*序列化拷贝工具类*/
public static class CloneUtil{
public static <T extends Serializable> T clone(T obj) throws Exception{
//序列化 将obj对象的内容进行流化，转化为字节序列写到内存的字节数组中
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(obj);
//反序列化 读取内存中字节数组的内容，重新转换为java对象返回
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return (T) ois.readObject();
}
}
/*序列化实现深拷贝*/
@Test
public void testPersonClone() throws Exception {
Person person1 = new Person("Spring1",20,0,new Car("奥迪",300000));
Person person2 = CloneUtil.clone(person1);
System.out.println("person2: " + person2.toString());
System.out.println("person2: " + person2.toString());
person2.setName("Spring2");
person2.getCar().setBrand("奔驰");
System.out.println("修改person2的属性 person1的属性保持不变 包括Person中car类无问题");
System.out.println("person1: " + person1.toString());
System.out.println("person2: " + person2.toString());
System.out.print( person1 == person2);
if(person1 == person2){
System.out.println(" 序列化实现深拷贝 person1和person2指向同一个对象");
}else {
System.out.println(" 序列化实现深拷贝 person1和person2指向不同的对象 包括Person中car对象");
}
}
5. 反射复制对象
@Data
public class Programmer {
private String corporation;
private String university; //学校名称
private Car car;
public Programmer(String corporation, String university, Car car) {
this.corporation = corporation;
this.university = university;
this.car = car;
}
}
@Data
public class Doctor {
private String corporation;
private int university; //学校编码
private Car car;
public Doctor() {}
public Doctor(String corporation, int university, Car car) {
this.corporation = corporation;
this.university = university;
this.car = car;
}
}
/*两个对象相同属性值复制*/
public static void CopyByReflection(Object source, Object dest) throws Exception {
//获取属性
BeanInfo sourceBean = Introspector.getBeanInfo(source.getClass(), java.lang.Object.class);
PropertyDescriptor[] sourceProperty = sourceBean.getPropertyDescriptors();
BeanInfo destBean = Introspector.getBeanInfo(dest.getClass(), java.lang.Object.class);
PropertyDescriptor[] destProperty = destBean.getPropertyDescriptors();
try {
for (int i = 0; i < sourceProperty.length; i++) {
for (int j = 0; j < destProperty.length; j++) {
if (sourceProperty[i].getName().equals(destProperty[j].getName())
&& sourceProperty[i].getPropertyType().equals(destProperty[j].getPropertyType())) {
//调用source的getter方法和dest的setter方法
destProperty[j].getWriteMethod().invoke(dest, sourceProperty[i].getReadMethod().invoke(source));
break;
}
}
}
} catch (Exception e) {
throw new Exception("属性复制失败:" + e.getMessage());
}
}
/*通过反射复制对象*/
@Test
public void testCloneByReflection() throws Exception {
Programmer programmer = new Programmer("Corporation-a","北京大学",new Car("奔驰",300000));
Doctor doctor = new Doctor();
CopyByReflection(programmer,doctor);
System.out.println("programmer对象: " + programmer.toString());
System.out.println("doctor对象: " + doctor.toString());
System.out.println("programmer对象和doctor对象，university的类型不同，故复制失败");
doctor.setCorporation("Corporation-b");
doctor.car.setBrand("宝马");
System.out.println("programmer对象: " + programmer.toString());
System.out.println("doctor对象: " + doctor.toString());
System.out.println("programmer对象中，car对象的复制，属于浅复制");
}
5 数据结构与集合
5.1 数据结构
常见数据结构包括：数组、 链表、 栈、队列、树、散列表、图、堆，其结构如下图：
5.2 Java集合
5.2.1 集合类型及其特性
数组/Array：查询快、增删慢、长度固定、连续内存、栈内存
链表/LinkList：查询慢、增删快、长度不定、随机内存、堆内存
散列表/哈希表/HashTable：数组+链表
Map/键值对：HashMap、LinkedHashMap、TreeMap、HashTable
List/动态数组：ArrayList、LinkedList、Vector
set/去重：HashSet、LinkedHashSet、TreeSet
5.2.2 常见集合的特点
| 集合类型 | 安全性 | 有序性 | 结构 | 复杂度 |
|---|---|---|---|---|
| HashMap | 线程不安全 | 数据无序 | 数组+链表+红黑树 | 增删查/O(1)、O(n)、O(log(n)) |
| LinkedHashMap | 线程不安全 | 数据有序 | HashMap+双向链表 (双向链表记录插入顺序) |
增删查/O(1)、O(n)、O(log(n)) |
| TreeMap | 线程不安全 | 数据有序 可排序 | 红黑树 (根据主键自动排序) |
增删查/O(log(n)) |
| HashTable | 线程安全 | 数据无序 | 数组+链表 | 增删查/O(1)、O(n) |
| - | ||||
| ArrayList | 线程不安全 | 数据有序 | 数组 | 查询快/O(1)、非尾部增删慢/O(n) |
| LinkedList | 线程不安全 | 数据有序 | 双向链表 | 查询慢/O(n)、增删快/O(1) |
| vector | 线程安全 | 数据有序 | 数组 | 查询快/O(1)、非尾部增删慢/O(n) |
| - | ||||
| HashSet | 线程不安全 | 数据无序 | HashTable | 增删查/O(1)、O(n) |
| LinkedHashSet | 线程不安全 | 数据有序 | HashTable+链表 (链表记录插入顺序) |
增删查/O(1)、O(n) |
| TreeSet | 线程不安全 | 数据有序 可排序 | 红黑树 (根据主键自动排序) |
增删查/O(log(n)) |
6 Java8新特性
6.1 Lambda表达式
6.1.1 概述
Lambda表达式可理解为将代码块或者函数作为方法的参数进行传递，使代码更简洁。
6.1.2 语法
1. 语法
语法： (parameters) -> expression 或者 (parameters) ->{ statements; }；
其中， -> 为Lambda 操作符，该操作符将Lambda表达式分为两部分，左侧为Lambda表达式的参数列表，右侧为Lambda体，即Lambda表达式要执行的功能，Lambda 表达式可以看作为匿名函数。
2. 语法精简
① 每个参数的类型均可省略；
② 若参数列表只有一个参数，可省略小括号；
③ 若方法体中只有一句代码，可省略大括号；
④ 若方法体中只有一句代码，且是return语句，可省略大括号和return关键字。
3. 示例
// 不需要参数,返回2
() -> 2
// 接收1个参数(数字类型),返回其2倍的值
x -> 2 * x
// 接受2个参数(数字),并返回他们的和
(x, y) -> x + y
// 接收2个int型整数,返回他们的乘积
(int x, int y) -> x * y
// 接受1个string对象,并在控制台打印,不返回任何值
(String s) -> System.out.print(s)
6.1.3 函数式接口
① 若接口只有一个抽象方法，则该接口为函数式接口；
② 在接口上添加 @FunctionalInterface 注解，编译器则按照函数式接口的定义检测该接口。
6.1.4 Lambda表达式基本使用
1. 无返回函数式接口
//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
void test(int a);
}
//无返回值两个参数
@FunctionalInterface
interface MoreParameterNoReturn {
void test(int a,int b);
}
public class TestDemo {
public static void main(String[] args) {
NoParameterNoReturn n = ()->{
System.out.println("无参数无返回值");
};
n.test();
OneParameterNoReturn o = (a)-> {
System.out.println("无返回值一个参数"+a);
};
o.test(666);
MoreParameterNoReturn m = (int a,int b)->{
System.out.println("无返回值两个参数"+a+" "+b);
};
m.test(666,999);
}
}
2. 有返回函数式接口
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
int test(int a);
}
//有返回值多个参数
@FunctionalInterface
interface MoreParameterReturn {
int test(int a,int b);
}
public class TestDemo {
public static void main(String[] args) {
NoParameterReturn n = ()->{
return 666;
};
int ret1 = n.test();
System.out.println(ret1);
System.out.println("================");
OneParameterReturn o = (int a)->{
return a;
};
int ret2 = o.test(999);
System.out.println(ret2);
System.out.println("================");
MoreParameterReturn m = (int a,int b)-> {
return a+b;
};
int ret3 = m.test(10,90);
System.out.println(ret3);
}
}
6.1.5 变量捕获
匿名内部类中，只能捕获程序运行过程中没有发生改变的量，Lambda表达式，同样只能捕获程序运行过程中没有发生改变的量。
1. 匿名内部类变量捕获
class Test {
public void func(){
System.out.println("void func()");
}
}
public class TestDemo{
public static void main(String[] args) {
int a = 10;
new Test(){
//a = 20; error
@Override
public void func(){
System.out.println("捕获变量："+a);
}
};
}
}
2. Lambda表达式变量捕获
@FunctionalInterface
interface NoParameterNoReturn {
void test();
}
public static void main(String[] args) {
int a = 10;
NoParameterNoReturn noParameterNoReturn = ()->{
// a = 99; error
System.out.println("捕获变量："+a);
};
noParameterNoReturn.test();
}
6.1.6 Lambda表达式与集合
Java8中关于集合新增的方法有很多，本文介绍常用的如下。
使用forEach()遍历集合，包括List和Map，若要操作元素，需要实现 Consumer接口并重写accept()方法，accept()方法中为元素操作逻辑。使用sort()排序，需要实现Comparator接口并重写compare()方法。
1. List和foreach、sort
public class TestDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you"));
System.out.println("Java7及以前 使用增强for循环实现");
for(String str : list){
System.out.println(str);
}
System.out.println("使用forEach()结合匿名内部类实现");
list.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
System.out.println("使用forEach()结合Lambda表达式实现");
list.forEach( str -> {
System.out.println(str);
});
System.out.println("使用forEach()结合Lambda表达式实现 简化模式");
list.forEach(a-> System.out.println(a));
}
}
public class YuTest {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>(Arrays.asList("I", "love", "you"));
System.out.println("使用sort()结合匿名内部类实现");
list.sort(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});
System.out.println(list);
System.out.println("使用sort()结合Lambda表达式实现");
//Lambda方法
list.sort((o1,o2)->o2.compareTo(o1));
System.out.println(list);
}
}
2. HashMap和foreach
public static void main(String[] args) {
HashMap<Integer, String> map = new HashMap<>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");
System.out.println("Java7以及之前迭代Map");
for(Map.Entry<Integer, String> entry : map.entrySet()){
System.out.println(entry.getKey() + "=" + entry.getValue());
}
System.out.println("使用forEach()结合匿名内部类实现");
map.forEach(new BiConsumer<Integer, String>(){
@Override
public void accept(Integer k, String v){
System.out.println(k + "=" + v);
}
});
System.out.println("使用forEach()结合Lambda表达式实现");
map.forEach((k,v)-> System.out.println("key = " + k + " value = " + v));
}
6.2 Stream
6.2.1 Stream概述
1. 定义
Stream将要处理的元素集合看作一种流，在流过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等，如下图。
2. 操作
Stream由数组或集合创建，流操作分为两种：① 中间操作，每次返回一个或多个新流；② 终端操作，每个流只能进行一次终端操作，终端操作结束后流无法再次使用，并产生一个新的集合或值。
3. 特性
① stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果；
② stream不会改变数据源，通常情况下会产生一个新的集合或一个值；
③ stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。
6.2.2 Stream的创建
1. 创建
流创建有3种方式方式，分别为：① 通过 java.util.Collection.stream() 方法用集合创建；② 使用java.util.Arrays.stream(T[] array)方法用数组创建；③ 使用Stream的of()、iterate()、generate()方法创建。
List<String> list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();
int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println);
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);
2. 顺序流和并行流
stream是顺序流，由主线程操作流，parallelStream是并行流，以多线程并行操作流，前提是流的数据处理没有顺序要求。例如筛选集合中奇数，两者处理不同，如下图。
通过parallel()可将顺序流转换成并行流。
Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();
6.2.3 类型说明
Stream中元素类型是Optional，Optional类是一个可以为null的容器对象，如果值存，在则isPresent()方法会返回true，调用get()方法会返回该对象，案例使用实体类如下。
class Person {
private String name; // 姓名
private int salary; // 薪资
private int age; // 年龄
private String sex; //性别
private String area; // 地区
// 构造方法
public Person(String name, int salary, int age,String sex,String area) {
this.name = name;
this.salary = salary;
this.age = age;
this.sex = sex;
this.area = area;
}
}
6.2.4 遍历/匹配（foreach/find/match）
Stream类似集合，支持遍历和元素匹配，Stream的遍历、匹配非常简单，如下。
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
// 遍历输出符合条件的元素
list.stream().filter(x -> x > 6).forEach(System.out::println);
// 匹配第一个
Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
// 匹配任意（适用于并行流）
Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
// 是否包含符合特定条件的元素
boolean anyMatch = list.stream().anyMatch(x -> x > 6);
System.out.println("匹配第一个值：" + findFirst.get());
System.out.println("匹配任意一个值：" + findAny.get());
System.out.println("是否存在大于6的值：" + anyMatch);
}
}
6.2.5 筛选（filter）
筛选，按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。
如下案例分别为：① 筛选并打印Integer集合中大于7的元素；② 筛选员工中工资高于8000的人形成新的集合，形成新集合依赖collect（收集）。
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
Stream<Integer> stream = list.stream();
stream.filter(x -> x > 7).forEach(System.out::println);
}
}
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
List<String> fiterList = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName).collect(Collectors.toList());
System.out.print("高于8000的员工姓名：" + fiterList);
}
}
6.2.6 聚合（max/min/count)
MySQL中可使用max、min、count进行数据统计，Stream中也引入了这种用法，方便对集合、数组的数据进行统计。
如下案例分别为：① 获取集合中最长的元素；② 获取集合中的最大值；③ 获取员工工资最高的人；④ 计算集合中大于6的元素的个数。
public class StreamTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
Optional<String> max = list.stream().max(Comparator.comparing(String::length));
System.out.println("最长的字符串：" + max.get());
}
}
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
// 自然排序
Optional<Integer> max = list.stream().max(Integer::compareTo);
// 自定义排序
Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
});
System.out.println("自然排序的最大值：" + max.get());
System.out.println("自定义排序的最大值：" + max2.get());
}
}
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getSalary));
System.out.println("员工工资最大值：" + max.get().getSalary());
}
}
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);
long count = list.stream().filter(x -> x > 6).count();
System.out.println("list中大于6的元素个数：" + count);
}
}
6.2.7 映射(map/flatMap)
将一个流按照规则映射到另一个流，映射有两种，分别为：① map，接收一个函数作为参数，将该函数应用到元素上，并将其映射成新元素；② flatMap，接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
如下案例分别为：① 英字符串数组元素改为大写，整数数组每个元素加3；② 员工薪资增加1000；③ 将两个字符数组合并成一个新字符数组。
public class StreamTest {
public static void main(String[] args) {
String[] strArr = { "abcd", "bcdd", "defde", "fTr" };
List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());
System.out.println("每个元素大写：" + strList);
System.out.println("每个元素+3：" + intListNew);
}
}
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
// 不改变原来员工集合的方式
List<Person> personListNew = personList.stream().map(person -> {
Person personNew = new Person(person.getName(), 0, 0, null, null);
personNew.setSalary(person.getSalary() + 10000);
return personNew;
}).collect(Collectors.toList());
System.out.println("一次改动前：" + personList.get(0).getName() + "-->" + personList.get(0).getSalary());
System.out.println("一次改动后：" + personListNew.get(0).getName() + "-->" + personListNew.get(0).getSalary());
// 改变原来员工集合的方式
List<Person> personListNew2 = personList.stream().map(person -> {
person.setSalary(person.getSalary() + 10000);
return person;
}).collect(Collectors.toList());
System.out.println("二次改动前：" + personList.get(0).getName() + "-->" + personListNew.get(0).getSalary());
System.out.println("二次改动后：" + personListNew2.get(0).getName() + "-->" + personListNew.get(0).getSalary());
}
}
public class StreamTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
List<String> listNew = list.stream().flatMap(s -> {
// 将每个元素转换成一个stream
String[] split = s.split(",");
Stream<String> s2 = Arrays.stream(split);
return s2;
}).collect(Collectors.toList());
System.out.println("处理前的集合：" + list);
System.out.println("处理后的集合：" + listNew);
}
}
6.2.8 归约(reduce)
归约，也称缩减，可把一个流缩减成一个值，能实现对集合求和、求乘积、求最值。如下案例分别为：① 求Integer集合的元素之和、乘积和最大值；② 求所有员工的工资之和和最高工资。
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
// 求和方式1
Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
// 求和方式2
Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
// 求和方式3
Integer sum3 = list.stream().reduce(0, Integer::sum);
// 求乘积
Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
// 求最大值方式1
Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
// 求最大值写法2
Integer max2 = list.stream().reduce(1, Integer::max);
System.out.println("list求和：" + sum.get() + "," + sum2.get() + "," + sum3);
System.out.println("list求积：" + product.get());
System.out.println("list求和：" + max.get() + "," + max2);
}
}
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
// 求工资之和方式1：
Optional<Integer> sumSalary = personList.stream().map(Person::getSalary).reduce(Integer::sum);
// 求工资之和方式2：
Integer sumSalary2 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(),
(sum1, sum2) -> sum1 + sum2);
// 求工资之和方式3：
Integer sumSalary3 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);
// 求最高工资方式1：
Integer maxSalary = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
Integer::max);
// 求最高工资方式2：
Integer maxSalary2 = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),
(max1, max2) -> max1 > max2 ? max1 : max2);
System.out.println("工资之和：" + sumSalary.get() + "," + sumSalary2 + "," + sumSalary3);
System.out.println("最高工资：" + maxSalary + "," + maxSalary2);
}
}
6.2.9 收集(collect)
收集，就是把一个流收集起来，最终可以是收集成一个值或者一个新的集合，collect主要依赖java.util.stream.Collectors类内置的静态方法。
6.2.9.1 归集(toList/toSet/toMap)
流不存储数据，在流中的数据完成处理后，需要将流中的数据重新归集到新的集合里。toList、toSet和toMap比较常用，另外还有toCollection、toConcurrentMap等复杂一些的用法。如下案例演示toList、toSet和toMap。
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
.collect(Collectors.toMap(Person::getName, p -> p));
System.out.println("toList:" + listNew);
System.out.println("toSet:" + set);
System.out.println("toMap:" + map);
}
}
6.2.9.2 统计(count/averaging)
Collectors提供了一系列用于数据统计的静态方法，分别为：① 计数count；
② 平均值averagingInt、averagingLong、averagingDouble；③ 最值maxBy、minBy；
④ 求和summingInt、summingLong、summingDouble；⑤ 统计以上所有：summarizingInt、summarizingLong、summarizingDouble。
如下案例分别为：统计员工人数、平均工资、工资总额、最高工资。
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
// 求总数
Long count = personList.stream().collect(Collectors.counting());
// 求平均工资
Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
// 求最高工资
Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
// 求工资之和
Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
// 一次性统计所有信息
DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
System.out.println("员工总数：" + count);
System.out.println("员工平均工资：" + average);
System.out.println("员工工资总和：" + sum);
System.out.println("员工工资所有统计：" + collect);
}
}
6.2.9.3 分组(partitioningBy/groupingBy)
① 分区：将stream按条件分为两个Map，比如员工按薪资是否高于8000分为两部分；② 分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组。
如下案例为：将员工按薪资是否高于8000分为两部分，将员工按性别和地区分组。
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, "male", "New York"));
personList.add(new Person("Jack", 7000, "male", "Washington"));
personList.add(new Person("Lily", 7800, "female", "Washington"));
personList.add(new Person("Anni", 8200, "female", "New York"));
personList.add(new Person("Owen", 9500, "male", "New York"));
personList.add(new Person("Alisa", 7900, "female", "New York"));
// 将员工按薪资是否高于8000分组
Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
// 将员工按性别分组
Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
// 将员工先按性别分组，再按地区分组
Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
System.out.println("员工按薪资是否大于8000分组情况：" + part);
System.out.println("员工按性别分组情况：" + group);
System.out.println("员工按性别、地区：" + group2);
}
}
6.2.9.4 接合(joining)
joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
System.out.println("所有员工的姓名：" + names);
List<String> list = Arrays.asList("A", "B", "C");
String string = list.stream().collect(Collectors.joining("-"));
System.out.println("拼接后的字符串：" + string);
}
}
6.2.9.5 归约(reducing)
Collectors类提供的reducing方法，相比于stream本身的reduce方法，增加了对自定义归约的支持。
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
// 每个员工减去起征点后的薪资之和（这个例子并不严谨，但一时没想到好的例子）
Integer sum = personList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> (i + j - 5000)));
System.out.println("员工扣税薪资总和：" + sum);
// stream的reduce
Optional<Integer> sum2 = personList.stream().map(Person::getSalary).reduce(Integer::sum);
System.out.println("员工薪资总和：" + sum2.get());
}
}
6.2.10 排序(sorted)
排序，中间操作，分为两种：① sorted()，自然排序，流中元素需实现Comparable接口；② sorted(Comparator com)，Comparator排序器自定义排序。
如下案例为：将员工按工资由高到低（工资一样则按年龄由大到小）排序。
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Sherry", 9000, 24, "female", "New York"));
personList.add(new Person("Tom", 8900, 22, "male", "Washington"));
personList.add(new Person("Jack", 9000, 25, "male", "Washington"));
personList.add(new Person("Lily", 8800, 26, "male", "New York"));
personList.add(new Person("Alisa", 9000, 26, "female", "New York"));
// 按工资升序排序（自然排序）
List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName).collect(Collectors.toList());
// 按工资倒序排序
List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed()).map(Person::getName).collect(Collectors.toList());
// 先按工资再按年龄升序排序
List<String> newList3 = personList.stream().sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName).collect(Collectors.toList());
// 先按工资再按年龄自定义排序（降序）
List<String> newList4 = personList.stream().sorted((p1, p2) -> {
if (p1.getSalary() == p2.getSalary()) {
return p2.getAge() - p1.getAge();
} else {
return p2.getSalary() - p1.getSalary();
}
}).map(Person::getName).collect(Collectors.toList());
System.out.println("按工资升序排序：" + newList);
System.out.println("按工资降序排序：" + newList2);
System.out.println("先按工资再按年龄升序排序：" + newList3);
System.out.println("先按工资再按年龄自定义降序排序：" + newList4);
}
}
6.2.11 提取/组合
流也可以进行合并、去重、限制、跳过等操作。
public class StreamTest {
public static void main(String[] args) {
String[] arr1 = { "a", "b", "c", "d" };
String[] arr2 = { "d", "e", "f", "g" };
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
// concat:合并两个流 distinct：去重
List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
// limit：限制从流中获得前n个数据
List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
// skip：跳过前n个数据
List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
System.out.println("流合并：" + newList);
System.out.println("limit：" + collect);
System.out.println("skip：" + collect2);
}
}