Stream Filter == List.get(index) does not compile

Question

I’m trying to create a Stream to filter a list of a class with several attributes. One of these attributes is repeated in other instances. I’m trying to filter these instance members to make a sum of one of the class attributes.

public class InsumoTratado {

private Long codigoComposicao;
private String textoCodigoComposicao;
private String descricaoComposicao;
private String unidadeComposicao;
private String tipoItem;
private Long codigoItem;
private String descricaoItemComposicao;
private String unidadeItem;
private double quantidadeComposicao;
private double valorUnitario;



public InsumoTratado() {
    }


public InsumoTratado(Long codigoComposicao, String textoCodigoComposicao, String descricaoComposicao, String unidadeComposicao, String tipoItem,
        Long codigoItem, String descricaoItemComposicao, String unidadeItem, double quantidadeComposicao,
        double valorUnitario) {
    super();
    this.codigoComposicao = codigoComposicao;
    this.textoCodigoComposicao = textoCodigoComposicao;
    this.descricaoComposicao = descricaoComposicao;
    this.unidadeComposicao = unidadeComposicao;
    this.tipoItem = tipoItem;
    this.codigoItem = codigoItem;
    this.descricaoItemComposicao = descricaoItemComposicao;
    this.unidadeItem = unidadeItem;
    this.quantidadeComposicao = quantidadeComposicao;
    this.valorUnitario = valorUnitario;
}


public Long getCodigoComposicao() {
    return codigoComposicao;
}


public void setCodigoComposicao(Long codigoComposicao) {
    this.codigoComposicao = codigoComposicao;
}

public String getTextoCodigoComposicao() {
    return textoCodigoComposicao;
}


public void setTextoCodigoComposicao(String textoCodigoComposicao2) {
    this.textoCodigoComposicao = String.valueOf((getCodigoComposicao()));
}


public String getDescricaoComposicao() {
    return descricaoComposicao;
}


public void setDescricaoComposicao(String descricaoComposicao) {
    this.descricaoComposicao = descricaoComposicao;
}


public String getUnidadeComposicao() {
    return unidadeComposicao;
}


public void setUnidadeComposicao(String unidadeComposicao) {
    this.unidadeComposicao = unidadeComposicao;
}


public String getTipoItem() {
    return tipoItem;
}


public void setTipoItem(String tipoItem) {
    this.tipoItem = tipoItem;
}


public Long getCodigoItem() {
    return codigoItem;
}


public void setCodigoItem(Long codigoItem) {
    this.codigoItem = codigoItem;
}


public String getDescricaoItemComposicao() {
    return descricaoItemComposicao;
}


public void setDescricaoItemComposicao(String descricaoItemComposicao) {
    this.descricaoItemComposicao = descricaoItemComposicao;
}


public String getUnidadeItem() {
    return unidadeItem;
}


public void setUnidadeItem(String unidadeItem) {
    this.unidadeItem = unidadeItem;
}


public double getQuantidadeComposicao() {
    return quantidadeComposicao;
}


public void setQuantidadeComposicao(double quantidadeComposicao) {
    this.quantidadeComposicao = quantidadeComposicao;
}


public double getValorUnitario() {
    return valorUnitario;
}


public void setValorUnitario(double valorUnitario) {
    this.valorUnitario = valorUnitario;
}


    
@Override
public String toString() {
    return "InsumoTratado [codigoComposicao=" + codigoComposicao 
            + ", descricaoComposicao=" + descricaoComposicao
            + ", unidadeComposicao=" + unidadeComposicao 
            + ", tipoItem=" + tipoItem 
            + ", codigoItem=" + codigoItem
            + ", descricaoItemComposicao=" + descricaoItemComposicao 
            + ", unidadeItem=" + unidadeItem
            + ", quantidadeComposicao=" + quantidadeComposicao 
            + ", valorUnitario=" + valorUnitario + "]";
}


@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((codigoComposicao == null) ? 0 : codigoComposicao.hashCode());
    return result;
}


@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    InsumoTratado other = (InsumoTratado) obj;
    if (codigoComposicao == null) {
        if (other.codigoComposicao != null)
            return false;
    } else if (!codigoComposicao.equals(other.codigoComposicao))
        return false;
    return true;
}

