Preencher uma terceira lista com os elementos diferentes entre a primeira e a segunda lista

1. Copie a lista allDocuments para uma variável temporária:

   List temporaria = new ArrayList<>(allDocuments);
   

2. Remova de temporaria todos os elementos presentes em documentLaunch:

   temporaria.removeAll(documentsLaunch);
   

3. Defina newsDocuments:

   newsDocuments = new ArrayList<>(temporaria);
   

   ou

   newsDocuments = temporaria;
   

   ou qualquer outra coisa do gênero.

Para isso, você vai ter que sobrescrever os métodos equals e hashCode dos objetos contidos nas listas.

Fonte: https://docs.oracle.com/javase/8/docs/api/java/util/List.html#removeAll-java.util.Collection-

A remoção é feita com ciclos?’

Por baixo dos panos sim, por você não. A implementação de List que vai fazer o loop quando você chamar o removeAll. Você só precisa fazer isso mesmo, essas 3 linhas. Na verdade nem precisa da temporária, dá pra fazer direto assim:

newsDocuments = new ArrayList<>(allDocuments); // cria uma nova ArrayList com todos os elementos de allDocuments
newsDocuments.removeAll(documentsLaunch); // remove de newsDocuments todos os elementos presentes em documentsLaunch que estão também em newsDocuments

Calma fica aí cara vou montar isso… depois te dou um toque.

Exemplo:

public static void main(String[] args) {
    List<Integer> naturais = Arrays.asList(new Integer[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
    List<Integer> pares = Arrays.asList(new Integer[]{0, 2, 4, 6, 8});
    List<Integer> impares = new ArrayList<>(naturais);
    impares.removeAll(pares);
    System.out.println(impares);
}

estou a implementar…

Usando Java 8:

public static void main(String[] args) {
    List<Integer> naturais = Arrays.asList(new Integer[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
    List<Integer> pares = Arrays.asList(new Integer[]{0, 2, 4, 6, 8});
    List<Integer> impares = naturais.stream().filter(i -> !pares.contains(i)).collect(Collectors.toList());
    System.out.println(impares);
}

Vou reiniciar a máquina tive um erro no servidor cara java.lang.OutOfMemoryError: PermGen space

estou usando java 7

Não funciona cara

List allDocuments = fnContacorrenteFacade.findAll();

List documentsLaunch = ctLancamentoFacade.findAll();

List newsDocuments = new ArrayList<>(allDocuments);

newsDocuments.removeAll(documentsLaunch);

Estou a pensar em resolver isso com um join entre as tabelas na BD… o que achas?

O construtor ArrayList(Collection c) faz uma cópia rasa (só a referência) de todos os elementos contidos na coleção c. Se a coleção for muito grande, isso pode ser um problema. Uma maneira de aliviar um pouco isso é fazer você a lógica de cópia, evitando a cópia completa. Assim:

newDocuments = new ArrayList<>();
for (Document document : allDocuments) {
    if (!documentsLaunch.contains(document)) {
        newDocuments.add(document);
    }
}

Você sobrescreveu equals e hashCode no tipo que é contido na lista?

A única razão para o método removeAll não funcionar é uma implementação errada de equals e hashCode. Nesse caso, nem mesmo o contains vai funcionar, porque ele usa o equals.

Fonte: https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html#contains-java.lang.Object-

O metodo equals tá errado. Tá retornando true sem comparar os atributos do objeto, só testa se é null ou não. O hashCode tá errado também.

Tem bastante detalhe sobre isso aqui: http://stackoverflow.com/questions/27581/what-issues-should-be-considered-when-overriding-equals-and-hashcode-in-java

Esses métodos devem ser implementados com muito cuidado. Existe uma série de regras que devem ser levadas em conta, para que sejam implementados corretamente. Isso é assunto de certificação, inclusive hahahahah

Geralmente as IDE geram esses dois métodos para ti. Tem gente que é contra usar esse recurso, porque pode sair errado em alguns casos.

Vamos uma consulta usando join entre as tabelas CtLancamento e FnContacorrente trazendo todos os elementos da tabela FnContacorrente que não estejam na tabela CtLancamento as duas estão relacionadas… usando join como ficaria??

Sim o IDE gerou mesmo…

Alguns documentos nessa tabela já foram lançados, eu quero que após o lançamento de um documento eles já não estejam na tabela…

Selecção_015.png1012×333 25.1 KB

Você quer todas as contas que não têm um lançamento? Se o relacionamento é bidirecional, e
é @ManyToOne de Conta para Lancamento, você pode fazer algo como:

SELECT conta FROM FnContacorrente conta WHERE conta.lancamento IS NULL

Não, quero todos os documentos(FnContacorrente) que ainda não foram lançados(CtLancamento)…

Me diz qual a relação de FnContacorrente com CtLancamento, a cardinalidade do relacionamento. É 1-1, N-M, 1-N/N-1? Qual possui qual?

1:N, ou seja, uma documento está associado a um lançamento.

É 1:N ou 1:1? hahahahahaha

Algo como:

SELECT d FROM Documento d WHERE d.lancamento IS NULL

retorna todos os Documento que não estão associados a um lançamento.

Sim, eu relacionei dessa forma, o id do documento está na tabela lançamento… pego a patiri de uma combobox.

sim, vou tentar!

O IS NULL vai funcionar no caso de uma referência @*ToOne.

Se fosse uma @*ToMany, você poderia fazer algo assim:

SELECT d FROM Documento d WHERE d.lancamentos IS EMPTY

a tabela documento não tem como chegar em lançamento cara…

Mas não precisa estar. Quando você define um relacionamento de, nesse caso, Documento para Lancamento, ele pode ser definido com um relacionamento reverso. É para isso que serve o atributo mappedBy das anotações de relacionamento.

Vou dar um exemplo bem simples, você adapta pro teu caso:

Imagine que no DB temos assim:

Lancamento

• id_lancamento (chave primaria)
• id_documento (chave estrangeira, referencia Documento)

Documento

• id_documento(chave primaria)

Certo? Note que o dono do relacionamento é Lancamento, pois ele possui a chave estrangeira.

No Java:

class Lancamento {
    @Id
    private long idLancamento; 
    @OneToOne
    private Documento documento;
}

class Documento {
    @Id
    private long idDocumento
    @OneToOne(mappedBy = "documento")
    private Lancamento lancamento;
}

Quando você fizer uma query assim em JPQL:

SELECT lanc FROM Documento d JOIN FETCH d.lancamento lanc WHERE d.id :documento_id

Você vai acessar o lancamento a partir do documento, mesmo a tabela Documento não tendo a referência para Lancamento! Sacou? Isso funciona por causa dos mapeamentos nas entidades em java, utilizando a anotação @OneToOne (ou qualquer outra).

O JPA, por baixo dos panos, vai emitir uma query mais ou menos assim em SQL pro DB:

SELECT * FROM lancamento WHERE lancamento.id_documento = (id_do_documento);

Sim, mas neste caso como ficaria a query para me retornar todos os documentos que não foram lançados? Tudo o que você falou faz sentido mas não vejo a query… estou tentando aqui.

Na classe Lancamento, você tem uma referência para Documento, certo? (Me ajuda com os nomes, faz de conta que são esses). Você quer fazer referência ao Lancamento a partir de Documento, isso?

Pelo que eu entendi, falta uma referencia para Lancamento dentro da classe Documento. Isso é o que chamamos de relacionamento reverso. É aqui que você vai colocar o mappedBy para poder fazer a query que eu falei com JPQL.

Parece que você tem isso:

class Lancamento {
    @OneToOne
    private Documento varivelDoTipoDocumentoDentroDaClasseLancamento;
}

Mas em Documento, você não tem isso:

class Documento {
    //note que a string é o nome do atributo do tipo Documento na classe Lancamento, exatamente do mesmo jeito
    @OneToOne(mappedBy = "varivelDoTipoDocumentoDentroDaClasseLancamento") 
    private Lancamento lancamento;
}

Por isso você não consegue partir de Documento para Lancamento. Correto? Se for isso, basta você colocar o atributo Lancamento dentro da classe Documento, com a anotação @OneToOne, e com o mappedBy sendo igual ao nome do atributo dentro da classe Lancamento do tipo Documento (isso talvez tenha ficado confuso, olha o código que ajuda).

ok, vou acrescentar isso!

Alterei a nível de BD, criei uma relação entre as tabelas de 1:1, vou gerar novamente as Entity.

Testei, está trazer o inverso, ou seja, está trazer os documentos que foram lançados…

SELECT c FROM FnContacorrente c WHERE c.ctLancamento.idfnContacorrenteFnContacorrente.idfnContacorrente IS NOT NULL

O SÍMBOLO != não está funcionar… a ideia é trazer os diferentes que são os que ainda não foram lançados.

Tira o NOT, usa só

IS NULL