ArrayList nao adicionou os itens corretamente

Programação Java
#1

Criei uma classe hora e estou fazendo um array dessas horas, mas quando adiciono um item no ArrayList ele seta todos os itens anteriores com o valor do ultimo item. Por que isso está acontecendo? Alguem pode me ajudar?

aqui está o código:


public static ArrayList<Hora> selectInterval() {
		Hora horaInicio = Seccao.getCurrentUserTimeStart();
		Hora horaFim = Seccao.getCurrentUserTimeEnd();
		int intervalo = Seccao.getTempoAtendimento();
		ArrayList<Hora> intervalos = new ArrayList<Hora>();
		Hora horaAux = new Hora();
		if (intervalo > 1) {
			intervalos.add(horaAux);
			while (!CalculaHora.IsBigger(horaAux, horaFim)) {
				horaAux = CalculaHora.SomaHora(horaAux, intervalo);
				intervalos.add(horaAux);
			}
		}
		return intervalos;
	}

Exemplo:
[]
qnd adiciono a hora 10:00;
[10:00]

quando adionio a hora 8:00;
[8:00, 8:00]

quando adiciono a hora 12:00
[12:00, 12:00, 12:00]

quando adciono a hora 5:00
[5:00, 5:00, 5:00, 5:00]

quando adicono a hora 20:00
[20:00, 20:00, 20:00, 20:00, 20:00]

e assim por diante… quando na verdade a saida correta para a inserção desses valores nesta mesma ordem seria:
[10:00, 8:00, 12:00, 5:00, 20:00]

#2 
                horaAux = CalculaHora.SomaHora(horaAux, intervalo);

