Adicionar varios valores ao map

Não. Mas sugiro que você estude sobre as classes Arrays e Collections. No caso da classe Arrays, você pode usar o método asList. Veja:

List<String> nomes = Arrays.asList("um", "dois", "tres");

Na classe Collections tem alguns métodos pra criar listas e mapas com apenas um valor (singletonList e singletonMap).

Nos demais casos, você pode criar métodos utilitários.

wagnerfrancisco:

Não. Mas sugiro que você estude sobre as classes Arrays e Collections. No caso da classe Arrays, você pode usar o método asList. Veja:

List<String> nomes = Arrays.asList("um", "dois", "tres");

Na classe Collections tem alguns métodos pra criar listas e mapas com apenas um valor (singletonList e singletonMap).

Nos demais casos, você pode criar métodos utilitários.

Vou te explicar minha ideia…

Criei um map com quatro valores que indicam estados de potencia…

Baixa, Minima, Alta, Maxima

Ai eu controlando isso atraves de um int e pego no map o valor da String entendeu?

So que na hora de criar a classe to criando…

No construtor da classe eu declaro isso

public ConjuntoPotencia() {
        mapTipo = new HashMap<>();
        mapTipo.put(new Integer(1), "Baixa");
        mapTipo.put(new Integer(2), "Media");
        mapTipo.put(new Integer(3), "Alta");
        mapTipo.put(new Integer(4), "Maxima");
    }

Mas ai eu queria sabe se tem como fazer o seu modo acima pro map…

Vlw

Sugiro que tu utilize um enum ao invés de um map, me parece mais apropriado neste caso:

public enum Potencia {

   BAIXA(1, "Baixa"), MEDIA(2, "Média"), ALTA(3, "Alta");

   private int codigo;
   private String descricao;

   private Potencia(int codigo, String descricao) {
      this.codigo = codigo;
      this.descricao = descricao;
   }

   public int getCodigo() {
      return this.codigo;
   }

   public String getDescricao() {
      return this.descricao;
   }
}

E depois, pra usar, basta chamar:

Potencia.ALTA

wagnerfrancisco:

Sugiro que tu utilize um enum ao invés de um map, me parece mais apropriado neste caso:

public enum Potencia {

   BAIXA(1, "Baixa"), MEDIA(2, "Média"), ALTA(3, "Alta");

   private int codigo;
   private String descricao;

   private Potencia(int codigo, String descricao) {
      this.codigo = codigo;
      this.descricao = descricao;
   }

   public int getCodigo() {
      return this.codigo;
   }

   public String getDescricao() {
      return this.descricao;
   }
}

E depois, pra usar, basta chamar:

Potencia.ALTA

Eu vinha usando Enum, nao como vc…

Mas eu acreditava que gerava muito mais codigo que o necessario entende…

class ConjuntoPotencia {

    private Map<Integer, String> mapTipo;

    public ConjuntoPotencia() {
        mapTipo = new HashMap<>();
        mapTipo.put(new Integer(1), "Baixa");
        mapTipo.put(new Integer(2), "Media");
        mapTipo.put(new Integer(3), "Alta");
        mapTipo.put(new Integer(4), "Maxima");
    }

    public String getTipo(int codigo) {
        return mapTipo.get(codigo);
    }
}

Olha o tamanho da classe interna que eu criei…

Mas valeu pelo seu exemplo

Se o problema for algumas linhas a mais agora, siga meu conselho, use o enum.

Você ganha um objeto que tem um significado muito mais claro. Pra quem lê o seu código, fica claro o que Potencia.ALTA significa. Ele não vai precisar abrir a sua classe sempre que quiser saber do que se trata.

Você não precisa ficar manipulando/comparando strings depois.

Além do mais, o dia que você precisar adicionar mais atributos ou métodos que façam sentido para a Potência, você tem um lugar pra fazer isso.

wagnerfrancisco:

Se o problema for algumas linhas a mais agora, siga meu conselho, use o enum.

Você ganha um objeto que tem um significado muito mais claro. Pra quem lê o seu código, fica claro o que Potencia.ALTA significa. Ele não vai precisar abrir a sua classe sempre que quiser saber do que se trata.

Você não precisa ficar manipulando/comparando strings depois.