public class MainProgram {
public static void main(String[] args) throws JsonSyntaxException, JsonIOException, FileNotFoundException {

    //Declaração das Classes a serem utilizadas na aplicação principal
    
    Gson gson = new Gson();
    Formatador formatador = new Formatador();
    InsumoTratado iTratado = new InsumoTratado();
    List<InsumoTratado> ListaInsumos2 = new ArrayList<>();

    try {

        //Import do arquivo Json com os dados dos insumos e armazenamento dos valores em um array de dados no formato String
        Insumo[] insumo1 = gson.fromJson(new FileReader("C://Users//marco//OneDrive//Área de Trabalho//file.txt"),Insumo[].class);

        // Instanciação dos elementos coletados do arquivo Json e armazenamento em uma nova lista tratada, com dados tipo Long e String
        for (Insumo x : insumo1) {
            Long codigoComposicao = x.getCodigoComposicao();
            String textoCodigoComposicao = x.getTextoCodigoComposicao();
            String descricaoComposicao = x.getDescricaoComposicao();
            String unidadeComposicao = x.getUnidadeComposicao();
            String tipoItem = x.getTipoItem();
            Long codigoItem = Long.parseLong(x.getCodigoItem());
            String descricaoItemComposicao = x.getDescricaoItemComposicao();
            String unidadeItem = x.getUnidadeItem();
            Double quantidadeComposicao = formatador.converterVirgulaParaPonto((x.getQuantidadeComposicao()));
            Double valorUnitario = formatador.converterVirgulaParaPonto((x.getValorUnitario()));
            iTratado = new InsumoTratado(codigoComposicao, textoCodigoComposicao, descricaoComposicao,
                    unidadeComposicao, tipoItem, codigoItem, descricaoItemComposicao, unidadeItem,
                    quantidadeComposicao, valorUnitario);
            iTratado.setCodigoComposicao(codigoComposicao);
            iTratado.setTextoCodigoComposicao(textoCodigoComposicao);
            iTratado.setDescricaoComposicao(descricaoComposicao);
            iTratado.setUnidadeComposicao(unidadeComposicao);
            iTratado.setTipoItem(tipoItem);
            iTratado.setCodigoItem(codigoItem);
            iTratado.setDescricaoItemComposicao(descricaoItemComposicao);
            iTratado.setUnidadeItem(unidadeItem);
            iTratado.setQuantidadeComposicao(quantidadeComposicao);
            iTratado.setValorUnitario(valorUnitario);
            ListaInsumos2.add(iTratado);

        }

    } catch (IOException e) {
        e.printStackTrace();
    }

    //Filtro para remover valores repetidos de descricao dos Códigos de Composição
    List<Long> listIter = new ArrayList<>();
    List<Long> deDupStringList3 = new ArrayList<>();

    for (InsumoTratado y : ListaInsumos2) {
        y.getCodigoComposicao();
        listIter.add(y.getCodigoComposicao());
        deDupStringList3 = listIter.stream().distinct().collect(Collectors.toList());

    }

    Long index = deDupStringList3.get(0);
    Long index1 = deDupStringList3.get(1);
    Long index2 = deDupStringList3.get(2);
    Long index3 = deDupStringList3.get(3);
    Long index4 = deDupStringList3.get(4);

    
    //Filtro e construção da saída do arquivo no console
    Stream<InsumoTratado> st1 = ListaInsumos2.stream();
    Double total = st1.filter(p -> p.getCodigoComposicao().equals(index))

            .mapToDouble(p -> p.getValorUnitario() * p.getQuantidadeComposicao()).sum();

    System.out.println(ListaInsumos2.get(0).getCodigoComposicao().toString() + " "
            + ListaInsumos2.get(0).getDescricaoComposicao().toString() + " "
            + ListaInsumos2.get(0).getUnidadeComposicao().toString() + " " + String.format("%.2f", total));

}

I created this stream:

Stream<Insumo> st1 = lista.stream();
               st1.filter(p -> p.getCodigoComposicao() == "94793")
              .mapToDouble(p -> p.getValorUnitario() * p.getQuantidadeComposicao()).sum();

That one "94793" it’s like a key to the other elements, but when I try to put something like:

Stream<Insumo> st1 = lista.stream();
               st1.filter(p -> p.getCodigoComposicao() == List<Insumo>.getCodigo)
              .mapToDouble(p -> p.getValorUnitario() * p.getQuantidadeComposicao()).sum();


Stream<InsumoTratado> st2 = ListaInsumos2.stream();
        Double total2 = st2.filter(p -> p.getCodigoComposicao().equals(index1))
                .mapToDouble(p -> p.getValorUnitario() * p.getQuantidadeComposicao()).sum();

It only returns the last element of the list, not the sum of the values, such as the Stream previous makes.

I also tried using Filter.equals, but I can also only evaluate one item at a time. What I’m trying to implement is: Receive a list of indexes from a List and pass this index as a kind of key for the stream to iterate over the list to automatically calculate the sums of each of the tax bills I received initially.

How can I fix this?

---

I’m using a new approach, using two loops to get the values of a list that gives me the numbers of the bills, and I use them as a filter to calculate the sums.

List<Long> indexes = new ArrayList<>();

        indexes.add(94793L);
        indexes.add(98561L);
        indexes.add(87286L);
        indexes.add(88830L);
        indexes.add(88831L);

        double sum = 0;

        for (int j = indexes.indexOf(indexes.get(0)); j < indexes.size(); j++) {
            for (int i = 0; i < ListaInsumos2.size(); i++) {

                InsumoTratado insumo = ListaInsumos2.get(i);
                if (insumo.getCodigoComposicao().equals(indexes.get(j))) {

                    sum = (sum + insumo.getPrecoFinal());

I’m getting the values, but summed into a single variable. Is there any way to make this sum by filtering by index, too?

Answer 1

getCodigo is recovering a tax note code that came in an external file. This value will vary as there are several codes in a list