Enum

Tinha feito um trem aki…
Mas esquece…

Acho que não:

java.lang.IllegalArgumentException: No enum const class ETipoFatura.3

Perguntar não machuca: porque você nao usa o ordinal()? ele jah retorna o número da enum na ordem, o unico problema é que começa de 0. Usando oordinal, o código que você tentou usar funciona.

Realmente perguntar não ofende, mas acontece que eu quero que as enums tenham aqueles valores entende ?? Eu vou adicionar outras enums depois com valores que não estão em ordem…

Não sei se é isto que você gostaria mas ve se ajuda.
http://www.dcc.ufrj.br/~comp2/TextosJava/TipoEnum.pdf

Acho que eu faria assim:

public enum ETipoFatura {

		POR_INTERVALO_DE_TEMPO(1),  
		POR_UNIDADE_REMOTA(2),  
		GERAL(3),  
		POR_INTERVALO_DE_TEMPO_UR(4);  

		private final int value;  

		ETipoFatura(int value) {  
			this.value = value;  
		}  

		public int getValue() {  
			return value;  
		}
		
		public static ETipoFatura getETipoFatura(int value){
			
			for (ETipoFatura tipoFatura : ETipoFatura.values(){
				if(tipoFatura.getValue() == value){
					return tipoFatura;
				}
            }
			
			return null;
		}
	}

dai recuperava assim:

ETipoFatura tipoFatura = ETipoFatura.getETipoFatura(3);

É feio mas resolve :)

maschiojv:

Acho que eu faria assim:

public enum ETipoFatura {

		POR_INTERVALO_DE_TEMPO(1),  
		POR_UNIDADE_REMOTA(2),  
		GERAL(3),  
		POR_INTERVALO_DE_TEMPO_UR(4);  

		private final int value;  

		ETipoFatura(int value) {  
			this.value = value;  
		}  

		public int getValue() {  
			return value;  
		}
		
		public static ETipoFatura getETipoFatura(int value){
			
			for (ETipoFatura tipoFatura : ETipoFatura.values(){
				if(tipoFatura.getValue() == value){
					return tipoFatura;
				}
            }
			
			return null;
		}
	}

dai recuperava assim:

ETipoFatura tipoFatura = ETipoFatura.getETipoFatura(3);

É feio mas resolve :)

Eu tinha pensado em fazer assim, mas imaginei que existisse uma forma correta ou menos xunxada auhaiuhaUAIHA. Mesmo assim valeu...

Acho que não:

java.lang.IllegalArgumentException: No enum const class ETipoFatura.3

Ahh sim. Como o tipo de um é String e internamente é Integer, nunca será igual. O que você pode fazer é implementar equals ou usar a idéia do maschiojv.

Aliás, se eu te contar que internamente o Java faz uma solução bem assim para o valueOf do enum? Veja aqui:

public static <T extends Enum><T>> T valueOf(Class<T> enumType, String name) { T result = enumType.enumConstantDirectory().get(name); if (result != null) return result; if (name == null) throw new NullPointerException("Name is null"); throw new IllegalArgumentException( "No enum const " + enumType +"." + name); }

Map<String, T> enumConstantDirectory() { if (enumConstantDirectory == null) { T[] universe = getEnumConstantsShared(); if (universe == null) throw new IllegalArgumentException( getName() + " is not an enum type"); Map<String, T> m = new HashMap<String, T>(2 * universe.length); for (T constant : universe) m.put(((Enum)constant).name(), constant); enumConstantDirectory = m; } return enumConstantDirectory; }

thingol:

import java.util.*;

 enum ETipoFatura  {  
     POR_INTERVALO_DE_TEMPO(256),  
     POR_UNIDADE_REMOTA(720),  
     GERAL(840),  
     POR_INTERVALO_DE_TEMPO_UR(1023);  
   
     private final int value;  
   
     ETipoFatura(int value) {  
         this.value = value;  
     }  
   
     public int getValue() {  
         return value;  
     }
     private static final Map<Integer, ETipoFatura> value2enum = new HashMap<Integer, ETipoFatura>();
     static {
         for (ETipoFatura v : values()) {
             value2enum.put (v.getValue(), v);
         }
     }  
     public static ETipoFatura getInstance(int v) {
         return value2enum.get (v);
     }
 }  

class TesteEnum {
    public static void main(String[] args) {
        ETipoFatura etf = ETipoFatura.GERAL;
        ETipoFatura etf2 = ETipoFatura.getInstance (720);
        ETipoFatura etf3 = Enum.valueOf (ETipoFatura.class, "POR_INTERVALO_DE_TEMPO_UR");
        System.out.println (etf); // imprime GERAL
        System.out.println (etf.getValue()); // imprime 840
        System.out.println (etf2); // imprime POR_UNIDADE_REMOTA
        System.out.println (etf2.getValue()); // imprime 720
        System.out.println (etf3); // imprime POR_INTERVALO_DE_TEMPO_UR
        System.out.println (etf3.getValue()); // imprime 1023
    }    
}