Além do mais, o dia que você precisar adicionar mais atributos ou métodos que façam sentido para a Potência, você tem um lugar pra fazer isso.

Cara não discordando de vc, acredito que meu codigo esteja claro

Veja so a classe

package modelo;

import java.util.HashMap;
import java.util.Map;

import controle.PotenciaBaixaExcecao;
import controle.PotenciaMaximaExcecao;

public class Potencia {

    private final int MAXIMA = 4;
    private final int BAIXA = 1;
    private int potenciaAtual = MAXIMA;
    private ConjuntoPotencia tipoPotencia;

    public Potencia() {
        tipoPotencia = new ConjuntoPotencia();
    }

    public void diminuirPotencia() {
        if (potenciaAtual == BAIXA) {
            throw new PotenciaBaixaExcecao();
        }
        this.potenciaAtual--;
        mostrar();
    }

    public void aumentarPotencia() {
        if (potenciaAtual == MAXIMA) {
            throw new PotenciaMaximaExcecao();
        }
        this.potenciaAtual++;
        mostrar();
    }

    private void mostrar() {
        System.out.println("Potencia: " + tipoPotencia.getTipo(potenciaAtual));
    }
}

class ConjuntoPotencia {

    private Map<Integer, String> mapTipo;

    public ConjuntoPotencia() {
        mapTipo = new HashMap<>();
        mapTipo.put(new Integer(1), "Baixa");
        mapTipo.put(new Integer(2), "Media");
        mapTipo.put(new Integer(3), "Alta");
        mapTipo.put(new Integer(4), "Maxima");
    }

    public String getTipo(int codigo) {
        return mapTipo.get(codigo);
    }
}

So me explica uma coisa pq o construtor do enum é desse jeito?

vlw

Você não pode chamar o construtor do enum de fora, por isso ele é privado. O que você define inicialmente são as constantes que ele tem.

Eu não disse que seu código não era claro, apenas disse que usando enum você tem um objeto que tem um significado mais claro. Veja, dentro da classe Potencia você tem alguns atributos como MAXIMA, BAIXA e potenciaAtual que são inteiros. Eles são inteiros, mas na verdade não é isso que eles representam. Você tem um objeto de um tipo, representando outro (Potencia).

Outros aspectos que você deve pensar:

1. Desempenho. A cada novo objeto Potencia que você instancia, você cria um novo mapa com as potencias possíveis. Mesmo que você torne o ConjuntoPotencia estático, você ainda cria novos objetos Potencia desnecessariamente. O enum garante que para aquele tipo, só vai haver uma instância.

2. Igualdade. Você não sobrescreveu nem equals nem hashCode no seu código. Se você tiver dois objetos com Potencia ALTA, eles vão ser considerados diferentes, quando na verdade são iguais. Com o enum você ganha isso de graça.

3. Imutabilidade. Usando enums, você tem objetos imutáveis de uma maneira simples.

Os três itens que eu citei acima podem ser resolvidos usando uma classe normal. Mas é muito mais trabalhoso!

Enfim, aparentemente ficaria melhor usar enums. Claro que nem sempre é vantajoso: se a potencia pudesse oscilar livremente - significando intensidade - não faria sentido ter um enum. Você usa quando tem alguns valores fixos.

Mas estou comparando tipo primitivo int…

Por isso não sobrescrevi o equals…

Verdade… e irei fazer com enum…

Uma vez vi um codigo que o cara fazia tipo um enumSet com o atributos do Enum…

Não entendi o q vc quiz dizer sobre intensidade…

Ela é limitada…Somente isso

macario1983:

wagnerfrancisco:

2. Igualdade. Você não sobrescreveu nem equals nem hashCode no seu código. Se você tiver dois objetos com Potencia ALTA, eles vão ser considerados diferentes, quando na verdade são iguais. Com o enum você ganha isso de graça.

Mas estou comparando tipo primitivo int…

Por isso não sobrescrevi o equals…

Isto dentro da classe Potencia. Mas e se você usar objetos Potencia em vários lugares? Por exemplo, você tem 2 motores, cada um com a sua potencia. Se você quiser comparar a potência de um com outro, como ficaria?

macario1983:

Verdade… e irei fazer com enum…

