Ajuda com ArrayList

[razael]

Pessoal…to precisando criar um metodo que divida um arraylist em celulas de um tamanho determinado , depois disso fazer a media dos elementos e inserir novamente na lista.
exemplo.

[1,1,2,3,3,3,4,5,5,7]
digamos que eu queira dividir em celulas de 3 elementos
teriamos [1,1,2/,3,3,3/4,5,5,7] a ultima celula pode ter mais elementos ou menos caso nao seja exata a divisao …
depois disso somariamos o resultado de cada celula e dividiramos pelo numero de celular ou seja 1+1+2/3 = 1,3 3+3+3/3 = 3 …depois iriamos re-inserir o resultado na lista [1.3,1.3,1.3/3,3,3/5.3,5.3,5.3,5.3]
como sou iniciante em java to meio enrolado…

estava tentando algo do tipo

while (rs.next())
{
// Recupera a entrada

			double num = rs.getDouble(1);
			lista.add(num);
					
		}
		Collections.sort(lista);
		//textResult.append(lista);
		int num = lista.size();
		int qtd_celulas = num/n_celulas;
		double soma_lista=0;
		double result_lista=0;
		int last_element=0;
		int i=0;
		int c=0;
		int d=0;
		
		for(c=1;c<=qtd_celulas;c++)
		{
			for(i=0;i<qtd_celulas;i++)
			{
				soma_lista = soma_lista+lista.get(i+last_element);
			}
			
			last_element=qtd_celulas*c;
			result_lista=soma_lista/qtd_celulas;
			//lista.add(c+last_element,result_lista);
			textResult.append(result_lista);
		}
		//textResult.append(lista);

mas como nao sei manipular listas direito nao esta funcionando…alguem poderia ajudar?

[fcoury]

razael,

Não sei se entendi o seu problema direito. Pelo que eu entendi é o seguinte:

Você tem um array de inteiros de um tamanho qualquer. Depois você diz de quantos em quantos quer agrupar, correto? Daí, você tira as médias de cada um dos agrupamentos e, por fim, substitui os elementos de cada um dos agrupamentos pela média. Uma observação é que, se a divisão do número de elementos na matriz pelo número de elementos no agrupamento não for inteira, acumulamos o resto no último agrupamento. É isso?

Demorou, mas fiz esse código, veja se é isso:

package com.testing.array;

public class ArrayAvgTest {
	public static void main(String[] args) {
		int[] array = new int[] { 1, 1, 2, 3, 3, 3, 4, 5, 5, 7 };
		dumpIntArray(array);
		dumpArray(makeAvgArray(array, 3));
	}
	
	public static void dumpArray(float[] floats) {
		String dump = "";
		for (float f : floats) {
			dump += f + ", ";
		}
		System.out.println(dump);
	}
	
	public static void dumpIntArray(int[] floats) {
		String dump = "";
		for (int f : floats) {
			dump += f + ", ";
		}
		System.out.println(dump);
	}
	
	public static float[] makeAvgArray(int[] array, int groupSize) {
		float[] ret = new float[array.length];
		
		// número de grupos = tamanho do array / tamanho do grupo
		int groupCount = array.length / groupSize;
		
		// resto da divisão acima
		int remain = array.length % groupSize;
		
		// tamanho do ultimo grupo = tamanho do grupo + resto da divisão
		int lastGroupSize = groupSize + remain; 
		
		System.out.println("Groups: " + groupCount);
		System.out.println("Last group will have: " + lastGroupSize);
		
		// posição atual no array
		int currentPosition = 0;
		while (true) {
			int sum = 0;
			int count = 0;
			int initialPos = currentPosition;

			// varre todos os elementos deste grupo
			for (int i = 0; i < groupSize; i++) {
				sum += array[currentPosition + i];
				count++;
			}
			currentPosition += groupSize;
			
			// verifica se tem elementos sobrando no final, para manter nesse grupo
			if (currentPosition + groupSize >= array.length) {
				for (int i = currentPosition; i < array.length; i++) {
					sum += array[i];
					count++;
					currentPosition++;
				}
			}
			
			// tira a média e coloca no resultado
			for (int i = initialPos; i < currentPosition; i++) {
				ret[i] = (float) sum / (float) count;
			}
			
			// se acabou, sai
			if (currentPosition >= array.length) {
				break;
			}
		}
		
		return ret;
	}
}

