Java get variable name as string

Question

final static int 
    DRAGON = 5,
    SNAKE = 6;

String this_item = "DRAGON";
int item_value = super_func(this_item);//must be 5

Is it possible to implement this super_func, as shown above?

Or maybe I am asking for too much?

EDIT:

I am not allowed to use enum. I can:

a) use a map (as someone pointed, or 2 array lists) or
b) do this with some pro way (but it doesn't seem possible).

Is this just an idle question? Why do you need to do this? Maybe you should explain what you're trying to do that lead you to need this. — Kenster, May 24 '14 at 14:40
possibly duplicate: http://stackoverflow.com/questions/744226/java-reflection-how-to-get-the-name-of-a-variable — timgeb, May 24 '14 at 14:41

score 3 · Answer 1 · answered May 24 '14 at 14:41

I don't know what this value is supposed to represent, but you could use an Enum.

enum Animal {
    DRAGON(5),
    SNAKE(6);

    private final int a;

    private Animal(int a){
        this.a = a;
    }

    public int getA(){
        return a;
    }
}

And then

String this_item = "DRAGON";
int item_value = Animal.valueOf(this_item).getA();//5

score 2 · Answer 2 · answered May 24 '14 at 14:40

2

You can get the value of a variable with Java Reflection tricks, but why not declaring a simple enum and using it:

    enum Creature{
    DRAGON(5), SNAKE(6);
     ...
    }

answered May 24 '14 at 14:40

Juvanis

25,802
5
69
87

score 1 · Answer 3 · edited May 24 '14 at 14:45

1

As far as I know such a thing is not possible, but you coudl store your variables in Map

HashMap<String,Integer> map = new HashMap<>();
map.put("DRAGON",5);
map.put("SNAKE",6);

int itemValue = map.get("DRAGON"); //Sets itemValue to 5

edited May 24 '14 at 14:45

HelloWorld123456789

5,299
3
23
33

answered May 24 '14 at 14:39

wastl

2,643
14
27

Cobbles · Answer 4 · 2014-05-24T15:03:13.210

You can also use a switch() statement.

int item_value;
switch(this_item) {
     case "DRAGON":
         item_value = 5;
         break;
     case "SNAKE":
         item_value = 6
         break;

or different solution doing the opposite

private String getAnimal(int itemValue) {
     switch(item_value) {
         case 5:
             return "DRAGON";
         case 6:
             return "SNAKE";
         default:
             return null;
}

score 1 · Accepted Answer · edited May 23 '17 at 12:07

While it's technically possible to do this using reflection, I'd strongly recommend you to rethink your structure, and consider one of the alternatives that have been mentioned in the other answers.

The simplest would probably be to use a map

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;

public class VariableNameTest
{
    private static final Map<String,Integer> map;
    static
    {
        Map<String, Integer> m = new LinkedHashMap<String, Integer>();        
        m.put("DRAGON",5);
        m.put("SNAKE",6);
        map = Collections.unmodifiableMap(m);
    }

    public static void main(String[] args)
    {
        System.out.println(getValue("DRAGON"));
        System.out.println(getValue("SNAKE"));
        System.out.println(getValue("Boo!"));
    }

    public static int getValue(String name)
    {
        Integer i = map.get(name);
        if (i == null)
        {
            // Do some error handling here!
        }
        return i;
    }
}

But if your intention is to extend this with additional functionality, you should probably introduce a class like it was recommended in https://stackoverflow.com/a/23846279/3182664

Just for completeness: The reflection solution, not recommended!

import java.lang.reflect.Field;

public class VariableNameTest
{
    static final int DRAGON = 5;
    static final int SNAKE = 6;

    public static void main(String[] args)
    {
        System.out.println(getValue("DRAGON"));
        System.out.println(getValue("SNAKE"));
        System.out.println(getValue("Boo!"));
    }

    private static int getValue(String name)
    {
        try
        {
            Class<?> c = VariableNameTest.class;
            Field f = c.getDeclaredField(name);
            return f.getInt(null);
        }
        catch (NoSuchFieldException e)
        {
            // Many things
            e.printStackTrace();
        }
        catch (SecurityException e)
        {
            // may cause
            e.printStackTrace();
        }
        catch (IllegalArgumentException e)
        {
            // this to 
            e.printStackTrace();
        }
        catch (IllegalAccessException e)
        {
            // fail horribly 
            e.printStackTrace();
        }
        return 0;
    }
}

Not recommended, because it's too complex and there are simpler alternatives, right? — Luka, May 24 '14 at 14:51
Not recommended, because `Many things` `may cause` `this to` `fail horribly` - and there are simpler, less invasive solutions, yes. — Marco13, May 24 '14 at 14:53
@Cobbles This "edit" of the original question was done while (or shortly after?) I referred to ZouZou's recommendation. However, I intentionally said that he might introduce a *class* (which does not necessarily mean that this class should extend the `Enum` class). Such a class could offer a functionality that is *roughly* similar to that of an `enum`. Of course, one could not `switch` over the instances/values of this class, but a `valueOf(String)` method could be offered, solving the initial issue. — Marco13, May 24 '14 at 15:11

Java get variable name as string

5 Answers5