• Revista PROGRAMAR: Já está disponível a edição #53 da revista programar. Faz já o download aqui!

blueomega

lista e familia e seus dados parametrizados

5 mensagens neste tópico

oi, venho de c++ e tinha-me habituado aos templates e a bibliotecas stl pra info e ando pelo java as aranhas, não me ajeito a documentação e o livro que tenho aqui em certas coisas ja não ta actualizado

1.º para alem da lista que outras estructuras de dados posso passar objectos (List<tipo de objecto> nome=new...), so encontro mesmo a lista, dava jeito algo como o vector, em que não tenho que defenir 1 tamanho, pensei no LinkedList, mas não sei\consigo passar-lhe objectos. ha alguem metodo sem criar a nossa propria stack?

alem disso tambem dava jeito pra um trabalho a stack (implementação do next fit num problema de empacotamento)

andei aqui a testar a lista e não ha maneira de lhe por 1 iterador a dar(a correr), alguem da uma ajuda, ja tentei o ListIterator e nada

public class pacote {

/**
 *Parametro tamanho do pacote
 */
private float tamanho;

/**
 * Constructor do pacote
 * @param dist
 */
public pacote (int dist)
{
if(dist==1)
{
	//cast de double pra float
	this.tamanho = (float)(Math.random());
}
else if(dist==2)
{
	//...distribuição normal
}
else if(dist==3)
{
	//...quiquadrado
}
}//fim do constructor

/**
 * Devolve o tamanho do pacote
 * @return
 */
public float get_tamanho()
{
	return this.tamanho;
}

}

import java.util.*;

public class palete {

 static final float volume_max = 5;//vol max
 float volume;//vol actual
 List<pacote> lista_pacotes ;//lista de pacotes


 public palete()
 {
	 lista_pacotes = new ArrayList<pacote>();
	 this.volume = 0;
 }

 public float get_volume()
 {
 return this.volume;
 }

 //não perfeitamente funcional
 public boolean palete_cheia(pacote vol)
 {
	 if(this.get_volume()+vol.get_tamanho()>=volume_max)
		 return true;
	 else
		 return false;
 }

 public void palete_add(pacote vol)
 {
	if(!palete_cheia(vol))//corrigir
	{	
	lista_pacotes.add(vol);
	this.volume += vol.get_tamanho();		
	}
	//throw error, criar
}



}

//so pra teste
public class mainteste {

/**
 * @param args
 */
public static void main(String[] args) {
boolean flag=false;
palete p= new palete();


do
{
pacote pal = new pacote(1);
if(p.get_volume()+pal.get_tamanho()<=1){
p.palete_add(pal);
}
else{
flag=true;
}

System.out.println("num gerado " + pal.get_tamanho());
System.out.println("total " + p.get_volume());
System.out.println(" ");
}
while(flag!=true);	

System.out.println(p.get_volume());
System.out.println(p.lista_pacotes.size());

}
}[/quote]

alem disso precisava de guardar depois varias paletes de maneira sequencial em outra lista\stack, algum conselho?

se alguem tiver exemplos de codigo sobre o assunto pm me

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Tens aqui uma das grandes invenções do Java o Vector é um array dinâmico, com tamanho flexível e com óptimos métodos para usar.

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Com essas regras de codificação vê-se mesmo que vens do C ;)

Notas sobre as regras de codificação em Java:

- o nome das classes começa sempre por maiúscula;

- o nome dos métodos e variáveis não leva "_", separas nomes alternados a capitalização das palavras, ex lista_pacotes passa a listaPacotes

- as constantes são escritas em maiúsculas e separadas por "_";

Não estás a usar correctamente o encapsulamento, ou melhor não estás a usar encapsulamento.

Quanto às estruturas podes usar:

- java.util.List

- java.util.LinkedList

- java.util.ArrayList

- java.util.Stack

- java.util.Vector

Estas são só algumas das mais usadas, mas se consultares a documentação podes ver que no package java.util.* tens as estruturas mais comuns.

