Jump to content

lista e familia e seus dados parametrizados


blueomega
 Share

Recommended Posts

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
Link to comment
Share on other 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.

I haven’t lost my mind; it’s backed up on DVD somewhere!

Link to comment
Share on other 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()

Link to comment
Share on other 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?

Link to comment
Share on other 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();
    }
    
}
Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
 Share

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.