It's possible add an int and an String in the array ? I said in the same array.
0
Add a comment
|
7 Answers
No, Java is a strongly-typed language. So you cannot add a String and an int to the same array if the array is typed as either String or int.
However if your array is typed as Object, you can add a String and an Integer (an integer literal will be autoboxed) to that same array. This is not recommended and is probably a sign that you should think more about your design. The first question you need to ask yourself is why you need to do this. If you do have a valid reason, then it would be better to convert from one to the other instead of having an array typed as Object.
Having a catch-call array where you can shove in any object in a bad idea for many reasons:
- You are enforcing no separation between the objects. Are the objects actually related to each other? If so you type then using an interface or create an abstract class that each of the types extend.
- Since you have no separation between the objects, anything you pull out of the array is an
Object. How would you know what it is? You need to inspect its type explicitly. This is an extremely cumbersome and unmaintainable design. - You essentially end up losing type-safety and will not be able to benefit from type-mismatch errors that will show up during compilation. This will hide possible errors in your code where you may have forgotten to inspect the type, or where you are casting an object to the wrong type. This can lead to all kinds of nightmarish bugs.
- Your code is going to be littered with explicit checks and casts and will be unmaintainable (by you or anyone else).
- Your code leaks abstraction everywhere. No one can look at the array and realize what the array contains. Anyone who uses your code needs to remember an overwhelming amount of detail as to what types of objects the array can contain.
- Obfuscation is never a valid reason. Code should be clear, easy to read, easy to maintain, and easy to understand (for you and for anyone else who will read your code). Any code that looks obfuscated or is "clever" either needs to be rewritten or documented extensively to explain the reason for its "cleverness". As far as obfuscating the source, it is a non-issue since you're going to be distributing the
.classfiles anyway. You can run that through a decompiler to look at the source code. There is nothing you can do at the source level to satisfactorily obfuscate your code; you're only going to make it difficult for you or anyone else to maintain. Obfuscation can be done at the byte-code level and so that doesn't really apply to this situation.
5 Comments
jli
Why is it "not recommended". I can see potential use cases, especially in obfuscation. I do agree that in most cases it's not necessary though.
corsiKa
@jli let's leave obfuscation for post-compile jar obfuscators. When it comes to code the developers actually write, let's make it as easy to work with as is possible (or at least reasonable).
Vivin Paliath
@jli Was going to comment but then it ended up being rather long, so take a look at my edit.
jli
When I say obfuscation, I mean not only source level but also at the bytecode level. Storing instances of objects in an array can make reflection much more annoying for hackers (as demonstrated by the game RuneScape, which employs this technique).
Vivin Paliath
@jli Obfuscation at the cost of making code unreadable and unmaintainable is not worth it IMO. A dedicated cracker will find a way to crack your game no matter what.
Yes it is possible, but it is not good practice.
Object[] myObjects = new Object[] {array1[i], array2[i], "name1", value1, value2, "name2", value1, value....};
It must be array of objects
4 Comments
Heisenbug
mmm...you can eventually ad an Integer..int isn't an object.
Amir Raminfar
This is such bad design I don't even know why would anybody want to do this.
Max
int is "autoboxed" to Integer
Max
It was not question about: "it is good practice ...", but question "it is possible...". Of course it is not good practice
Strictly speaking: No.
Otherwise: Yes for most practical purposes:
Object[] array = { 42, "foo" };
Please note, that the 42 is not an int but an `Integer´. But due to autoboxing and unboxing you wont notice the difference. The tradeoff is of course performance and garbage collector overhead.
Also the array must be of type Object[], not of type String[] nor of type int[].
Comments
In your string array you could have "123" and then convert it to an int later when you need it.
Comments
You can't add a primitive types (including int) to an array with Objects such as String. However, autoboxing of int to Integer will make this possible if you declare an Object[] array.
Object[] array = new Object[2];
array[0] = "Hello";
array[1] = 42;
Though I wouldn't recommend doing this if modeling this String and int as attributes of a class would work.
Comments
You can use java.util.ArrayList to do this. You will need to make sure that you check carefully what you are getting when you pull items out though.
3 Comments
jli
ArrayList is no better than a normal array in this case, it would be the same as an Object array.
dann.dev
True, but I thought it might be easier for the user to try, as by the question I'm guessing he's pretty new to java/programming
jli
Works out to the same thing, and no easier to use.
Yes it definitely is possible, just have an array of raw objects.
For example:
Object[] arr = new Object[10];
arr[0] = 10; // boxed to Integer class
arr[1] = "foo"; // String class
Then you can use instanceof to determine the type of object stored at a particular index.
For example:
if (arr[0] instanceof Integer) ((Integer) arr[0]) += 10;
Note that this is not necessarily a good practise to get used to, but it does have applications.