Uma vez vi um codigo que o cara fazia tipo um enumSet com o atributos do Enum…

Não entendi o q vc quiz dizer sobre intensidade…

Ela é limitada…Somente isso

Eu estava só supondo.

[quote=wagnerfrancisco][quote=macario1983]

wagnerfrancisco:

2. Igualdade. Você não sobrescreveu nem equals nem hashCode no seu código. Se você tiver dois objetos com Potencia ALTA, eles vão ser considerados diferentes, quando na verdade são iguais. Com o enum você ganha isso de graça.

Mas estou comparando tipo primitivo int…

Acho que essa questão seria mais de mapeamento de classes não?

Acho que usando uma interface ou algo do tipo pois a comparação é para todos os modelos…

Vai do ponto de vista…

Mas irei usar Enum

Ontem pesquisando sobre exemplo de enuns no google

Vi um exemplo mas fechei aonde o cara declarava o atributo com indice e representação do mesmo em forma de String…

Uma curiosidade, como c ficou sabendo sobre o uso da classe Arrays e EnumSet?

Forum? Experiencia?

Vlw

Não entendi o esquema das interfaces…

Em relação à classe Arrays, a enums, nem sei ao certo como foi. Mas recomendo a leitura do livro Effective Java (segunda edição) do Joshua Bloch. É muito bom e trata destes aspectos além de muitos outros.

wagnerfrancisco:

Não entendi o esquema das interfaces…

Em relação à classe Arrays, a enums, nem sei ao certo como foi. Mas recomendo a leitura do livro Effective Java (segunda edição) do Joshua Bloch. É muito bom e trata destes aspectos além de muitos outros.

package modelo;

import java.util.EnumSet;

import controle.PotenciaBaixaExcecao;
import controle.PotenciaMaximaExcecao;

public class Potencia {

    private int indice = 4;

    public void diminuirPotencia() {
        if (TipoPotencia.potenciaAtual(indice).equals(TipoPotencia.BAIXA)) {
            throw new PotenciaBaixaExcecao();
        }
        indice--;
        mostrar();
    }

    public void aumentarPotencia() {
        if (TipoPotencia.potenciaAtual(indice).equals(TipoPotencia.MAXIMA)) {
            throw new PotenciaMaximaExcecao();
        }
        indice++;
        mostrar();
    }

    private void mostrar() {
        System.out.println("Potencia: " + TipoPotencia.getPotencia(indice));
    }
}

enum TipoPotencia {

    BAIXA(1, "Baixa"), MEDIA(2, "Média"), ALTA(3, "Alta"), MAXIMA(4, "Máxima");

    int indice;
    String tipoPotencia;
    static EnumSet<TipoPotencia> setPotencia = EnumSet.allOf(TipoPotencia.class);

    private TipoPotencia(int indice, String potencia) {
        this.indice = indice;
        this.tipoPotencia = potencia;
    }

    public static String getPotencia(int indice) {
        for (TipoPotencia potencia : setPotencia) {
            if (potencia.indice == indice) {
                return potencia.tipoPotencia;
            }
        }
        throw new IllegalArgumentException("Indice inválido");
    }

    public static TipoPotencia potenciaAtual(int indice) {
        for (TipoPotencia potencia : setPotencia) {
            if (potencia.indice == indice) {
                return potencia;
            }
        }
        throw new IllegalArgumentException("Indice inválido");
    }
}

cara fiz esse codigo, e ae que tu achas?

eu ate tentei fazer com enum map…

de certa forma é uma pena ele obrigar a colocar como key o enum…

pq senao ia ser show de bola pra eu trabalhar…

Mas ainda teria os problemas com equals, hashcode, etc… e ainda estaria utilizando o inteiro representando o valor indiretamente, o que o enum procura evitar. Eu acredito que faria algo neste sentido:

public enum Potencia {

	BAIXA("Baixa") {
		@Override
		public Potencia proxima() {
			return MEDIA;
		}

		@Override
		public Potencia anterior() {
			throw new IllegalStateException();
		}
	},
	MEDIA("Média") {
		@Override
		public Potencia proxima() {
			return ALTA;
		}

		@Override
		public Potencia anterior() {
			return BAIXA;
		}
	},
	ALTA("Alta") {
		@Override
		public Potencia proxima() {
			return MAXIMA;
		}

		@Override
		public Potencia anterior() {
			return MEDIA;
		}
	},
	MAXIMA("Máxima") {
		@Override
		public Potencia proxima() {
			throw new IllegalStateException();
		}

		@Override
		public Potencia anterior() {
			return ALTA;
		}
	};

