Dúvida !i!

acho que vc poderia usar Map…

Integer ano;
Concurso concurso;
Map<Integer, Concurso> mapteste = new HashMap<Integer, Concurso>();
mapteste.put(ano, concurso);

espero ter ajudado

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.

Abs,

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.

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.

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

Milk15:

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.

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

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); }

Entendeu?

Abraços.

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:

List<Integer> listaAno;
   
    
    public void adicionaAno(Integer ano){
        for (Integer i : listaAno){
            if(!listaAno.contains(ano)){
                listaAno.add(ano);
            }
        }
        
    }

e vou depois colocar um boolean para ele retornar dizendo se ano está liberado ou não

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:

List<Integer> listaAno;
   
    
    public void adicionaAno(Integer ano){
        for (Integer i : listaAno){
            if(!listaAno.contains(ano)){
                listaAno.add(ano);
            }
        }
        
    }

e vou depois colocar um boolean para ele retornar dizendo se ano está liberado ou não

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:

List<Integer> listaAno;
   
    
    public void adicionaAno(Integer ano){
        if(!listaAno.contains(ano))
           listaAno.add(ano);   
    }

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!

Boa tarde a todos,

Eu fiz da seguinte maneira:

A classe ano:

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…

Esperto ter ajudado!