Interessante, acho que vou usar essa implementação ela parece menos "feia" rsrsrs.

Valew galera

Guitar_Men:

Interessante, acho que vou usar essa implementação ela parece menos “feia” rsrsrs.

Valew galera

E mais pesada tbm. Por exemplo, você deixa um map em memória o tempo todo.

Eu ficaria com a sugestão do maschiojv, que é bem mais simples. É um simples loop, que depois de terminado o processamento, vai tudo pro GC.

otavio:

Guitar_Men:

Interessante, acho que vou usar essa implementação ela parece menos “feia” rsrsrs.

Valew galera

E mais pesada tbm. Por exemplo, você deixa um map em memória o tempo todo.

Eu ficaria com a sugestão do maschiojv, que é bem mais simples. É um simples loop, que depois de terminado o processamento, vai tudo pro GC.

Você acha que um Map na memória faz diferença na performance? Quantos KB ele pode ocupar de RAM? Bem poucos, não? E ainda o acesso é mais rápido e o processamento é menor.

De qualquer forma, não consigo ver grandes diferenças de performance entre os dois casos.

Na verdade UMA pode não parecer muito, mas de grão em grão… vai-se muita memoria. Soma-se um hashmap aqui, outro alí, mais um XMl do Struts, mais um Hibernate, Session, e logo tu vai ter um monte desses pedacinhos que somados vão consumir.

Obvio que isso tudo é uma sugestão minha, que trabalho há alguns anos com projetos onde é necessário cuidar a performance. Sempre que possível simplificar e reduzir coisas que ficam em memória.

Nesse caso você além de ter um Map em memória, vai ter que percorrer ele sempre que precisar pegar o objeto (assim que funciona a implementação interna dele). No outro caso você apenas percorre um array de objetos. Abaixo a implementação que faz a mesma coisa.

Entry tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { return e.value; } }

Mas a escolha é sua, dependendo das tuas necessidades.

Só pelo fato do Guitar_Men não estar usando uma tabela no banco de dados e recuperando o valor num select, acho que a performance está ótima XD
Parece brincadeira, mas eu vejo muito disso.

Além do mais, se ficar parando pra analizar e discutir cada coisinha dessas o sistema do Guitar_Men não sai nunca né. heheheh

Teria que analizar o seguinte:

vai buscar a enum pelo valor muitas vezes? isso vai consumir muito processador, então usa a solução do thingol
se vai usar poucas vezes isso, entao não tem porque deixar o map na memória (lembrando que as enuns vao estar de qualquer jeito), faz do meu jeito

mas no fim das contas, pra mim decisão eu jogaria cara ou coro, não ficaria quebrando a cabeça com coisinhas dessa

maschiojv:

Só pelo fato do Guitar_Men não estar usando uma tabela no banco de dados e recuperando o valor num select, acho que a performance está ótima XD
Parece brincadeira, mas eu vejo muito disso.

Além do mais, se ficar parando pra analizar e discutir cada coisinha dessas o sistema do Guitar_Men não sai nunca né. heheheh

Teria que analizar o seguinte:

vai buscar a enum pelo valor muitas vezes? isso vai consumir muito processador, então usa a solução do thingol
se vai usar poucas vezes isso, entao não tem porque deixar o map na memória (lembrando que as enuns vao estar de qualquer jeito), faz do meu jeito

mas no fim das contas, pra mim decisão eu jogaria cara ou coro, não ficaria quebrando a cabeça com coisinhas dessa :)

:lol: Cara e coroa é muito boa…

maschiojv:

Só pelo fato do Guitar_Men não estar usando uma tabela no banco de dados e recuperando o valor num select, acho que a performance está ótima XD
Parece brincadeira, mas eu vejo muito disso.

Além do mais, se ficar parando pra analizar e discutir cada coisinha dessas o sistema do Guitar_Men não sai nunca né. heheheh

Teria que analizar o seguinte:

vai buscar a enum pelo valor muitas vezes? isso vai consumir muito processador, então usa a solução do thingol
se vai usar poucas vezes isso, entao não tem porque deixar o map na memória (lembrando que as enuns vao estar de qualquer jeito), faz do meu jeito

mas no fim das contas, pra mim decisão eu jogaria cara ou coro, não ficaria quebrando a cabeça com coisinhas dessa :)

maschiojv, não há necessidade de stress. Como eu disse, eu fiz apenas uma sugestão com a intenção de ajudar. Além disso eu ainda disse: depende do que é teu projeto, caso for grande, há de se pensar nessas “coisinhas”. Caso contrário, tanto faz.

Diga isso pro meu kame hame ha! ehhehe