	private String descricao;

	private Potencia(String descricao) {
		this.descricao = descricao;
	}
	
	public String getDescricao() {
		return descricao;
	}

	public abstract Potencia proxima();

	public abstract Potencia anterior();
}


public class PotenciaTest {

	@Test
	public void deveriaAumentar() {
		assertEquals(Potencia.MEDIA, Potencia.BAIXA.proxima());
		assertEquals(Potencia.ALTA, Potencia.MEDIA.proxima());
		assertEquals(Potencia.MAXIMA, Potencia.ALTA.proxima());
	}
	
	@Test(expected = IllegalStateException.class)
	public void naoDeveriaAumentarDeMaxima() {
		Potencia.MAXIMA.proxima();
	}
	
	@Test
	public void deveriaDiminuir() {
		assertEquals(Potencia.ALTA, Potencia.MAXIMA.anterior());
		assertEquals(Potencia.MEDIA, Potencia.ALTA.anterior());
		assertEquals(Potencia.BAIXA, Potencia.MEDIA.anterior());
	}
	
	@Test(expected = IllegalStateException.class)
	public void naoDeveriaDiminuirDeBaixa() {
		Potencia.BAIXA.anterior();
	}
}

Apenas uma classe, imutável.

wagnerfrancisco:

Mas ainda teria os problemas com equals, hashcode, etc… e ainda estaria utilizando o inteiro representando o valor indiretamente, o que o enum procura evitar. Eu acredito que faria algo neste sentido:

public enum Potencia {

	BAIXA("Baixa") {
		@Override
		public Potencia proxima() {
			return MEDIA;
		}

		@Override
		public Potencia anterior() {
			throw new IllegalStateException();
		}
	},
	MEDIA("Média") {
		@Override
		public Potencia proxima() {
			return ALTA;
		}

		@Override
		public Potencia anterior() {
			return BAIXA;
		}
	},
	ALTA("Alta") {
		@Override
		public Potencia proxima() {
			return MAXIMA;
		}

		@Override
		public Potencia anterior() {
			return MEDIA;
		}
	},
	MAXIMA("Máxima") {
		@Override
		public Potencia proxima() {
			throw new IllegalStateException();
		}

		@Override
		public Potencia anterior() {
			return ALTA;
		}
	};

	private String descricao;

	private Potencia(String descricao) {
		this.descricao = descricao;
	}
	
	public String getDescricao() {
		return descricao;
	}

	public abstract Potencia proxima();

	public abstract Potencia anterior();
}


public class PotenciaTest {

	@Test
	public void deveriaAumentar() {
		assertEquals(Potencia.MEDIA, Potencia.BAIXA.proxima());
		assertEquals(Potencia.ALTA, Potencia.MEDIA.proxima());
		assertEquals(Potencia.MAXIMA, Potencia.ALTA.proxima());
	}
	
	@Test(expected = IllegalStateException.class)
	public void naoDeveriaAumentarDeMaxima() {
		Potencia.MAXIMA.proxima();
	}
	
	@Test
	public void deveriaDiminuir() {
		assertEquals(Potencia.ALTA, Potencia.MAXIMA.anterior());
		assertEquals(Potencia.MEDIA, Potencia.ALTA.anterior());
		assertEquals(Potencia.BAIXA, Potencia.MEDIA.anterior());
	}
	
	@Test(expected = IllegalStateException.class)
	public void naoDeveriaDiminuirDeBaixa() {
		Potencia.BAIXA.anterior();
	}
}

Apenas uma classe, imutável.

na moral…estou a anos luz de programar igual a vc kkkkk

show de bola seu exemplo vou avaliar ele…

vc bate muito na tecla do equals e hashcode…

seria por conta de ter varios motores como vc disse né?

Nem tanto… hehe, até pq esta é a minha solução, certamente tem quem critique.

