Stream API概述
流（Stream）是与任何特定存储机制无关的元素序列，它关注的是对数据的运算操作，与CPU打交道；集合关注的数据的存储，与内存打交道。
Stream API是Java8提供的一套API，使用这套API可以对内存中的数据进行过滤、排序、映射、规约等操作，和sql对数据库中数据的操作类似，也可以近似地看成是集合中的迭代器Iterator的增强版。
需要注意的点：
- Stream自己不会存储元素。
- Stream不会改变源对象。它们会返回一个持有结果的新的Stream对象。
- Stream操作延迟执行的。这意味着他们会等到需要结果的时候才执行。
Stream使用流程
- Stream的实例化。
- 一系列的中间操作（过滤、映射...）。
- 终止操作。
需要注意的点：
- 一个中间操作链，是对数据源的数据进行处理。
- 执行终止操作，中间操作链才会执行，然后产生结果。之后，不会再次，如果想要再次获得这个结果，就要重新执行前面的流程。
下面按照使用流程来进行使用
创建Stream
创建Stream总共有四种方式，直接看示例代码：
public class StreamAPITest {
//创建Stream方式一：通过集合
@Test
public void test() {
List<Employee> employees = EmployeeData.getEmployees();
//default Stream<E> stream():返回一个顺序流
Stream<Employee> stream = employees.stream();
//default Stream<E> parallelStream():返回一个并行流
Stream<Employee> parallelStream = employees.parallelStream();
}
//创建Stream方式二：通过数组
@Test
public void test2() {
int[] arr = new int[]{1, 2, 3, 4, 5, 6};
// 调用Arrays类的 static <T> Stream<T> stream(T[] array)：返回一个流
IntStream stream = Arrays.stream(arr);
Employee e1 = new Employee(1001, "Tom");
Employee e2 = new Employee(1002, "Jerry");
Employee[] arr1 = {e1, e2};
Stream<Employee> stream1 = Arrays.stream(arr1);
}
//创建Stream方式三：通过Stream的of()
@Test
public void test3() {
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
}
//创建Stream方式四：创建无限流
@Test
public void test4() {
//迭代
//static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
//遍历前10个偶数
Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
//生成
//static<T> Stream<T> generate(Supplier<T> s)
Stream.generate(Math::random).limit(10).forEach(System.out::println);
}
}
上述例子中有两个类EmployeeData和Employee，后续操作会用到，这里给出相关代码。
Employee类：
public class Employee {
private int id;
private String name;
private int age;
private double salary;
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 double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Employee() {
}
public Employee(int id) {
this.id = id;
}
public Employee(int id, String name) {
this.id = id;
this.name = name;
}
public Employee(int id, String name, int age, double salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
@Override
public String toString() {
return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Employee employee = (Employee) o;
if (id != employee.id)
return false;
if (age != employee.age)
return false;
if (Double.compare(employee.salary, salary) != 0)
return false;
return name != null ? name.equals(employee.name) : employee.name == null;
}
@Override
public int hashCode() {
int result;
long temp;
result = id;
result = 31 * result + (name != null ? name.hashCode() : 0);
result = 31 * result + age;
temp = Double.doubleToLongBits(salary);
result = 31 * result + (int) (temp ^ (temp >>> 32));
return result;
}
}
EmployeeData类：
public class EmployeeData {
public static List<Employee> getEmployees(){
List<Employee> list = new ArrayList<>();
list.add(new Employee(1001, "马化腾", 34, 6000.38));
list.add(new Employee(1002, "马云", 12, 9876.12));
list.add(new Employee(1003, "刘强东", 33, 3000.82));
list.add(new Employee(1004, "雷军", 26, 7657.37));
list.add(new Employee(1005, "李彦宏", 65, 5555.32));
list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
list.add(new Employee(1007, "任教主", 26, 4333.32));
list.add(new Employee(1008, "扎克伯格", 35, 2500.32));
return list;
}
}
中间操作
多个中间操作可以连接起来就像火车的车厢，而终止操作就像是一个火车头，在没有火车头的情况下，单独连接在一起的车厢不会动，只有接上火车头，那么车厢才能动，也就是说一个或多个中间操作在没有终止操作的时候，是不执行的。
筛选与切片
| 方法 | 描述 |
|---|---|
| filter(Predicate p) | 接收Lambda表达式，从流中排除某些元素 |
| distinct() | 筛选，通过流所生成元素的hashCode()和equals()去除重复元素 |
| limit(long maxSize) | 截断流，使其元素不超过给定的数量 |
| skip(long n) | 跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流，与limit(n)互补 |
代码示例：
//执行终止操作后，Stream流就被关闭了，使用时需要再次创建Stream流
@Test
public void test1() {
List<Employee> employees = EmployeeData.getEmployees();
// filter(Predicate p) -- 接收 Lambda表达式，从流中排除某些元素。
Stream<Employee> employeeStream = employees.stream();
// 练习：查询员工表中薪资大于7000的员工信息
employeeStream.filter(employee -> employee.getSalary() > 7000).forEach(System.out::println);
System.out.println();//换行
// 每次执行完终止操作后，流就被关闭了，
// 如果不重新生成一个，继续操作就会报错java.lang.IllegalStateException: stream has already been operated upon or closed
employeeStream = employees.stream();
// limit(n) -- 截断流，使其元素不超过给定数量。
employeeStream.limit(3).forEach(System.out::println);
System.out.println();
// skip(n) -- 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n) 互补
employees.stream().skip(3).forEach(System.out::println);
System.out.println();
// distinct() -- 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素。
employees.add(new Employee(10086, "周鸿祎", 50, 88888));
employees.add(new Employee(10086, "周鸿祎", 50, 88888));
employees.add(new Employee(10086, "周鸿祎", 50, 88888));
employees.add(new Employee(10086, "周鸿祎", 50, 88888));
employees.stream().distinct().forEach(System.out::println);
}
/**
运行结果：
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1007, name='任教主', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1007, name='任教主', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
Employee{id=10086, name='周鸿祎', age=50, salary=88888.0}
*/
映射
| 方法 | 描述 |
|---|---|
| map(Function f) | 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。 |
| mapToDouble(ToDoubleFunction f) | 接受一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream。 |
| mapToInt(ToIntFunction f) | 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的IntStream。 |
| mapToLong(ToLongFunction f) | 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的LongStrream。 |
| flatMap(Function f) | 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流 |
代码示例：
@Test
public void test2() {
List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
// map(Function f) -- 接收一个函数作为参数，将元素转换成其他形式或提取信息，
// 该函数会被应用到每个元素上，，并将其映射成一个新的元素。
list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
System.out.println();
// 练习1：获取员工姓名长度大于3的员工的姓名。
List<Employee> employees = EmployeeData.getEmployees();
Stream<String> namesStream = employees.stream().map(Employee::getName);
namesStream.filter(name -> name.length() > 3).forEach(System.out::println);
System.out.println();
// 练习2: 使用map()中间操作实现flatMap()中间操作方法
Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
streamStream.forEach(s -> {
s.forEach(System.out::println);
});
System.out.println();
// flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
characterStream.forEach(System.out::println);
}
// 将字符串中的多个字符构成的集合转换为对应的Stream的实例
public static Stream<Character> fromStringToStream(String str) {
ArrayList<Character> list = new ArrayList<>();
for (Character c : str.toCharArray()) {
list.add(c);
}
return list.stream();
}
// map()和flatMap()方法类似于List中的add()和addAll()方法
// add()方法直接将list2集合作为元素添加到list1中，addAll()方法将list2中的元素添加到list1中
@Test
public void test() {
ArrayList list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.add(4);
ArrayList list2 = new ArrayList<>();
list2.add(5);
list2.add(6);
list2.add(7);
//list1.add(list2);
//System.out.println(list1); //[1, 2, 3, 4, [5, 6, 7]]
list1.addAll(list2);
System.out.println(list1); //[1, 2, 3, 4, 5, 6, 7]
}
/**
运行结果：
AA
BB
CC
DD
比尔盖茨
扎克伯格
a
a
b
b
c
c
d
d
a
a
b
b
c
c
d
d
*/
排序
| 方法 | 描述 |
|---|---|
| sorted() | 产生一个新流，其中按自然顺序排序 |
| sorted(Comparator com) | 产生一个新流，其中按比较器顺序排序 |
代码示例：
@Test
public void Test3() {
// sorted() -- 自然排序
List<Integer> list = Arrays.asList(12, -34, 84, 64, 33);
list.stream().sorted().forEach(System.out::println);
System.out.println();
// 抛异常，原因：Employee没有实现Comparable接口；如果不想修改Employee类，
// 就需要使用定制排序sorted(Comparator com)
// List<Employee> employees = EmployeeData.getEmployees();
// employees.stream().sorted().forEach(System.out::println);
// sorted(Comparator com) -- 定制排序
List<Employee> employees1 = EmployeeData.getEmployees();
employees1.stream().sorted((e1, e2) -> {
int ageValue = Integer.compare(e1.getAge(), e2.getAge());
if (ageValue != 0) {
return ageValue;
} else {
return -Double.compare(e1.getSalary(), e2.getSalary());
}
}).forEach(System.out::println);
}
/**
运行结果：
-34
12
33
64
84
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1007, name='任教主', age=26, salary=4333.32}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
*/
终止操作（终止操作）
终端操作会从流的流管道生成结果，其结果可以使任何不是流的值，例如：List、Integer，甚至是void。
流进行了终止操作后，不能再次使用。
匹配与查找
| 方法 | 描述 |
|---|---|
| allMatch(Predicate p) | 检查是否匹配所有元素 |
| anyMatch(Predicate p) | 检查是否至少匹配一个元素 |
| noneMatch(Predicate p) | 检查是否没有匹配所有元素 |
| findFirst() | 返回第一个元素 |
| findAny() | 返回当前流中的任意元素 |
| count() | 返回流中元素总数 |
| max(Comparator c) | 返回流中最大值 |
| min(Comparator c) | 返回流中最小值 |
| forEach(Consumer c) | 内部迭代（使用Collection接口需要用户去做迭代，称为外部迭代。相反，Stream API使用内部迭代——它帮你把迭代做了） |
代码示例：
public class StreamAPITest2 {
@Test
public void Test1() {
List<Employee> employees = EmployeeData.getEmployees();
// allMatch(Predicate p) -- 检查是否匹配所有元素。
// 练习：是否所有的员工的年龄都大于18
boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
System.out.println(allMatch);
// anyMatch(Predicate p) -- 检查是否至少匹配一个元素。
// 练习：是否存在员工的工资大于 5000
boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 5000);
System.out.println(anyMatch);
// noneMatch(Predicate p) -- 检查是否没有匹配的元素。注意，这里没有匹配的元素才会返回true
// 练习：是否存在员工姓“雷”
boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
System.out.println(noneMatch);
System.out.println();
// findFirst() -- 返回第一个元素
Optional<Employee> first = employees.stream().findFirst();
System.out.println(first);
// findAny -- 返回当前流中的任意元素，配合并行流才能看到效果，串行流只会返回第一个
Optional<Employee> employee = employees.parallelStream().findAny();
System.out.println(employee);
/**
运行结果：
false
true
false
Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]
Optional[Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}]
*/
}
@Test
public void Test2() {
List<Employee> employees = EmployeeData.getEmployees();
// count() -- 返回流中元素的总个数
long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
System.out.println(count);
// max(Comparator c) -- 返回流中最大值
// 练习：返回最高的工资
Optional<Double> maxSalary = employees.stream().map(e -> e.getSalary()).max(Double::compareTo);
System.out.println(maxSalary);
// min(COmparator c) -- 返回流中最小值
// 练习：返回最低的工资
Optional<Double> minSalary = employees.stream().map(e -> e.getSalary()).min(Double::compareTo);
System.out.println(minSalary);
// forEach(Consumer c) -- 内部迭代
employees.stream().forEach(System.out::println);
System.out.println();
// 使用集合的遍历操作
employees.forEach(System.out::println);
/**
运行结果：
5
Optional[9876.12]
Optional[2500.32]
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1007, name='任教主', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1003, name='刘强东', age=33, salary=3000.82}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1007, name='任教主', age=26, salary=4333.32}
Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
*/
}
}
规约
| 方法 | 描述 |
|---|---|
| reduce(T iden, BinaryOperator b) | 可以将流中元素反复结合起来，得到一个值。返回 T |
| reduce(BinaryOperator b) | 可以将流中元素反复结合起来，得到一个值。返回Optional<T> |
map和reduce的连接通常称为 map-reduce模式，因Google用它来进行网络搜索而出名
代码示例：
@Test
public void test3() {
// reduce(T identity, BinaryOperator) -- 可以将流中元素反复结合起来，得到一个值，返回 T
// 练习：计算1-10的自然数的和
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer sum = list.stream().reduce(0, Integer::sum); // identity可以理解成初始值
System.out.println(sum);
// reduce(BinaryOperator) -- 可以将流中元素反复结合起来，得到一个值，返回Optional<T>
// 练习2：计算公司所有员工工资的总和
List<Employee> employees = EmployeeData.getEmployees();
Optional<Double> sumSalary = employees.stream().map(e -> e.getSalary()).reduce(Double::sum);
System.out.println(sumSalary);
}
/**
运行结果：
55
Optional[48424.08]
*/
收集
| 方法 | 描述 |
|---|---|
| collect(Collector c) | 将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法 |
Collector接口中方法的实现决定了如何对流执行收集的操作（如收集到List、Set、Map）
Collectors类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：
Collectors类的静态方法
Collectors类的静态方法
代码示例：
@Test
public void test4() {
// collect(Collector c) -- 将流转换为其他形式，接受一个Collector接口的实现，
// 用于给Stream中元素做汇总的方法
// 练习1：查找工资大于6000的员工，结果返回一个List或Set
List<Employee> employees = EmployeeData.getEmployees();
List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
employeeList.forEach(System.out::println);
System.out.println();
Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
employeeSet.forEach(System.out::println);
}
/**
运行结果：
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1001, name='马化腾', age=34, salary=6000.38}
Employee{id=1002, name='马云', age=12, salary=9876.12}
Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
Employee{id=1004, name='雷军', age=26, salary=7657.37}
*/
Optional类的概述
在Java中，空指针异常极为常见，Optional类就是为了解决Java中的空指针问题而生的
Optional<T>类（java.util.Optional）是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用null表示一个值不存在，现在Optional可以更好的表达这个概念，并且可以避免空指针异常。
Optional类提供的方法
Optional类提供了很多方法，下面来介绍 一下这些方法。
创建Optional类对象的方法
-
Optional.of(T t)：创建一个Optional实例，t必须非空； -
Optional.empty()：创建一个空的Optional实例 -
Optional.ofNullable(T t)：t可以为null
判断Optional容器是否包含对象
-
boolean isPresent()：判断是否包含对象 -
void ifPresent(Consumer<? super T> consumer)：如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它。
获取Optional容器的对象
-
T get()：如果调用对象包含值，返回该值，否则抛异常 -
T orElse(T other)：如果有值则将其返回，否则返回指定的other对象 -
T orElseGet(Supplier<? extends t> other)：如果有值则将其返回，否则返回由Supplier接口实现提供的对象。 -
T orElseThrow(Supplier<? extends X> exceptionSupplier)：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。
搭配使用
-
of()和get()搭配使用，明确对象非空 -
ofNullable()和orElse()搭配使用，不确定对象非空
应用举例
代码示例：
public class OptionalTest {
@Test
public void test1() {
// empty()：创建的Optional独享内部的value = null
Optional<Object> opl = Optional.empty();
if (!opl.isPresent()) { // Optional封装的数据是否包含数据
System.out.println("数据为空");
}
System.out.println(opl);
System.out.println(opl.isPresent());
// 如果Optional封装的数据value为空，则get()报错。否则，value不为空时，返回value
System.out.println(opl.get()); // java.util.NoSuchElementException: No value present
/**
运行结果：
数据为空
Optional.empty
false
*/
}
@Test
public void Test2() {
String str = "Java";
//str = null;
// of(T t)：封装数据t生成Optional对象。要求t非空，否则报错 java.lang.NullPointerException
Optional<String> opl = Optional.of(str);
// get()通常与of()搭配使用，用于获取内部封装的数据value
String str1 = opl.get();
System.out.println(str1);
/**
运行结果：
Java
*/
}
@Test
public void test3() {
String str = "MySQL";
str = null;
// ofNullable(T t)：封装数据t赋值给Optional内部的value 。不要求t非空
Optional<String> opl = Optional.ofNullable(str);
System.out.println(opl);
// orElse(T t1)：如果Optional内部的value非空，则返回此value值。如果value为空，则返回t1
String str2 = opl.orElse("Spring");
System.out.println(str2);
/**
运行结果：
Optional.empty
Spring
*/
}
}
使用Optional类避免产生空指针异常。
public class OptionalTest2 {
// 不使用Optional类 进行非空校验
public String getGirlName1(Boy boy) {
if (boy != null) {
Girl girl = boy.getGirl();
if (girl != null) {
return girl.getName();
}
}
return null;
}
// 使用Optional类进行非空校验
public String getGirlName2(Boy boy) {
Optional<Boy> boyOptional = Optional.ofNullable(boy);
// 此时的boy1一定非空，boy为空时返回“雏田”
Boy boy1 = boyOptional.orElse(new Boy(new Girl("雏田")));
Girl girl = boy1.getGirl();
// girl1一定非空，girl为空时返回“冯宝宝”
Optional<Girl> girlOptional = Optional.ofNullable(girl);
Girl girl1 = girlOptional.orElse(new Girl("冯宝宝"));
return girl1.getName();
}
// 测试getGirlName1(Boy boy)
@Test
public void test1() {
Boy boy = null;
System.out.println(getGirlName1(boy));
boy = new Boy();
System.out.println(getGirlName1(boy));
boy = new Boy(new Girl("冯宝宝"));
System.out.println(getGirlName1(boy));
/**
运行结果：
null
null
冯宝宝
*/
}
// 测试getGirlName2(Boy boy)
@Test
public void test2() {
Boy boy = null;
System.out.println(getGirlName2(boy));
boy = new Boy();
System.out.println(getGirlName2(boy));
boy = new Boy(new Girl("冯宝宝"));
System.out.println(getGirlName2(boy));
/**
运行结果：
雏田
冯宝宝
冯宝宝
*/
}
}
Girl类：
public class Girl {
private String name;
public Girl() {
}
public Girl(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Girl{" +
"name='" + name + '\'' +
'}';
}
}
Boy类：
public class Boy {
private Girl girl;
public Boy() {
}
public Boy(Girl girl) {
this.girl = girl;
}
public Girl getGirl() {
return girl;
}
public void setGirl(Girl girl) {
this.girl = girl;
}
@Override
public String toString() {
return "Boy{" +
"girl=" + girl +
'}';
}
}
网友评论