Limpar 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 ?

steveVai:

tente isso:

arrayHashing.clear();

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 ?

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.

mi.rodrigues:

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 ?

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

arrayHashing = new int[1000];

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

Hebert Coelho:

mi.rodrigues:

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 ?

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

Eu daria a seguinte resposta:

Opa! Valeu!

Hebert Coelho:

mi.rodrigues:

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 ?

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

Eu daria a seguinte resposta:

é isso ae… ou usa um ArrayList… depois da um clear()

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

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.

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; }

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?

Tem.

arrayHashing = new int[1000];

simplesmente construa outro.

Rodrigo Sasaki:

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.

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; }

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 array

kk parece piada mais o custo é insignificante

Explicando por que recriar o array demora mais:

A JVM precisa procurar um bloco contínuo de memória para alocar o espaço, e caso não conseguir, ela vai ativar um full garbage colector e desfragmentar o espaço de memória, movendo os objetos em memória até ela liberar espaço. Se mesmo assim não conseguir, aí ela atira um OutOfMemoryError.

Um grande problema em fazer benchmarks em java é que a jvm efetua várias otimizações ao executar.

Transforme, por exemplo, a criação do array num método, a limpeza do array em outro, e rode ambos num for, mil vezes antes de comparar os tempos.
Verá que a criação do array se torna muito mais rápido.

Não sei como utilizar um BitSet nesse caso seria vantajoso, já que você precisa armazenar inteiros e não bits.

Uma outra boa forma que pode ser aliada ao uso de mapas de representação binária é a organização de arrays em blocos contíguos distribuindo o custo em tempo de inclusão e remoção, ou a aplicação da técnica de tratamento de matrizes esparsas.

Uma estrutura inteligente combina as várias técnicas estruturais conforme a utilização.

Estou começando agora o estudo de Inteligência Artificial, mas creio sua aplicação deve ser bem interessante para otimização de bibliotecas atuais.