Estou utilizando o comando remove para remover alguns elementos da minha lista, porem por mais que faça um for por índice do elemento, eu não consigo apagar todos os elementos da lista, basicamente, metade dos elementos ainda permanecem.
for(int i=0; i<solucoes2.size(); i++ )
{
solucoes2.remove(i);
}
o comando solucoes2.clear() limpa a lista, porem eu necessito de apagar os elementos por índice, e sinceramente não sei o que está acontecendo.
Após o solucoes2.remove(i), faça um i--
Não deu certo ;/ …
Por que você precisa remover os elementos pelo índice? Se você está removendo todos, não dá na mesma que usar o clear()?
De todo modo, se solucoes2 é um List (ArrayList/LinkedList), seu problema é que uma remoção no começo da lista altera a posição de todos os demais itens. Para contornar isso, um truque é fazer a remoção do fim pro começo. Algo como:
for(int i=solucoes2.size()-1; i<=0; i--)
{
solucoes2.remove(i);
}
Abraço;
Primeiramente eu não quero remover todos elementos, quero remover os elementos pelo indice justamente porque necessito eliminar alguns especificos e outros que vao ficar duplicados, de qualquer modo obrigado pelo código, tive que fazer uma pequena correção ali para
i>=0
mas funcionou perfeitamente, abç.
Obrigado pela explicação tambem!
Ah, sim. Fiz de cabeça e esqueci de ajustar essa parte.
Abraço.
Posta o seu código completo.
O problema que estava acontecendo é o que o TerraSkill falou mesmo, após remover um elemento no inicio da lista, toda as outras posições estavam sendo realocadas, eu cheguei até testar no main separadamente essa parte do codigo pra ver problema, não tem tanta necessidade eu acho mas ta ai o codigo:
import java.util.ArrayList;
import java.util.stream.Collectors;
import java.util.Collections;
import java.util.List;
import java.util.Iterator;
import entidades.Nsga;
import entidades.P;
public class Main
{
public static void main(String[] args)
{
Nsga nsga = new Nsga(10,2);
System.out.println("Tamanho da populacao |N|: "+ nsga.getN());
System.out.println("Numero de funcoes objetivo |F|: "+ nsga.getF());
nsga.exec(true);
/*
int k=0;
List<Double> a = new ArrayList<>();
List<Double> b = new ArrayList<>();
List<Double> c= new ArrayList<>();
List<Double> d= new ArrayList<>();
List<Double> e= new ArrayList<>();
List<Double> f= new ArrayList<>();
List<P> solucoes = new ArrayList<P>();
List<P> solucoes2 = new ArrayList<P>();
List<List<Double>> fas = new ArrayList<List<Double>>();
List<Double> fs = new ArrayList<Double>();
P p1 = new P(10,2);
P p2 = new P(10,2);
P p3 = new P(10,2);
P p4 = new P(10,2);
P p5 = new P(10,2);
a.add(123.553);
a.add(4123.553);
a.add(2123.4553);
a.add(923.3453);
a.add(10.3453);
a.add(200.8453);
a.add(103.4453);
a.add(2.8453);
a.add(70.3453);
a.add(90.8453);
b.addAll(a);
p1.addF(a.get(0));
p1.addF(a.get(1));
p2.addF(a.get(2));
p2.addF(a.get(3));
p3.addF(a.get(4));
p3.addF(a.get(5));
p4.addF(a.get(6));
p4.addF(a.get(7));
p5.addF(a.get(8));
p5.addF(a.get(9));
solucoes.add(p1);
solucoes.add(p2);
solucoes.add(p3);
solucoes.add(p4);
solucoes.add(p5);
b.sort(null);
System.out.println(solucoes);
System.out.println("\na: ");
System.out.println(a);
System.out.println();
System.out.println("b: ");
System.out.println(b);
System.out.println();
for(int i=0; i<solucoes.get(i).getF().size(); i++) // até o numero de funcoes objetivo: 2
{
for(int j=0; j<solucoes.size(); j++) // até o numero de solucoes: 5
{
fs.add(solucoes.get(j).getF().get(i));
}
fs.sort(null);
fas.add(fs);
fs = new ArrayList<Double>();
}
System.out.println("Solucoes: ");
System.out.println(solucoes);
System.out.println("\nfas");
System.out.println(fas);
System.out.println();
for(k=0; k<solucoes.get(k).getF().size(); k++)
{
for(int i=0; i<solucoes.size(); i++)
{
for(int j=0; j<solucoes.size(); j++)
{
if(solucoes.get(j).getF().get(k).equals(fas.get(k).get(i)))
{
System.out.println(solucoes.get(j));
solucoes2.add(solucoes.get(j));
break;
}
}
}
}
Double min=Double.MAX_VALUE;
Double max=Double.MIN_VALUE;
for(int j=0; j<solucoes.get(j).getTamF(); j++)
{
for(int i=0; i<solucoes.size(); i++)
{
if(solucoes2.get(solucoes.size()*j + i).getF().get(j)<min)
min = solucoes2.get(solucoes.size()*j + i).getF().get(j);
if(solucoes2.get(solucoes.size()*j + i).getF().get(j)>max)
max = solucoes2.get(solucoes.size()*j + i).getF().get(j);
}
for(int i=0; i<solucoes.size(); i++)
{
if( (i+solucoes.size()*j ) == (0+solucoes.size()*j) || (i+solucoes.size()*j)==(solucoes.size()*j+solucoes.size()-1))
solucoes2.get(solucoes.size()*j+i).setDist(Double.POSITIVE_INFINITY);
else
{
int posicao = solucoes.size()*j+i;
Double di = solucoes2.get(posicao).getDist();
Double sucessor = solucoes2.get(posicao+1).getF().get(j);
Double antecessor = solucoes2.get(posicao-1).getF().get(j);
Double distancia = (sucessor - antecessor) /(max-min);
System.out.println("\nPosicao= "+posicao);
System.out.println(sucessor +" - "+ antecessor);
System.out.println("___________________");
System.out.println(max+ " - "+ min);
System.out.printf("\ndi= "+di +", Distancia: %f\n\n", distancia);
//
solucoes2.get(posicao).setDist(di+distancia);
}
}
}
//solucoes.clear();
for(int i=solucoes2.size()-1; i>=solucoes.size(); i--)
{
solucoes2.remove(i);
}
//solucoes.addAll(solucoes2.stream().distinct().collect(Collectors.toList()));
Collections.sort(solucoes2);
//System.out.println(solucoes);
System.out.println(solucoes2);
}
*/
}
}
Sim, por isso que eu tinha recomendado você fazer um i-- após o remove.
Imagino que você pôs o i-- no local errado:
Minha ideia era fazer assim:
for (int i = 0; i < solucoes.size(); i++) {
solucoes2.remove(i--);
}
Ou assim, pra ser mais legível:
for (int i = 0; i < solucoes.size(); i++) {
solucoes2.remove(i);
i--;
}kkkkkkkk eu coloquei de todos jeitos possiveis, nao deu certo nao.
O que não deu certo? Qual erro deu?