Os motores com potências iguais são apenas um exemplo. Sempre que você precisasse comparar potências (a classe Potencia, não o enum), teria problemas. Duas potências altas seriam consideradas diferentes. A identidade do objeto potencia é determinada pelos seus valores (no caso, tinha um inteiro que o representava). Duas potências com o mesmo valor, são iguais. Por isso é interessante escrever o equals (e consequentemente o hashcode).

wagnerfrancisco:

Nem tanto… hehe, até pq esta é a minha solução, certamente tem quem critique.

Os motores com potências iguais são apenas um exemplo. Sempre que você precisasse comparar potências (a classe Potencia, não o enum), teria problemas. Duas potências altas seriam consideradas diferentes. A identidade do objeto potencia é determinada pelos seus valores (no caso, tinha um inteiro que o representava). Duas potências com o mesmo valor, são iguais. Por isso é interessante escrever o equals (e consequentemente o hashcode).

Olha, eu achei exemplos mais parecidos com o meu do que com o seu…

O seu ta legal…apesar que eu ainda n to bão no Java, tem 5 meses…

Mas tua solucao foi legal…

Sobre o equals acima falado, cara tive um problema no exemplo que estou fazendo pra mim no DAO

Que eu gravo num map um Objeto telefone…

E ai eu precisava comparar valores…

Um cara foi e me disse pra fazer isso…

Show de bola

wagnerfrancisco:

Nem tanto… hehe, até pq esta é a minha solução, certamente tem quem critique.

Os motores com potências iguais são apenas um exemplo. Sempre que você precisasse comparar potências (a classe Potencia, não o enum), teria problemas. Duas potências altas seriam consideradas diferentes. A identidade do objeto potencia é determinada pelos seus valores (no caso, tinha um inteiro que o representava). Duas potências com o mesmo valor, são iguais. Por isso é interessante escrever o equals (e consequentemente o hashcode).

cara estive pensando uma coisa…vc bateu muito na tecla da variavel int de controle…

tambem seria para a classe digamos filha, nao ter acesso a classe superior?

macario1983:

wagnerfrancisco:

Nem tanto… hehe, até pq esta é a minha solução, certamente tem quem critique.

Os motores com potências iguais são apenas um exemplo. Sempre que você precisasse comparar potências (a classe Potencia, não o enum), teria problemas. Duas potências altas seriam consideradas diferentes. A identidade do objeto potencia é determinada pelos seus valores (no caso, tinha um inteiro que o representava). Duas potências com o mesmo valor, são iguais. Por isso é interessante escrever o equals (e consequentemente o hashcode).

cara estive pensando uma coisa…vc bateu muito na tecla da variavel int de controle…

tambem seria para a classe digamos filha, nao ter acesso a classe superior?

Como assim? Não entendi bem… você fala em herdar de Potencia?

wagnerfrancisco:

macario1983:

wagnerfrancisco:

Nem tanto… hehe, até pq esta é a minha solução, certamente tem quem critique.

Os motores com potências iguais são apenas um exemplo. Sempre que você precisasse comparar potências (a classe Potencia, não o enum), teria problemas. Duas potências altas seriam consideradas diferentes. A identidade do objeto potencia é determinada pelos seus valores (no caso, tinha um inteiro que o representava). Duas potências com o mesmo valor, são iguais. Por isso é interessante escrever o equals (e consequentemente o hashcode).

cara estive pensando uma coisa…vc bateu muito na tecla da variavel int de controle…

tambem seria para a classe digamos filha, nao ter acesso a classe superior?

Como assim? Não entendi bem… você fala em herdar de Potencia?

Dificil te explicar…

Mas seria tipo imaginar a classe potencia como pai e a classe tipo potencia como filha…

Assim a filha n teria seu estado alterado pelo pai

cara testei seu codigo e infelizmente não se encaixa ou eu não soube aproveitar

meu projeto é um microondas

estou usando composição para integrar o microondas

e quando executava seu codigo dava nullpointer

achei muito doido seu codigo, legal a ideia…

Classe pai e classe filha submetem ao uso de herança, por isso falei em herdar de Potência. Mas no exemplo não haverá nada disso, não haverá mais TipoPotencia.

Posta aí a parte que deu a NullPointerException pra nós darmos uma olhada…