Espero que ajude.

Só agora reparei na dúvida do iterador. Não sei o que pretendes por colocar o iterador a correr mas todas as colecções possuem um iterador. Normalmente chama-se através do método listIterator(), assim, e pegando na tua lista, para usares um iterador basta fazeres lista_pacotes.listIterator()

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Knitter thx pela ajuda, pensei que quando fazia import java.util.* importava tudo e não apenas a generica,agora fica mais simples de usar os metodos de cada uma. estava a achar estranho so dar com a lista e com o resto não dar, era algo estupido tendo em conta a utilidade dos templates e não existir algo do genero em java

sim eu sei que não tou a usar encapsulamento nenhum, so usei publics mesmo pra teste e pra ser rapido

sim ja defeni o iterador da lista ListIterator list = lista_pacotes.listIterator(); , mas não sei exactamente de onde colocar e como o usar de fora da classe, simplesmente não o consigo usar

a minha intensão é correr futuramente os itens de uma lista de paletes, para obter por exemplo o seu conteudo, mas como a class palete ja tinha uma lista estava a ver se a conseguia por a dar nela

ha diferenças em inicializar a lista dentro do constructor ou fora?

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites
(...)pensei que quando fazia import java.util.* importava tudo(...)

Sim quando usas a directiva import dessa forma estás a indicar todas as classes dentro do package util.

Quanto a iniciar o atributo dentro ou fora do construtor, não existe diferença a não ser que precises de fazer apenas dentro do construtor, mas isso deves perceber. No caso geral, não existe qualquer diferença.

Um iterador é um objecto esquisito ;), não o podes obter no ínicio da criação da lista porque ele refere os elementos que se encontram na lista, e se defines no inicio e depois inseres um objecto o iterador torna-se inválido. No entanto o código para usar um iterador é bastante simples. Exemplo:

/*
* IteratorExample.java
*
* Created on 5 de Abril de 2007, 18:25
*
*/

package org.sergiolopes;

import java.util.*;

/**
*
* @author Knitter
*/
public class IteratorExample {
    /**
     * Simples lista de nomes
     */
    private LinkedList<String> listaNomes = new LinkedList<String>();
    
    /**
     * Creates a new instance of IteratorExample
     */
    public IteratorExample(int maxNomes) {
        String nomeBase = "Nome";
        
        /* Encher a lista com alguns nomes */
        for(int i = 0; i < maxNomes; i++) {
            listaNomes.add(nomeBase + " - " + i);
        }
    }
    
    /**
     * Metodo simples para percorrer a lista usando um iterador.
     * Convem obter um novo iterador sempre que se pretende percorrer a lista 
     * de modo a evitar problemas de iteradores inválidos
     */
    private void percorrerLista() {
        /* Obter o iterador da lista */
        Iterator it = listaNomes.listIterator();
        
        /**
         * Percorrer o iterador.
         * O metodo hasNext() verifica se ainda existem elementos a percorrer.
         * E' o metodo que se usa sempre para controlar os ciclos onde se usam 
         * iteradores.
         *
         * O metodo next() devolve o elemento currente!, isto pode parecer 
         * estranho mas e' o que acontece. O metodo devolve-te o objecto 
         * corrente e avanca o iterador para o elemento seguinte, mesmo que 
         * estejas no ultimo objecto. Neste caso o que acontece e' que o metodo 
         * de controlo termina o ciclo.
         */
        while(it.hasNext())
            System.out.println(it.next());
    }
    
    public static void main(String[] args) {
        IteratorExample itE = new IteratorExample(50);
        /* Et voila', tens um metodo para percorrer a lista. */
        itE.percorrerLista();
    }
    
}

0

Partilhar esta mensagem


Link para a mensagem
Partilhar noutros sites

Crie uma conta ou ligue-se para comentar

Só membros podem comentar

Criar nova conta

Registe para ter uma conta na nossa comunidade. É fácil!


Registar nova conta

Entra

Já tem conta? Inicie sessão aqui.


Entrar Agora