Java 8 - Stream API - Filtrowanie listy, brak rezultatu

Question

Napisałem klasę Task, EmployeeDAO do komunikacji z bazą danych oraz ProfileServlet, gdzie wywołuję napisane w EmployeeDAO metody.

Chciałbym pobrać listę wszystkich zadań dla pracownika o wybranym id (to zrobiłem poprawnie), a następnie przefiltrować wyniki, by pozostawić zadania wyłącznie z jednej kategorii (tutaj natomiast moja implementacja podświetlona w kodzie niczego nie filtruje, tzn. zwraca te same wyniki).

package com.plkpiotr.kanban.api;

import javax.persistence.*;

/**
 * Represents a tasks.
 * A tasks belongs to a project and employee.
 */
@Entity
@Table(name = "tasks")
public class Task {

    @Id
    @Column(columnDefinition = "serial")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(nullable = false, length = 5)
    private String category;

    @Column(nullable = false, length = 64)
    private String content;

    @ManyToOne
    @JoinColumn(name = "id_project")
    private Project project;

    @ManyToOne
    @JoinColumn(name = "id_employee")
    private Employee employee;

    public Integer getId() {
        return id;
    }

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

    public String getCategory() {
        return category;
    }

    public void setCategory(String category) {
        this.category = category;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Project getProject() {
        return project;
    }

    public void setProject(Project project) {
        this.project = project;
    }

    public Employee getEmployee() {
        return employee;
    }

    public void setEmployee(Employee employee) {
        this.employee = employee;
    }
}

package com.plkpiotr.kanban.dao;

import com.plkpiotr.kanban.api.Employee;
import com.plkpiotr.kanban.api.Task;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Provides "Data Access Object" for "Employee" class.
 */
public class EmployeeDAO {
    private EntityManager entityManager;

    /**
     * Creates a employee through given manager of entities.
     *
     * @param entityManager Manager of entities for employee.
     */
    public EmployeeDAO(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    /**
     * Inserts a employee to database.
     *
     * @param employee Employee object waiting for inserting to database.
     */
    public boolean insertEmployee(Employee employee) {
        EntityTransaction entityTransaction = entityManager.getTransaction();
        employee.setPassword(this.encodePassword(employee.getPassword()));
        try {
            entityTransaction.begin();
            entityManager.persist(employee);
            entityTransaction.commit();
            return true;
        } catch (Exception e) {
            entityTransaction.rollback();
            e.printStackTrace();
            return false;
        }
    }

    /**
     * Encodes password through "Message-Digest algorithm 5".
     *
     * @param password Password posts in a form.
     */
    private String encodePassword(String password) {
        MessageDigest messageDigest = null;
        try {
            MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
        messageDigest.update(password.getBytes());
        BigInteger hashCode = new BigInteger(1, messageDigest.digest());
        String finished = hashCode.toString(16);
        if (finished.length() == 31)
            finished = "0" + finished;
        return finished;
    }

    /**
     * Gets employee by nick.
     *
     * @param nick Nick employee's.
     */
    public Employee getEmployee(final String nick) {
        return (Employee) entityManager.createQuery("SELECT e from Employee e WHERE e.nick = :nick")
                .setParameter("nick", nick)
                .getSingleResult();
    }

    /**
     * Gets all tasks for a employee.
     *
     * @param idEmployee ID employee's.
     */
    public List<Task> getAllTasks(final int idEmployee) {
        return entityManager.createQuery("SELECT t from Task t WHERE t.employee.id = :idEmployee")
                .setParameter("idEmployee", idEmployee)
                .getResultList();
    }

    /**
     * Gets tasks for a employee by category.
     *
     * @param tasks List of all tasks for a employee.
     * @param category One of the category task's: "todo", "doing" or "done".
     */
    public List<Task> getTasksByCategory(List<Task> tasks, final String category) {
        tasks.stream()
                .filter(task -> category.equals(task.getCategory()))
                .collect(Collectors.toList());
        return tasks;
    }
}

package com.plkpiotr.kanban.servlets;

import com.plkpiotr.kanban.api.Task;
import com.plkpiotr.kanban.dao.EmployeeDAO;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

@WebServlet("/profile")
public class ProfileServlet extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        EmployeeDAO employeeDAO = (EmployeeDAO) request.getAttribute("initEmployeeDAO");
        List<Task> allTasks = employeeDAO.getAllTasks(1);
        List<Task> todoTasks = employeeDAO.getTasksByCategory(allTasks, "doing");
        //request.setAttribute("allTasks", allTasks);
        response.getWriter().println(todoTasks);
        //request.getRequestDispatcher("/WEB-INF/views/profile.jsp").forward(request, response);
    }
}

Czy mógłbym prosić o nakierowanie gdzie popełniam błąd? W wyrażeniu lambda, czy w kolejnych metodach strumienia?

Comments

Zamiast poprzedniej wersji:

public List<Task> getTasksByCategory(List<Task> tasks, final String category) {
        tasks.stream()
                .filter(task -> category.equals(task.getCategory()))
                .collect(Collectors.toList());
        return tasks;
}

Poradziłem sobie w ten sposób:

public List<Task> getTasksByCategory(List<Task> tasks, final String category) {
        return tasks.stream()
                .filter(task -> category.contains(task.getCategory()))
                .collect(Collectors.toList());
}

Jednak nie rozumiem, dlaczego equals() nie zadziałało tylko contains()...

Answer 1

Fiter powinno działać dobrze poprostu collector zwraca NOWĄ listę. A ty zwracałeś starą, pozdrawiam :)

Dodatkowo mogą być problemy z wielością liter oraz białymi znakami.