Variable nach Namen aus einem String abrufen

Beispielcode:

int width = 5;
int area = 8;
int potato = 2;
int stackOverflow = -4;

Angenommen, ich möchte, dass der Benutzer eine Zeichenfolge eingibt:

String input = new Scanner(System.in).nextLine();

Sagen Sie dann die Benutzereingaben potato. Wie würde ich die Variable namens abrufen potato und was damit machen? Etwas wie das:

System.getVariable(input); //which will be 2
System.getVariable("stackOverflow"); //should be -4

Ich habe einiges nachgeschlagen und nicht viel gefunden; Ich habe einen Verweis auf etwas gefunden, das “die Reflection-API” genannt wird, aber das scheint zu kompliziert für diese eine einfache Aufgabe zu sein.

Gibt es dafür eine Möglichkeit und wenn ja, welche? Wenn “Reflection” tatsächlich funktioniert und wenn es der einzige Weg ist, wie würde ich es dann verwenden, um dies zu tun? Die Tutorial-Seite dafür enthält alle möglichen internen Dinge, die ich nicht verstehen kann.

BEARBEITEN: Die muss ich behalten Strings in den Variablen für das, was ich tue. (Ich kann keine verwenden Map)

Die Verwendung von Reflektion scheint kein gutes Design für das zu sein, was Sie hier tun. Es wäre besser, a zu verwenden Map<String, Integer> zum Beispiel:

static final Map<String, Integer> VALUES_BY_NAME;
static {
    final Map<String, Integer> valuesByName = new HashMap<>();
    valuesByName.put("width", 5);
    valuesByName.put("potato", 2);
    VALUES_BY_NAME = Collections.unmodifiableMap(valuesByName);
}

Oder mit Guave:

static final ImmutableMap<String, Integer> VALUES_BY_NAME = ImmutableMap.of(
    "width", 5,
    "potato", 2
);

Oder mit einem Aufzählung:

enum NameValuePair {

    WIDTH("width", 5),
    POTATO("potato", 2);

    private final String name;
    private final int value;

    private NameValuePair(final String name, final int value) {
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public String getValue() {
        return value;
    }

    static NameValuePair getByName(final String name) {
        for (final NameValuePair nvp : values()) {
            if (nvp.getName().equals(name)) {
                return nvp;
            }
        }
        throw new IllegalArgumentException("Invalid name: " + name);
    }
}

Variablennamen sind nur zur Compilerzeit verfügbar. Reflektion gewährt nur Zugriff auf Klassendeklarationen und darin deklarierte Elemente, aber nicht auf lokale Variablen. Ich vermute, dass a Map irgendeiner Art wird eine angemessenere Lösung für Ihr eigentliches Problem sein. Genauer gesagt, check out HashMap und TreeMap.

Anstatt zu versuchen, den Wert eines Variablennamens zu finden, warum verwenden Sie nicht eine Map mit einem Schlüssel/Wert-Paar?

Map<String, Integer> vars = new HashMap<String, Integer>();
vars.put("width",5);
vars.put("area",8);
vars.put("potato", 2);
vars.put("stackOverflow",-4);

Dann könnten Sie wie folgt auf die Eingänge zugreifen:

vars.get(input); //would be 2
vars.get("stackOverflow"); //would be -4

Ich habe eine Lösung für dieses Problem, bei der keine Karte verwendet wird. Ich bin auf diese Technik gestoßen, weil wir mehrere Variablen hatten, die basierend auf etwas im Variablennamen selbst aktualisiert werden mussten. Der beste Weg, dies zu tun, ist jedoch die Verwendung der Getter/Setter anstelle der Variablen.

Nachdem Sie Ihre Klasse erstellt haben, können Sie auf die Methoden zugreifen, indem Sie Methodenobjekte erstellen und sie einzeln aufrufen.

public class FooClass

private String foo1;
private String foo2;

public String getFoo1();
public String getFoo2();

FooClass fooClass = new FooClass();

Method mFoo1 = fooClass.getClass().getMethod("getFoo" + increment + "()");

mFoo1 .invoke(fooClass);

Dies wäre jedoch nicht nur auf inkrementelle Zahlen beschränkt, solange Sie die Zeichenfolge dazu bringen können, genau mit der Methode übereinzustimmen.

String value = "Potato";
Method mPotato = myClass.getClass().getMethod("get" + value+ "()");

mPotato.invoke(myClass);

Ich habe eine andere Lösung ohne Karte:

class Vars {
    Integer potato, stack;
    public Vars(a,b) {
        potato=a;
        stack=b;
    }
}
Object object=(Object)new Vars(1,2);
Class<?> c = object.getClass();
Integer result=(Integer)c.getField("potato").get(object);

Sehr redundant, aber Sie können Ihre Variablennamen beibehalten, wenn Sie eine Karte verwenden:

int width = 5;
int area = 8;
int potato = 2;
int stackOverflow = -4;
Map<String, Integer> map = new HashMap<>();
map.put("width", width);
map.put("area", area);
map.put("potato", potato);
map.put("stackOverflow", stackOverflow);

Aber so eine Aussage:

width = 42;

würde den Wert in der Map nicht ändern:

String input = "width";
map.get(input); // <-- still returns 5.

Nur ein neuer Aufruf von Put behebt Folgendes:

width = 42;
map.put("width", width);
// or
map.put("width", 42);