Boa noite.
Estou procurando alternativas para realizar iterações em ArrayLists que consumam o mínimo de memória. porque o meu programa está travando. Eu lí que as iterações em Collections são extremamente mais rápidas e consomem menos memória. Alguém tem alguma informação a respeito?
A iteração por si só não deveria influenciar no consumo de memória.
Dependendo da forma como você implementa suas iterações, elas podem ser um pouco mais lentas.
O que você faz nestas iterações? Posta o seu código e mostra onde está travando.
Ola Andre, tudo ok?
Me perdoe, mas tenho que negar sua afirmação! Que eu saiba, iterações simples em qualquer tipo de collections não consome memoria não. Tenho milhares funcionando ha anos com até com milhares objetos dentro. De vários motivos possíveis de lentidão de uma solução java, dificilmente quase nunca seria uma iteração. Vc esta se baseando em que ?
Como os colegas já disseram, talvez não seja a iteração, mas a lógica que existe dentro dela.
O que posso acrescentar é: avalie a possibilidade de alterar a lógica nas iterações, substituir a coleção por map e tentar identificar qual o gargalo real.
certo. bom, para ser sincero eu ainda estou aprendendo, por isso eu não tenho o conhecimento suficiente para afirmar se foi um problema de iteração. mas o que é certo é que o meu programa estava funcionando lindamente até que eu resolvi implementar um código de classificação entre arraylists como rotina. depois dessa implementação a velocidade começou a avacalhar. eis aqui o código:
(eu sei que provavelmente a implementação das iterações está complexa, mas ela é necessária)
public void classify() {
if(!fewdays.isEmpty())
{
ArrayList up = new ArrayList();
ArrayList down = new ArrayList();
ArrayList memvoid = new ArrayList();
//caso 0.
for(brick temp: fewdays)
{
if(temp.status != null)
{
if(temp.time > 2)
{
temp.time = 0;
memory.add(temp);
memvoid.add(temp);
}
else
{
temp.time++;
}
}
else //seja lá qual for a classificação (condição de exclusão)
{
if(temp.time > 2)
{
temp.time = 0;
memory.add(temp);
memvoid.add(temp);//o que ele está fazendo aqui? ele já foi qualificado.
}
else
{
temp.time++;
}
}
}
fewdays.removeAll(memvoid);
memvoid.clear();
brick middle = new brick();
//caso 1. (classificação qualificada)
for(brick temp : fewdays)
{
if(temp.special && temp.sizeone > 0) //(O)<---|Passagem secreta|
{
if(temp.status.equalsIgnoreCase("right"))
{
right.add(temp);
}
if(temp.status.equalsIgnoreCase("left"))
{
left.add(temp);
}
}
else//(O)
{
if(roof.isEmpty())
{
temp.status = "middleroof";
roof.add(temp);
}
else
{
if(temp.density > middle.density)
{
roof.add(temp);
middle = temp;//(O)
}
else
{
temp.status = "roof";
roof.add(temp);
}
}
}
}
if(temp.density > middle.density)
{
middle = temp;//(O)
}
}
if(roof.isEmpty())
{
middle.status = "middleroof";
memvoid.add(middle);
}
else
{
for(brick temp : roof)
{
if(temp.status.equalsIgnoreCase("middleroof"))
{
if(middle.density > temp.density)
{
temp.status = "roof";
middle.status = "middleroof";
memvoid.add(middle);
}
}
else
{
if(middle.density >= temp.density)
{
middle.status = "roof";
memvoid.add(middle);
}
else
{
middle.status = "border";
}
}
}
}
middle.addAll(memvoid);
memvoid.clear();
brick middlw = new brick();
//caso 2.
for(brick temp : fewdays)
{
/*
* Essa verificação é necessária para não misturar os classificados
*/
if(temp.status == null)
{
if(temp.low - temp.high >= 0)
up.add(temp);
else
down.add(temp);
}
}
//caso 2.1
for(brick temp : up)
{
if((temp.low - temp.high > middlw.low - middlw.high))
{
middlw = temp;
}
}
if(floor.isEmpty())
{
middlw.status = "floormiddle";
memvoid.add(middlw);
}
else
{
for(brick temp : floor)
{
if(temp.status != null)
{
if(temp.status.equalsIgnoreCase("floormiddle"))
{
if((middlw.low - middlw.high) > (temp.low - temp.high))
{
middlw.status = "floormiddle";
temp.status = "floor";
memvoid.add(middlw);
}
}
else
{
if((middlw.low - middlw.high) >= (temp.low - temp.high)) {
middlw.status = "floor";
memvoid.add(middlw);
}
else
{
middlw.status = "border";
}
}
}
}
}
floor.addAll(memvoid);
memvoid.clear();
brick middlq = new brick();
//caso 2.2.
for(brick temp : down)
{
if((temp.low - temp.high) < (middlq.low - middlq.high))
{
middlq = temp;
}
}
if(outside.isEmpty())
{
middlq.status = "highest";
memvoid.add(middlq);
}
else
{
for(brick temp : outside)
{
if(temp.status != null)
{
if(temp.status.equalsIgnoreCase("highest"))
{
if((middlq.low - middlq.high) < (temp.low - temp.high))
{
middlq.status = "highest";
temp.status = "high";
memvoid.add(middlq);
}
}
else
{
if((middlq.low - middlq.high) <= (temp.low - temp.high))
{
middlq.status = "high";
memvoid.add(middlq);
}
else
{
middlq.status = "air";
}
}
}
}
}
outside.addAll(memvoid);
memvoid.clear();
setTime();
System.gc();
}
Galera, eu já descobri o porque eu achei que estava travando. na verdade é porquê o java dá preferencia aos processos que necessitam de memória. e como o meu programa tem a parte gráfica rodando ao mesmo tempo a parte gráfica ficou em lag. mas a velocidade do processamento está intacta. de qualquer maneira, valeu.
O mais correto é que qualquer processamento de dados sejam feitos em uma Thread separada da Thread utilizada pela UI independente de tecnologia.
E o array list levando a culpa em…kkkkk