ArrayList nao adicionou os itens corretamente

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]

                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.

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!

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.

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 ?

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

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.

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!!!

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.