Como é a definição de SomaHora? (argh, declare métodos começando por minúsculas - você não está escrevendo programas em C#)

Dá a impressão que você retorna o mesmo objeto que recebe como parâmetro. Se for isso, então o seu arraylist estará contendo várias referências ao mesmo objeto.

#3

Cara, veja se assim fuinciona:

public static ArrayList<Hora> selectInterval() {   
        Hora horaInicio = Seccao.getCurrentUserTimeStart();   
        Hora horaFim = Seccao.getCurrentUserTimeEnd();   
        int intervalo = Seccao.getTempoAtendimento();   
        ArrayList<Hora> intervalos = new ArrayList<Hora>();   
        Hora horaAux = new Hora();   
        if (intervalo > 1) {   
            intervalos.add(horaAux);   
            while (!CalculaHora.IsBigger(horaAux, horaFim)) {   
                        Hora novahora= CalculaHora.SomaHora(horaAux, intervalo);   
                intervalos.add(novahora);   
            }   
        }   
        return intervalos;   
    }

O problema eh que vc estava alterando o estado DO MESMO OBJETO horaAux, e inserindo ele na lista novamente!

#4

1º muito obirgado por me respoder
2º me perdoem pelo nome de metodo começando com letra maiúscula, me passei na hora de criar so métodos… malz :frowning:

3º utilizei o codigo sugerido mas continuou o mesmo erro. Também não acredito que seja problema no método CalculaHora.somaHora(hora, minutosAdicionado), pois testei a saida dele. também no array sempre fica a ultima hora adicionada, se a saída do “somaHora” retornasse sempre o mesmo numero, o array receberia sempre um único número, o número de todos os registros anteriores não seriam alterados.

#5

Estou desesperado! não estou acreditando que todo o meu projeto está empacado numa coisa como essa…

vou tentar explicar melhor meu problema…

É como se fossem adicionadas instâncias dentro do arrayList, não os valores, dessa forma, quando mudo o valor da instância, o valor dentro do array muda também. O que está acontecendo é que a cada passada do laço de repetição, eu altero o valor e insiro novamente no array a mesma instância, assim vou enchendo o array com a mesma instancia e consequentemente com o mesmo valor. toda vez qeu altero o valor, todas as instancias são alteradas tambem.

ps.:open_mouth: mais intrigante pra mim, é que se em qualquer parte do codigo, o valor da instancia for alterada, o valor das instância dentro do array mudão também…

como corrijo isso ?

#6

Poste a definição do método SomaHora.

#7

Mostre o código do SomaHora.

Uma sugestão. Nesse método retorne uma nova Hora. Quase certeza que voce altera a instancia de um dos argumentos e volta ele mesmo, isso vai alterar todas as instancias desse objeto.

#8

consegui resolver o problema da seguinte forma :

[code] public static ArrayList selectInterval() {
Hora horaInicio = new Hora(Seccao.getCurrentUserTimeStart());
Hora horaFim = Seccao.getCurrentUserTimeEnd();
int intervalo = Seccao.getTempoAtendimento();
ArrayList intervalos = new ArrayList();

	if (intervalo > 1) {
		intervalos.add(new Hora(horaInicio));
		while (!CalculaHora.isBigger(horaInicio, horaFim)) {
			intervalos.add(new Hora(CalculaHora.somaHora(horaInicio, //observe aqui que ao invés de criar uma variável e adiciona-la ao arrayList eu crio uma  
					intervalo)));                                     //nova instancia a cada laço de repetição. alterei o construtor para receber um tipo hora 
		}                                                           // e modificar a nova instância criada. Dessa forma consegui fazer o compilador entender
		int size = intervalos.size() - 1;                        // que ele deveria conlocar instâncias diferentes com diferentes valores, ao invés de colocar 
		intervalos.remove(size);                               // uma unica instância várias vezes.
	}                                                                                         
	return intervalos;
}[/code]

aqui vai o construtor do método Hora:

/*
*Observe aqui que sobrescrevo o construtor 3 vezes, um para receber hora e minuto, outro para receber de hora até segundos, e por 
*fim um para receber um tipo hora e setar seus valores para a referida Hora passada para o construtor.
*/
public Hora(Hora hora){
		this.hora = hora.getHora();
		this.minuto = hora.getMinuto();
		this.segundo =hora.getSegundo();
	}
	
	public Hora (int hora, int minuto){
		this.hora = hora;
		this.minuto = minuto;
	}
	
	public Hora (int hora, int minuto, int segundo){
		this.hora = hora;
		this.minuto = minuto;
		this.segundo = segundo;
	}

apesar de estar funcionado, gostaria de saber se fiz correto, se não, qual seria o padrão de desenvolvimento neste caso?

so para título de curiosidade aqui vai o metodo somaHora(dessa vez com letra minúscula rsrsr), é como disse este método esta retornando
corretamente o um tipo hora acrescido dos minutos passados como argumneto para ele.

	public static Hora somaHora (Hora hora, int minutosAdicionados){
		int aux = 0;
		int minuto = hora.getMinuto();		
		int horas = hora.getHora(); 
		if(minuto+minutosAdicionados<60){
			minuto += minutosAdicionados;								 
		}else{
			aux = (minuto+minutosAdicionados)/60;/*comporta o execesso de horas contidas na soma total de minutos
			 									  * esse laço é desnecessário apenas enconomiza processamento*/
			horas += aux;
			minuto = ((minuto+ minutosAdicionados) -(aux*60));/*subtrai os minutos da hora sem a fraçao, com os minutos da
			                                                   * hora com a fração, isso para se chegar à quantidade de minutos 
			                                                   *excedidos*/ 			
		}
		hora.setHora(horas);
		hora.setMinuto(minuto);
		return hora;
	}

ps.:Quero parabenizar esse forum que tem me ajudado muito, e tem ajudado muitas outras pessoas também, com isso tem contribuido de forma notória para fortalecer a comunidade java!!!

ESTÃO DE PARABÉNS!!!

#9

Fazendo a modificação sugerida pelo MarkAmeba e simplificando o código:

public static Hora somaHora (Hora hora, int minutosAdicionados) {
    Hora resultado = new Hora (hora.getHora(), hora.getMinuto()); // suponho que Hora tenha um construtor que aceite horas e minutos
    int minutosTotais = hora.getMinuto() + minutosAdicionados;
    resultado.setHora (hora.getHora() + minutosTotais / 60);
    resultado.setMinuto (minutosTotais % 60);
    return resultado;
}

Dica: normalmente em JavaSE não é preciso se preocupar com o tempo de uma multiplicação, divisão ou resto. Apenas em JavaME isso pode ser crítico.

#10