[thokk]

Consideremos as seguintes implementações com a finalidade de percorrer um array , um Vector e um ArrayList…

public void iterateArray(int[ ] ar){
int size = ar.length;
int j;
for(int i = 0 ; i < size; i++){
j = ar[i];
}
}

public void iterateVector(Vector vec){
int size = vec.size( );
Object j;
for (int i = 0; i< size; i ++){
j = vec.get(i);
}
}

public void iterateArrayList(ArrayList al){
int size = al.size();
Object j;
for(int i = 0; i < size; i ++) {
j = al.get(i);
}
}

Muitos programadores usam a classe Vector como default para operações
simples, pois é muito conveniente e simples de se usar. Um array difere
de um Vector de várias maneiras, fundamentalmente em desempenho. Por
exemplo, o método iterateArray, escrito acima é cerca de 40 vezes mais
rápido que o método iterateVector. IterateVector é ainda mais lento se
usar Enumeration ou Iterator para a percorrer a mesma estrutura de dados.

Já quanto a classe ArrayList utilizada no método iterateArrayList,
podemos dizer que há um ganho substancial de velocidade comparada ao uso
de Vector, mas não o bastante se comparada com a velocidade provida pelo
uso de arrays. O método iterateArrayList é quase 4 vezes mais rápido
que iterateVector, mas iterateArray ainda é quase 11 vezes mais rápido
que iterateArrayList.

Com isso, você deveria usar algo que não seja um array? Vector e
ArrayList são muito úteis, pois são redimensionados automaticamente
quando são incluídos mais objetos que o seu tamanho atual pode acomodar.
Entretanto, paga-se caro por tal recurso. Essas classes são
implementadas em termos de um array e caso suas instâncias forem
redimensionadas, um novo array é criado e tudo é copiado do array antigo
para o novo. Tudo isso para a inclusão de um novo objeto.

Outro efeito colateral que pode não ser óbvio quando trabalhando com as
classes Vector e ArrayList é quando ocorre a remoção de um elemento de
suas instâncias. Sempre que um elemento é removido deles, cada um dos
outros itens em um índice maior que o elemento removido é movido para
ter um índice um a menos que tinha antes da remoção. Esta é uma operação
sem dúvida dispendiosa.

Portanto, dadas as implicações de desempenho de Vector e ArrayList ,
considere o uso de um array no código crítico para o desempenho. Se você
exigir a funcionalidade de um Vector, mas não seu sincronismo, use um
ArrayList. Use Vector somente quando você exigir sua funcionalidade e
seu sincronismo inerente.

Ainda que você esteja lidando com uma quantidade de dados variável, isso
não justifica totalmente o uso de um ArrayList ou Vector. Se você não
estiver certo quanto ao número de elementos que precisa armazenar,
poderá criar um array grande o suficiente para conter a sua maior
possibilidade. Isso poderia desperdiçar memória em casos médios, mas as
vantagens no desempenho podem ser maiores que os custos de memória.

[razael]

Coury , muito obrigado cara…ta certinho…
so por um pequeno detalhe

