CODEWITHSUNDEEP
javavariables
Syeda Zunaira
Syeda Zunaira

Reputation: 5207

create variables dynamically, Data Types of java Variables

As we know variables are of different data types, but which data type are their names of?
As it seems they are String, but if they are String then this should be allowed:

int i=6;
String [] arr+i;

...as we can add an int to a String.
So if these are not String then what are they?
And if we want to create variable names dynamically how can we create it? By dynamically I mean whenever the user clicks on a specific JComponent, a new variable is created, like:

int i=0;
//on first click
String str+i; ///str0
i++;
///on 2nd click
String str+i;   ////str1
///i++;

How can I do it?

Upvotes: 1

Views: 10654

Answers (6)

Massab
Massab

Reputation: 1050

You can not create dynamic variables in Java because Java isn't a scripting language. YOu need to create variables in source code. But Java provides other ways to do this. You can use arrays or Map<String, String> etc for this purpose.

Map<String, String> map= new HashMap<>(); 
int i=0; 
while(true) {
    // you can use whatever condition you need
    details.put("key" + i, "val: "+i);
    i++
    // some condition to break the loop 
}

Upvotes: 3

patrick waiyego
patrick waiyego

Reputation: 64

CONSIDER THIS:

public class Test {

public Test() {

}

public static void main(String[] args) {

//  GenericType<Integer> intObj;//creates a generic type for integers
    //String type
    GenericType<String> strObj=new GenericType<String>("My data");

    System.out.println("Value is " +strObj.getValue());



    }

}

class GenericType<GT>{
GT  obT;

 GenericType(GT o){
obT=o; 
 }

 GT getValue(){
 return obT;
 }

 void showType(){
System.out.println("Type of GT is " +obT.getClass().getName()); 
 }

}

GT is the name of a type parameter. This name is used as a placeholder for the actual type that will be passed to GenericType when an object is created. Thus, GT is used within GenericType whenever the type parameter is needed. Notice that GT is contained within < >. This syntax can be generalized. Whenever a type parameter is being declared, it is specified within angle brackets. Because Gen uses a type parameter, Gen is a generic class, which is also called a parameterized type.

as mentioned above JAVA provide you with advanced generic classes such as ArrayList, Vectors, Hashmaps to cater for such scenarios .

previous thread similar: How to create new variable in java dynamically

Upvotes: 1

patrick waiyego
patrick waiyego

Reputation: 64

Firstly variables can be categorized into two. primitives (standard ) types such as int, float,double, char,boolean, byte... and non-primitives(user defined)types such as String, Integer, Float, Double. String type fall under non primitive , its a class provided by java.lang Api such that when you create a string variable you are indeed creating an object EX String str; str is an object it can as well be declared as String str=new String();

hence the string class consist of helper methods that may help to achieve your objective, you can as well use concatenation/joining of strings as follows:

class Demo{
String str;
static int i;
JButton but=new JButton("click me!");
.....

public static void actionPeaformed(ActionEvent e){
Object source=e.getSource();
 str="msg";
if(source==but){

String newStr;

newStr=str+i;

System.out.println(newStr);

}


}

}

where str may contain some message/text eg from label/elsewhere for every click

Upvotes: 0

dramzy
dramzy

Reputation: 1429

Java identifiers are not of any type and definitely not String. You can't do this in java, instead, you use a data structure to use these values like ArrayList<String>and store the nth String in the nth index of the data structure like so: 

ArrayList<String> strings= new ArrayList<String>(); // Create a new empty List
strings.add(index, string);  //add string at index position of the List; can be replaced with strings.add(string) if the strings are being sequentially added

Upvotes: 3

candied_orange
candied_orange

Reputation: 7308

Java does not work this way. Other languages do but Java isn't one of them. You can't dynamically manipulate the names of variables because they are fixed at compile time. However, in some interpreted scripting languages such a thing is possible.

To be more accurate if they are fixed to be anything at all they are fixed at compile time. If java is not compiled in debug mode the names of the variables cease to be at all. They just become addresses of memory locations.

See this for details: Can I get information about the local variables using Java reflection?

Upvotes: 0

Mitch Talmadge
Mitch Talmadge

Reputation: 4755

Variable names do not have data types. They are merely references. They are not a String, they are not an int, they are just names. You can't dynamically declare a variable with a name derived from the name of another variable, Java does not work this way.

Upvotes: 0

Related Questions