Ae pessoal, é uma dúvida que eu acho que é simples, mas eu não estou conseguindo conseguindo “visualizar”, vejam o que eu tenho que fazer
É uma pequena aplicação para o gerenciamento dos concursos de quadrilhas realizados a cada ano.
Requisitos da aplicação:
Cada concurso será identificado pelo ano de sua realização (somente um concurso poderá ser realizado a cada ano)
…
A minha dúvida como faço pra marcar e indentificar que ne tal ano, já houve concurso?
Eu estava pensando em fazer um classe Ano, com duas variáveis: int Ano(seria a identificacao do ano Ex: 2011 ), e uma boolean HouveConcurso.
Mas não sei se isso seria a melhor alternativa…
Cara, me tira so uma duvida.
Você vai mapear essa classe no banco? Acho que assim não ficaria tão legal.
Sair cadastrando todos os Anos e verificar a flag pra saber se pode cadastrar ou não.
Acho que quando você for cadastrar um concurso você faz uma verificação se já existe algum registro com o mesmo ano cadastrado.
Caso exista você não permite inserção, se não existe você deixa.
Acho que assim é o mais fácil e a maneira que me veio na cabeça de cara. Se pensar em algo diferente eu posto aqui.
[quote=Milk15][quote=ViniGodoy]Por favor, ao criar tópicos, dê um título descritivo. O título “Dúvida” não diz nada a respeito do conteúdo do tópico.
[/quote]
ViniGodoy - Haha foi mal Vini, já imaginei que alguém ia falar sobre isso, mas foi porque eu fiquei sem idéia pro título mesmo…
Rique - eu n vou precisar fazer banco n, é só uma aplicação que mostre na hora, não vai precisar ficar armazenado.
Arqueiros - Ainda não sei usar hashmap, mas vou tentar dar uma pesquisada sobre isso, valeu
[/quote]
Oi.
Basicamente seria isso, supondo que você tenha um objeto que represente o Concurso, com as suas respectivas informações:
Map<Integer, SeuObjeto> concursos = new HashMap<Integer, SeuObjeto>();
Integer year = 2010;
if(!concursos.contains(year)) {
// pega o seu objeto
concursos.put(year, seuObjetoConcurso);
}
Eu acho que entendi , pra cada “year” existe uma ‘ligação’ com o concurso x, certo?
Dessa sua idéia tirei um jeito de fazer apenas com ArrayList, que acho que vai funcionar.
Na classe que vai gerenciar coloquei um ArrayList de ano, e criei um método adicionaAno para verificar se pode adicionar o ano ‘x’ na lista:
[code]List listaAno;
public void adicionaAno(Integer ano){
for (Integer i : listaAno){
if(!listaAno.contains(ano)){
listaAno.add(ano);
}
}
}
[/code]
e vou depois colocar um boolean para ele retornar dizendo se ano está liberado ou não
[quote=Milk15]Eu acho que entendi , pra cada “year” existe uma ‘ligação’ com o concurso x, certo?
Dessa sua idéia tirei um jeito de fazer apenas com ArrayList, que acho que vai funcionar.
Na classe que vai gerenciar coloquei um ArrayList de ano, e criei um método adicionaAno para verificar se pode adicionar o ano ‘x’ na lista:
[code]List listaAno;
public void adicionaAno(Integer ano){
for (Integer i : listaAno){
if(!listaAno.contains(ano)){
listaAno.add(ano);
}
}
}
[/code]
e vou depois colocar um boolean para ele retornar dizendo se ano está liberado ou não
[/quote]
Sim, a idéia do Map é chave e valor. É praticamente um ID de uma tabela de seu banco de dados, tendo ID, tenho os seus respectivos valores.
Só que esse ‘id’ pode ser qualquer Objeto.
Você até pode usar um List, mas creio que Map seja bem mais simples e pratico.
E está usando errado o método contains, porque um laço de repetição?
Sem falar que o laço vai encontrar ou não o objeto dentro da lista na primeira iteração e mesmo assim vai continuar fazendo isso, por n vezes, seja qual for o tamanho da lista.
Basta:
[code]List listaAno;
public void adicionaAno(Integer ano){
if(!listaAno.contains(ano))
listaAno.add(ano);
}
[/code]
Só obviamente, pense com calma, veja se nunca vai ser nula sua lista e bla bla bla. Podes mudar o retorno do método e etc.
Abraços!
public class Ano {
private int ano = 0;
public int getAno() {
return ano;
}
public void setAno(int ano) {
this.ano = ano;
}
}
A classe concurso:
public class Concurso {
private String descricaoConcurso = "";
public String getDescricaoConcurso() {
return descricaoConcurso;
}
public void setDescricaoConcurso(String descricaoConcurso) {
this.descricaoConcurso = descricaoConcurso;
}
}
A classe quadrilha:
import java.util.HashMap;
import java.util.Map;
public class Quadrilhas {
private Map<Integer, Concurso> mapaDeConcursos = new HashMap<Integer, Concurso>();
public void adicionaConcurso(Ano ano, Concurso concurso) {
if (mapaDeConcursos.get(ano.getAno()) == null) {
mapaDeConcursos.put(ano.getAno(), concurso);
System.out.println("Concurso " + ano.getAno() + " adicionado.");
} else {
System.out.println("Já existe concurso pro ano de " + ano.getAno());
}
}
}
E o main para testes:
public class Main {
public static void main(String[] args) {
Quadrilhas q = new Quadrilhas();
Concurso concursoUm = new Concurso();
concursoUm.setDescricaoConcurso("Dança 1");
Ano AnoUm = new Ano();
AnoUm.setAno(2011);
q.adicionaConcurso(AnoUm, concursoUm);
Concurso concursoDois = new Concurso();
concursoDois.setDescricaoConcurso("Dança 2");
Ano anoDois = new Ano();
anoDois.setAno(2011);
q.adicionaConcurso(anoDois, concursoDois);
}
}
Com a idéia do Map fica bem simples mesmo, retornando a mensagem você nem precisaria de um boolean como você disse que queria fazer…