int[] arrayHashing = new int[1000];for (int t = 0; t < 1000; t++) {
arrayHashing[t] = 0;
}
Existe uma forma mais rápida de limpar, “zerar”, um array?
Bom, no caso ele já começa inicializado né, por ser de int que é um tipo primitivo.
Mas se quiser limpar um que não esteja zerado, esse é o jeito. Não tem como fazer um algoritmo melhor, eu imagino.
Qualquer índice que você não passe pode ser um índice que precisaria ser limpado.
Você pode instanciar um novo array também. Tudo vai depender do que é melhor pra você, caso precise gerenciar bem a memória
tente isso:
arrayHashing.clear();
sinceramente nao conheço uma forma mais rapida de limpar um array
mas por curiosidade… porque voce quer limpar um array mais rapido ?
um array de 1000 posiçoes ele zera em menos de meio segundo, voce quer mais rapido do que isso ?
[quote=steveVai]tente isso:
arrayHashing.clear();[/quote]Posta um código que funciona com isso ae?
[quote=yfalbino]sinceramente nao conheço uma forma mais rapida de limpar um array
mas por curiosidade… porque voce quer limpar um array mais rapido ?
um array de 1000 posiçoes ele zera em menos de meio segundo, voce quer mais rapido do que isso ?[/quote]
Tenho que fazer uma questão em até 1 seg cara… Quanto mais demorar a questão, menor vai ser minha nota! Abraços! E por curiosidade tb! 
Então instancie um array novo.
[quote=mi.rodrigues][quote=yfalbino]sinceramente nao conheço uma forma mais rapida de limpar um array
mas por curiosidade… porque voce quer limpar um array mais rapido ?
um array de 1000 posiçoes ele zera em menos de meio segundo, voce quer mais rapido do que isso ?[/quote]
Tenho que fazer uma questão em até 1 seg cara… Quanto mais demorar a questão, menor vai ser minha nota! Abraços! E por curiosidade tb! :P[/quote]
Eu daria a seguinte resposta:
[quote]arrayHashing = new int[1000];[/quote] // a antiga vai pro espaço e a nova tá zerada lindona! .
entendo isso, mas a unica forma de limpar um array que eu conheço é essa
a função clear() nao existe mais nas plataformas java EE ou java SE, posso estar errado, mas eu acredito que so tenha essa forma de limpar um array
[quote=Hebert Coelho][quote=mi.rodrigues][quote=yfalbino]sinceramente nao conheço uma forma mais rapida de limpar um array
mas por curiosidade… porque voce quer limpar um array mais rapido ?
um array de 1000 posiçoes ele zera em menos de meio segundo, voce quer mais rapido do que isso ?[/quote]
Tenho que fazer uma questão em até 1 seg cara… Quanto mais demorar a questão, menor vai ser minha nota! Abraços! E por curiosidade tb! :P[/quote]
Eu daria a seguinte resposta:
Opa! Valeu!
[quote=Hebert Coelho][quote=mi.rodrigues][quote=yfalbino]sinceramente nao conheço uma forma mais rapida de limpar um array
mas por curiosidade… porque voce quer limpar um array mais rapido ?
um array de 1000 posiçoes ele zera em menos de meio segundo, voce quer mais rapido do que isso ?[/quote]
Tenho que fazer uma questão em até 1 seg cara… Quanto mais demorar a questão, menor vai ser minha nota! Abraços! E por curiosidade tb! :P[/quote]
Eu daria a seguinte resposta:
é isso ae… ou usa um ArrayList… depois da um clear()
[quote=yfalbino]entendo isso, mas a unica forma de limpar um array que eu conheço é essa
a função clear() nao existe mais nas plataformas java EE ou java SE, posso estar errado, mas eu acredito que so tenha essa forma de limpar um array[/quote]so tenha essa forma? Qual forma?
o clear() que não existe? Desculpe a pergunta mas… já existiu? O java geralment não apaga métodos apenas os marca como deprecated.
[quote=Hebert Coelho]so tenha essa forma? Qual forma?
o clear() que não existe? Desculpe a pergunta mas… já existiu? O java geralment não apaga métodos apenas os marca como deprecated.[/quote]
Bom, eu comecei a desenvolver com Java 6 então não sei.
Eu sei que ArrayList tem um método clear, mas advinha o que ele faz: public void clear()
{
this.modCount += 1;
for (int i = 0; i < this.size; ++i)
this.elementData[i] = null;
this.size = 0;
}
[quote=mi.rodrigues]int[] arrayHashing = new int[1000];
for (int t = 0; t < 1000; t++) {
arrayHashing[t] = 0;
}
Existe uma forma mais rápida de limpar, “zerar”, um array? [/quote]
Tem.
arrayHashing = new int[1000];simplesmente construa outro.
[quote=Rodrigo Sasaki][quote=Hebert Coelho]so tenha essa forma? Qual forma?
o clear() que não existe? Desculpe a pergunta mas… já existiu? O java geralment não apaga métodos apenas os marca como deprecated.[/quote]
Bom, eu comecei a desenvolver com Java 6 então não sei.
Eu sei que ArrayList tem um método clear, mas advinha o que ele faz: public void clear()
{
this.modCount += 1;
for (int i = 0; i < this.size; ++i)
this.elementData[i] = null;
this.size = 0;
}[/quote]
ArrayList é conhecido por não ter uma implementação muito eficiente. Se a eficiencia for um problema, é melhor criar seu arraylist baseado no arraylist e sobreescrevendo algumas coisas… (ou fazer direto a partir de AbstractList)
Caso o objetivo seja limpara para reuso e o ponto for eficiência você pode manter o que é chamado de bitmap, onde em uma sequencia de bits os setados estão “sujos” e os zerados “limpos”, o custo para zerar uma estrutura usando bitmap é mínimo.
Exemplo:
Array de 1024 posicoes
bitmap de um 1024/8 bytes
para zerar basta 1024/8 sets para 0
no caso isso é para 8 bits, se você tem uma arquitetura de 64 bits então isso cai ainda mais pode fazer 1024/64 sets para 0, creio que o tipo seria long int, ou seja com um outro array de 1024/64 long ints você abstrai o uso do array real.
Com um pouco mais de experiência pode até continuar a sub-representação bitmap para blocos maiores
Está aí o teste isso pode variar, mas a saída aqui foi a seguinte:
[size=18]Limpar o bitmap:[color=darkblue]4[/color]
Limpar o array:[color=oranje]5[/color]
Recriar o bitmap:[color=blue]0[/color]
Recriar o array:[color=red]16[/color]
[/size]
import java.util.BitSet;
import java.util.Random;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
final int ARRAY_SIZE = 10000000;
int []arrayHashing = new int[ARRAY_SIZE];
Random r = new Random(System.currentTimeMillis());
BitSet bitmap = new BitSet(ARRAY_SIZE);
for (int i = 0; i < ARRAY_SIZE; ++i) {
arrayHashing[i] = r.nextInt();
bitmap.set(i);
}
long startTime = System.currentTimeMillis();
bitmap.clear();
long endTime = System.currentTimeMillis();
System.out.print("Limpar o bitmap:");
System.out.println( endTime - startTime );
startTime = System.currentTimeMillis();
for (int i : arrayHashing)
i = 0;
endTime = System.currentTimeMillis();
System.out.print("Limpar o array:");
System.out.println( endTime - startTime );
startTime = System.currentTimeMillis();
bitmap = new BitSet(ARRAY_SIZE);
endTime = System.currentTimeMillis();
System.out.print("Recriar o bitmap:");
System.out.println( endTime - startTime );
startTime = System.currentTimeMillis();
arrayHashing = new int[ARRAY_SIZE];
endTime = System.currentTimeMillis();
System.out.print("Recriar o array:");
System.out.println( endTime - startTime );
}
}Pode acreditar, recriar o array é mais lento que setar todos os valores! Quem diria, menos linhas de código não tem a ver com menos tempo.
com um array de tamanho 99999999 a diferença fica gritante:
Limpar o bitmap:8
Limpar o array:7
Recriar o bitmap:0
Recriar o array:355
e conforme o tamanho dos objetos (o tipo determina o tamanho) que você guarda a diferença pesa ainda mais para o uso do bitmap.
Ainda sim creio que o BitSet não foi otimizado para o uso que sujeri
Uma otimização direta poderia ser feita com outros níveis de blocos onde um novo bitmap e outro e assim por diante, representam aglomerados maiores de dados.
Um exemplo simples e rustico caso o único interesse seja limpar por completo um array:
boolean limpo = true;// o array é inicializado limpo
long []arrayHashing = new long[ARRAY_SIZE];
boolean limpo = false; //suja o array
limpo = true; //limpa o arraykk parece piada mais o custo é insignificante