删除父对象时如何删除由 ZF7B44CFFAFD5C52223D5498196C8A2E7BZ.flatMap 创建的列表中的子对象？

Question

假设我有一个部门 class 包含员工列表，如下所示：

public class Departement {
    List<Employees> employeesList;

    public List<Employees> getEmployeesList() {
        return employeesList;
    }

    public Departement setEmployeesList(List<Employees> employeesList) {
        this.employeesList = employeesList;
        return this;
    }
}

有一种情况，我需要将所有员工列在一个单独的列表中。 为此，我正在使用流，如下所示：

List<Departement> departments ...
List<Employees> employees = departments.stream().flatMap(departement -> 
departement.getEmployeesList().stream()).collect(Collectors.toList()));

如果我在部门列表中删除一个部门，有没有办法在stream.flatMap制作的员工列表中自动删除其员工？

Answer 1

只是为了尝试一下，我实现了一个由父列表支持的通用列表类型：

public class FlatMapList<C,P> implements List<C>
{

    private Function<P,List<C>> getter;
    private List<P> parents;


    public FlatMapList(List<P> parents, Function<P,List<C>> getter)
    {
       this.parents = parents;
       this.getter = getter;

    }

    @Override
    public int size()
    {
        return getList().size();
    }

    @Override
    public boolean isEmpty()
    {
        return getList().isEmpty();
    }

    @Override
    public boolean contains(Object o)
    {
        return getList().contains(o);
    }

    @Override
    public Iterator<C> iterator()
    {
        return getList().iterator();
    }

    @Override
    public Object[] toArray()
    {
        return getList().toArray();
    }

    @Override
    public <T> T[] toArray(T[] a)
    {
        return getList().toArray(a);
    }

    @Override
    public boolean add(C e)
    {
        throw new UnsupportedOperationException("List is readonly");
    }

    @Override
    public boolean remove(Object o)
    {
        throw new UnsupportedOperationException("List is readonly");
    }

    @Override
    public boolean containsAll(Collection<?> c)
    {
        throw new UnsupportedOperationException("List is readonly");
    }

    @Override
    public boolean addAll(Collection<? extends C> c)
    {
        throw new UnsupportedOperationException("List is readonly");
    }

    @Override
    public boolean addAll(int index, Collection<? extends C> c)
    {
        throw new UnsupportedOperationException("List is readonly");
    }

    @Override
    public boolean removeAll(Collection<?> c)
    {
        throw new UnsupportedOperationException("List is readonly");
    }

    @Override
    public boolean retainAll(Collection<?> c)
    {
        throw new UnsupportedOperationException("List is readonly");
    }

    @Override
    public void clear()
    {
        throw new UnsupportedOperationException("List is readonly");
    }

    @Override
    public C get(int index)
    {
        return getList().get(index);
    }

    @Override
    public C set(int index, C element)
    {
        throw new UnsupportedOperationException("List is readonly");
    }

    @Override
    public void add(int index, C element)
    {
        throw new UnsupportedOperationException("List is readonly");

    }

    @Override
    public C remove(int index)
    {
        throw new UnsupportedOperationException("List is readonly");
    }

    @Override
    public int indexOf(Object o)
    {
        return getList().indexOf(o);
    }

    @Override
    public int lastIndexOf(Object o)
    {
        return getList().lastIndexOf(o);
    }

    @Override
    public ListIterator<C> listIterator()
    {
        return getList().listIterator();
    }

    @Override
    public ListIterator<C> listIterator(int index)
    {
        return getList().listIterator(index);
    }

    @Override
    public List<C> subList(int fromIndex, int toIndex)
    {
        return getList().subList(fromIndex,toIndex);
    }

    @Override
    public String toString( ) {
        return getList().toString();
    }

    private List<C> getList() {
        return Collections.unmodifiableList(parents.stream().flatMap(p ->
            this.getter.apply(p).stream()).collect(Collectors.toList()));
    }

    public static void main(String[] args) {

       Department dep1 = new Department();
       dep1.setName("D1");
       dep1.setEmployeesList(Arrays.asList(new Employee("e1"),new Employee("e2")));
       Department dep2 = new Department();
       dep2.setName("D2");
       dep2.setEmployeesList(Arrays.asList(new Employee("e3"),new Employee("e4")));
       List<Department> deps = new ArrayList<>(Arrays.asList(dep1,dep2));

       // Create a List backed with the parent list and the getter for the children
       List<Employee> employees = new FlatMapList<>(deps,Department::getEmployeesList);
       System.out.println(employees);
       deps.remove(dep1);
       System.out.println(employees);

    }
}

Output

[Employee [name=e1], Employee [name=e2], Employee [name=e3], Employee [name=e4]] 
[Employee [name=e3], Employee [name=e4]]

Answer 2

当您从列表中删除一个部门时，它将自动删除子级，即员工。 请在下面找到代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Departement {
    List<Employees> employeesList;

    public List<Employees> getEmployeesList() {
        return employeesList;
    }

    public Departement setEmployeesList(List<Employees> employeesList) {
        this.employeesList = employeesList;
        return this;
    }

    @Override
    public String toString() {
        return "Departement{" +
                "employeesList=" + employeesList +
                '}';
    }
}

class Employees {
    private String name;

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

    public String getName() {
        return name;
    }

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

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

public class Test {
    public static void main(String[] args) {
        Employees emp1 = new Employees("emp1");
        Employees emp2 = new Employees("emp2");
        Employees emp3 = new Employees("emp3");
        List<Employees> employees1 = Arrays.asList(emp1);
        List<Employees> employees2 = Arrays.asList(emp2);
        List<Employees> employees3 = Arrays.asList(emp3);
        Departement departement1 = new Departement();
        departement1.setEmployeesList(employees1);
        Departement departement2 = new Departement();
        departement2.setEmployeesList(employees2);
        Departement departement3 = new Departement();
        departement3.setEmployeesList(employees3);

        List<Departement> departments = new ArrayList<>();
        departments.add(departement1);
        departments.add(departement2);
        departments.add(departement3);
        System.out.println(departments); // printing all the departements
        departments.remove(departement2); // now deleting department2
        System.out.println(departments); // printing all the departements
    }
}

Output：

[Departement{employeesList=[Employees{name='emp1'}]}, Departement{employeesList=[Employees{name='emp2'}]}, Departement{employeesList=[Employees{name='emp3'}]}]
[Departement{employeesList=[Employees{name='emp1'}]}, Departement{employeesList=[Employees{name='emp3'}]}]

更新 1：没有直接的方法可以从员工列表中自动删除对象。 您可以使用以下任一选项：

方案一：首先删除待删除部门的所有员工，并从部门列表中删除该部门。

for (Employees employees4 : departement2.getEmployeesList()) {
    employees.remove(employees4);
}
departments.remove(departement2);

选项 2：从部门列表中删除部门，然后再次创建员工列表：

departments.remove(departement2);
employees = departments.stream().flatMap(departement ->departement.getEmployeesList().stream()).collect(Collectors.toList());