Prendre des variables par nom à partir d'une Chaîne

Exemple de code:

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

Maintenant, dire que je veux avoir de l'utilisateur en entrée une chaîne de caractères:

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

Alors, disent les entrées de l'utilisateur potato. Comment pourrais-je récupérer la variable nommée potato et faire des trucs avec elle? Quelque chose comme ceci:

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

J'ai regardé certaines choses et ne pas trouver beaucoup de choses; j'ai trouvé une référence à quelque chose appelé "l'API Reflection", mais qui semble trop compliqué pour que ce simple tâche.

Est-il un moyen de le faire, et si oui, quel est-il? Si "Réflexion" ne fonctionne en effet et si c'est la seule manière de faire, alors comment pourrais-je l'utiliser pour ce faire? La page du tutoriel pour il a toutes sortes de interne des trucs que je ne peux pas donner un sens.

EDIT: j'ai besoin de garder le Strings dans les variables pour ce que je suis en train de faire. (Je ne peux pas utiliser un Map)

Vous devez utiliser la réflexion.
Non, vous voulez utiliser un Map de chaînes à ints. La réflexion est trop pour cette tâche.
Vous pouvez ajouter vos valeurs dans un dictionnaire. Ainsi, vous obtenez une paire de clés de valeur.
Carte. simple et agréable.
Je ne pense pas que ce soit possible via la réflexion pour les variables de la méthode, seuls les attributs de classe...

OriginalL'auteur Doorknob | 2012-11-08

L'aide de la réflexion ne semble pas être une bonne conception pour ce que vous faites ici. Il serait préférable d'utiliser un Map<String, Integer> par exemple:

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

Ou avec Goyave:

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

Ou avec un enum:

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

J'ai besoin de garder le Strings dans la variable pour ce que je suis en train de faire.
Pensez à utiliser un enum (voir mon edit) - que vous obtient plus près.

OriginalL'auteur Paul Bellora

3

Au lieu d'essayer de trouver la valeur d'un nom de variable, pourquoi ne pas utiliser une Carte avec une paire clé/valeur?
```
Map<String, Integer> vars = new HashMap<String, Integer>();
vars.put("width",5);
vars.put("area",8);
vars.put("potato", 2);
vars.put("stackOverflow",-4);
```
Ensuite, vous pouvez accéder aux intrants comme suit:
```
vars.get(input); //would be 2
vars.get("stackOverflow"); //would be -4
```
N'oubliez pas qu'il doit être un Map<String, Integer> en Java.

OriginalL'auteur mbumiller
2

Les noms de variables sont disponibles uniquement au compilateur de temps. La réflexion ne donne accès qu'aux déclarations de classe et les éléments déclarés à l'intérieur d'eux, mais pas pour les variables locales. Je soupçonne qu'un Map d'une certaine sorte, sera une solution plus appropriée à votre problème réel. Plus précisément, découvrez HashMap et TreeMap.

OriginalL'auteur Code-Apprentice

Très redondant, mais vous pouvez garder vos noms de variable lors de l'utilisation d'une carte:

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

Mais une déclaration comme ceci:

width = 42;

ne serait pas modifier la valeur de la Carte:

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

Seulement un nouvel appel de mettre des correctifs:

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

OriginalL'auteur jlordo

J'ai une solution pour ce problème qui ne fait pas intervenir à l'aide d'une carte. Je suis tombé sur cette technique, car nous avons eu plusieurs variables qui doivent être mise à jour basé sur quelque chose dans le nom de la variable elle-même. Cependant, la meilleure façon de le faire est d'utiliser les getters/setters plutôt que les variables.

Après la création de votre classe, vous pouvez accéder aux méthodes par une Méthode de création d'objets et de faire appel à eux individuellement.

public class FooClass

private String foo1;<br>
private String foo2;<br>

public String getFoo1()<br>
public String getFoo2()<br>

FooClass fooClass = new FooClass();

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

mFoo1 .invoke(fooClass);

However, this would not be limited to only incremental numbers, as long as you can get the string to match the method exactly.

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

mPotato.invoke(myClass);

OriginalL'auteur Robert Greathouse

J'ai une autre solution sans carte :

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

OriginalL'auteur LMD

Vous devez vous connecter pour publier un commentaire.