if (currentPosition + groupSize >= array.length) { --> deveria ser > e nao >=

valeu mesmo…me ajudou mto
seria abusar mto te pedir ajuda em outro metodo (muito similar a esse)
?

obrigado

[fcoury]

if (currentPosition + groupSize >= array.length) { --> deveria ser > e nao >=

Não, é maior igual mesmo. Isso porque em um array de tamanho 7 por exemplo os índices vão de 0 à 6, entendeu?

seria abusar mto te pedir ajuda em outro metodo (muito similar a esse)
?

Claro que não, manda ver… Ah! E não esquece de avaliar

[razael]

Claro…como eu te avalio?

Bom…o outro problema e bem parecido…

[1,1,2,3,3,3,4,5,5,7]
digamos que eu queira dividir em celulas de 3 elementos
teriamos [1,1,2/,3,3,3/4,5,5,7] a ultima celula pode ter mais elementos ou menos caso nao seja exata a divisao … (igual ao outro)
em seguida consideramos os extremos das celulas ex. 1o celula (1 extremo inicial , 2 extremo final) , 2o (3 extremo inicial , 3 extremo final) , 3o celula (4 extremo inicial e 7 extremo final)…
entao calculamos a distancia de cada valor em relacao aos extremos de cada celula , o valor original e substituido pelo valor do extremo mais proximo gerando o novo conjunto de dados…
ex.
1o celula , distancia do 1o elemento da celula ao extremo inicial (1-1=0)
distancia do 1o elemento da celula ao extremo final (1-2=1) , como o extremo mais proximo e o inicial entao o valor que substituimos e o proprio um…isso e feito para todos os elementos.

3o celula por exemplo

distancia do 1o elemento ao extremo inicial (4-4=0) ao extremo final (4-7=-3) entao temos que substituir pelo proprio 4 , 2o elemento (5-4=1) e (5-7=-2) substituimos por 4 , 3o elemento (5-4=1) e (5-7=-2) entao substitui por 4 , e (7-4=3) e (7-7=0) entao substituimos por zero…

no exemplo teriamos depois do procedimento o seguinte

original -> [1,1,2/,3,3,3/4,5,5,7]

depois -> [1,1,2/,3,3,3/4,4,4,7]

esse e mais chatinho…se puder dar uma luz…

abraco e obrigado novamente.

[razael]

[fcoury]

Acho que resolvi. Dá uma olhada:

package com.testing.array;

public class ArrayTest {
	public static void main(String[] args) {
		int[] array = new int[] { 1, 1, 2, 3, 3, 3, 4, 5, 5, 7 };
		dumpIntArray(array);
		dumpIntArray(makeDistanceArray(array, 3));
	}
	
	
	public static void dumpArray(float[] floats) {
		String dump = "";
		for (float f : floats) {
			dump += f + ", ";
		}
		System.out.println(dump);
	}
	
	public static void dumpIntArray(int[] floats) {
		String dump = "";
		for (int f : floats) {
			dump += f + ", ";
		}
		System.out.println(dump);
	}
	
	public static int[] makeDistanceArray(int[] array, int groupSize) {
		int[] ret = new int[array.length];
		
		// posição atual no array
		int currentPosition = 0;
		while (true) {
			// calcula as posições iniciais e finais deste grupo
			int initialPos = currentPosition;
			int finalPos = currentPosition + groupSize - 1;
			
			// verifica se tem elementos sobrando no final, para manter nesse grupo
			if ((finalPos+1) + groupSize >= array.length) {
				for (int i = finalPos; i < array.length; i++) {
					finalPos++;
				}
				finalPos--;
			}

			// primeiro e último elementos do grupo
			int firstElement = array[initialPos];
			int lastElement = array[finalPos];

			// percorre o grupo
			for (int i = initialPos; i <= finalPos; i++) {
				// verifica a distancia absoluta do item para o primeiro e ultimo elementos
				int distanceFromFirst = Math.abs(array[i] - firstElement);
				int distanceFromLast = Math.abs(array[i] - lastElement);

				// substitui pela menor distancia
				if (distanceFromFirst < distanceFromLast) {
					ret[i] = firstElement;
				}
				else {
					ret[i] = lastElement;
				}
			}
			
			currentPosition = finalPos + 1;
			
			// se acabou, sai
			if (finalPos >= array.length-1) {
				break;
			}
		}
		
		return ret;
	}
}

[razael]

valeu!!!
funcionou perfeito
vc e O CARA!

abracos