In Java, Is it possible to concatenate the value of a variable into a variable name (Sounds messed up, but please read details)

Question

Basically I have a variable, zlort = one;

I want to concatenate the value of zlort into a variable (object reference) name.

Like

BankAccount Accountzlort = new BankAccount;

I want the zlort in Account.zlort to actually be the replaced with value of zlort (one--meaning I want the value to be Accountone), and not zlort itself.

Is it possible to do this?

Thanks!

Answer 1

No you can't, but you might put the instance in a map:

Map<String,BankAccount> map = new HashMap<String,BankAccount>();
map.put("Account" + zlort, new BankAccount());

Answer 2

After reading the explanations in your comments, the fact that you can't use an array but can use an `ArrayList'...

Rather than creating a new variable name (or array element, or map value) for each BankAccount, you can probably use scope to your advantage.

Scope is the concept that a reference to a variable only has meaning within a certain part of code. If you declare a variable inside a method, that variable can only be seen within that method. A variable declared within a block (a loop, if statement, etc ) can only be seen from within that block.

Class fields have a different kind of scoping that can be adjusted with keywords (see here).

For example:

public class ScopeExample

    int classInt = 10;

    public void method() {
        int methodInt = 0; // This integer can only be seen by code in 
                           // this method
    }

    public void method2() {
        //doSomething(methodInt) // This line won't compile because i is 
                                 // declared in a different method!
        doSomething(classInt); // This line will compile and work 
                               // because x is declared in the class that 
                               // contains this method.
        int index = 0;
        while (index < 3) {
            int whileInt = index; // This integer can only be seen from within 
                                  // this while loop! It is created each 
                                  // loop iteration.
            doSomething(whileInt);
        }
        doSomething(whileInt); //This line won't work, whileInt is out of scope!
    }

    public doSomething(int a) {
        System.out.println(a);
    }

}

SO! If you create a BankAccount object within the loop, you don't have to worry about creating a new name for the next one. Each time the loop iterates it will become a new object (when you create it).

If you have to store it, you definitely will need to use an array or other data structure (ArrayList!).

Building on the idea of scope, you -can- have the same variable name for each new BankAccount. A variable reference name isn't guaranteed to be paired with the object that it refers to. That is a convenience to the programmer, so you don't have to know the exact memory address it is being stored in.

For example:

public static void main(String[] args) {

    Object o;
    int i = 0;
    while (i < 5) {
        Object reference = new Object(); // Create a new Object and store 
                                         // it in 'reference'
        o = obj; // The Object 'o' now refers to the object in 'reference'
        i++;
    }
    System.out.println(o); // This should print information about the 
                           // LAST object created.
}

The new Object created in the loop does not belong to 'obj'. You as a programmer use 'obj' to point to the Object. The program doesn't really know what obj means, other than the fact that it points to the Object you just created.

Finally, you can use this along with an ArrayList to make your life easier.

public static void main(String[] args) {

    // Our new ArrayList to hold our objects!
    ArrayList<Object> stuff = new ArrayList<Object>();

    int i = 0;
    while (i < 5) {
        Object obj = new Object(); // Create an object and make obj point to it.
        stuff.add(obj); // Put "the object that 'obj' points to" in 'stuff'.
        i++;
    }

    // This loop goes through all of the Objects in the ArrayList and prints them
    for (int index = 0; index < stuff.size(); index++) {
        System.out.println(stuff.get(i)); // This will print a single 
                                          // object in the ArrayList each time.
    }
}

Answer 3

It is not possible to change the name of a variable at runtime. That would lead to extreme security and stability problems when dealing with any real-world application.

However, as the two answers here have mentioned, a HashMap might acheive what you are looking for. (See the javadoc!!)

A HashMap (or any other map, for that matter) maps a Key to a Value. The concept is similar to a variable, which is a name -> value mapping. The only difference is that variables are part of the actual program code, which is effectively unmodifiable after compiling. A Map is a data structure that can be modified by the running program. This allows you to freely add key-value pairings to it.

Note that in Java, type-safety is encouraged through the use of Generics. Basically this ensures that the key can only be of one type (e.g. String) and the value can be of only one type (BankAccount). A thorough coverage of Generics can be found here.

You would declare this as follows:

Map<String, BankAccount> accounts = new HashMap<String, BankAccount>();

And then to add a key-value pair to the map, you would use the put() method (which 'puts' a value into the map, associated with a key)

String key = "Key"
BankAccount value = new BankAccount();
accounts.put(key, value);

To retrieve it, you would use the get() method.

BankAccount retrievedValue;
retrievedValue = accounts.get(key);

Answer 4

If you mean dynamically choosing the name to assign a variable to, then no.

You could use a HashMap to achieve the same effect.