How to compare two Arraylist and get the values shared by both?

Question

I own two classes, they are:

Filtrocity class:

public class FiltroCidade {

    private int idCandidato;
    private List<String> cidades;

    public FiltroCidade(){ }

    public int getIdCandidato() {
        return idCandidato;
    }

    public void setIdCandidato(int idCandidato) {
        this.idCandidato = idCandidato;
    }

    public void addCidade(String cidade) {
        cidades.add(cidade);
    }

    public List<String> getCidades() {
        return cidades;
    }    
}

Vagaemprego Class:

public class VagaEmprego {    
    private String nomeVaga;
    private String cidade;

    public VagaEmprego() { }    

    public VagaEmprego(String nomeVaga, String cidade) {        
        this.nomeVaga = nomeVaga;
        this.cidade = cidade;
    }

    public String getNomeVaga() {
        return nomeVaga;
    }

    public void setNomeVaga(String nomeVaga) {
        this.nomeVaga = nomeVaga;
    }

    public String getCidade() {
        return cidade;
    }

    public void setCidade(String cidade) {
        this.cidade = cidade;
    }
}

And I own a ArrayList populated, he is:

Arraylist vacant:

List<VagaEmprego> vagas = new ArrayList<>();
vagas.add(new VagaEmprego("Programador C", "Cruzeiro"));
vagas.add(new VagaEmprego("Programador Delphi", "Queluz"));
vagas.add(new VagaEmprego("Administrador", "Acre"));
vagas.add(new VagaEmprego("Programador Java", "Guaratingueta"));

And I have several cities added in the attribute cidades of my class FiltroCidade, see:

FiltroCidade filtroCidade = new FiltroCidade();
filtroCidade.setIdCandidato(1);
filtroCidade.addCidade("Cruzeiro");
filtroCidade.addCidade("Gotham");
filtroCidade.addCidade("Acre");

How can I get the vacancies where cities are the same as the attribute cidades class FiltroCidade?

Answer 1

With Java 8 you can solve using expression lambda to filter only the records in which the city is contained within the array city filter.

List<VagaEmprego> encontradas = vagas
        .stream()
        .filter(p -> filtroCidade
                .getCidades()
                .contains(p.getCidade()))
        .collect(Collectors.toList());

---

From the Java 5 you can use the predicate method.

According to Article Filtering Results (Predicates) - Java 8

... Methods that perform element evaluation are known as predicates, which in Java is represented by the class Predicate and contains the filter method...

import java.util.ArrayList;
import java.util.Collection;

public interface Predicado<T> {

  boolean aplicar(T tipo);

  public static <T> Collection<T> filtrar(Collection<T> colecao, Predicado<T> predicado) {
    Collection<T> resultado = new ArrayList<>();

    for (T elemento : colecao) {
      if (predicado.aplicar(elemento)) {
        resultado.add(elemento);
      }
    }

    return resultado;
  }
}

And using:

Predicado<VagaEmprego> predicado = new Predicado<VagaEmprego>() {
  public boolean aplicar(VagaEmprego vaga) {
    return filtroCidade.getCidades().contains(vaga.getCidade());
  }
};

Collection<VagaEmprego> encontradas = Predicado.filtrar(vagas, predicado);

---

In earlier versions you can filter as follows:

List<VagaEmprego> encontradas = new ArrayList<>();

for (VagaEmprego vaga : vagas) {
  if (filtroCidade.getCidades().contains(vaga.getCidade())) {
    encontradas.add(vaga);
  }
}