Connect and share knowledge within a single location that is structured and easy to search. I have to ask a question in return: is your GenSet "checked" or "unchecked"? What does that mean? Checked : strong typing. GenSet knows explicitly what type of objects it contains i. See Collections.
Unchecked : weak typing. No type checking is actually done on any of the objects passed as argument. Note that the component type of the array should be the erasure of the type parameter:. All of this results from a known, and deliberate, weakness of generics in Java: it was implemented using erasure, so "generic" classes don't know what type argument they were created with at run time, and therefore can not provide type-safety unless some explicit mechanism type-checking is implemented.
This is one of the suggested ways of implementing a generic collection in Effective Java; Item No type errors, no need to cast the array repeatedly.
However this triggers a warning because it is potentially dangerous, and should be used with caution. As detailed in the comments, this Object[] is now masquerading as our E[] type, and can cause unexpected errors or ClassCastException s if used unsafely.
As a rule of thumb, this behavior is safe as long as the cast array is used internally e. Should you need to return an array of a generic type to other code, the reflection Array class you mention is the right way to go.
Worth mentioning that wherever possible, you'll have a much happier time working with List s rather than arrays if you're using generics. Certainly sometimes you don't have a choice, but using the collections framework is far more robust. That compiles without warnings, and as you can see in main , for whatever type you declare an instance of GenSet as, you can assign a to an array of that type, and you can assign an element from a to a variable of that type, meaning that the array and the values in the array are of the correct type.
It works by using class literals as runtime type tokens, as discussed in the Java Tutorials. Class literals are treated by the compiler as instances of java. To use one, simply follow the name of a class with. So, String. This also works for interfaces, enums, any-dimensional arrays e. So, whenever you call the constructor for GenSet , you pass in a class literal for the first argument representing an array of the GenSet instance's declared type e.
Note that you won't be able to get an array of primitives, since primitives can't be used for type variables. Inside the constructor, calling the method cast returns the passed Object argument cast to the class represented by the Class object on which the method was called.
Calling the static method newInstance in java. Array returns as an Object an array of the type represented by the Class object passed as the first argument and of the length specified by the int passed as the second argument. Calling the method getComponentType returns a Class object representing the component type of the array represented by the Class object on which the method was called e. That last sentence isn't entirely accurate. Calling String[]. Regarding Joachim Sauer's comment on this answer I don't have enough reputation to comment on it myself , the example using the cast to T[] will result in a warning because the compiler can't guarantee type safety in that case.
See Array. In Java 8, we can do a kind of generic array creation using a lambda or method reference. This is similar to the reflective approach which passes a Class , but here we aren't using reflection. Prefer lists to arrays. Your code will work, although it will generate an unchecked warning which you could suppress with the following annotation:.
Java generics work by checking types at compile time and inserting appropriate casts, but erasing the types in the compiled files. This makes generic libraries usable by code which doesn't understand generics which was a deliberate design decision but which means you can't normally find out what the type is at run time. Not a subclass of T, not a superclass of T, but precisely T. This then means that you can create an array object of the appropriate type in your constructor, which means that the type of the objects you store in your collection will have their types checked at the point they are added to the collection.
Don't worry about typecasting warnings when you are writing a generic class; worry when you are using it. The example is using Java reflection to create an array. Doing this is generally not recommended, since it isn't typesafe. Instead, what you should do is just use an internal List, and avoid the array at all.
I have found a quick and easy way that works for me. Note that i have only used this on Java JDK 8. I don't know if it will work with previous versions. Although we cannot instantiate a generic array of a specific type parameter, we can pass an already created array to a generic class constructor.
For more flexibility with your arrays you can use a linked list eg. ArrayList class. I made this code snippet to reflectively instantiate a class which is passed for a simple automated test utility. Class can be both primitive int. The forced cast suggested by other people did not work for me, throwing an exception of illegal casting. This way you get an array of type K if the item only has the value or any generic type you want defined in the class Item.
Actually an easier way to do so, is to create an array of objects and cast it to your desired type like the following example:. As others have said generics are "erased" during compilation.
So at runtime an instance of a generic doesn't know what its component type is. The reason for this is historical, Sun wanted to add generics without breaking the existing interface both source and binary.
This is not true with generics. So, the following declaration is not valid, and won't compile:. Generics were introduced in Java to enforce stronger type check at compile time. As such, generic types don't have any type information at runtime due to type erasure. However, arrays carry with them the runtime type information of the component type.
At runtime, arrays use Array Store check to check whether you are inserting elements compatible with actual array type. So, the following code:.
With generics, this is not possible, as the compiler will try to prevent the runtime exception by providing compile time check, by avoiding creation of reference like this, as shown above.
Creation of array whose component type is either a type parameter , a concrete parameterized type or a bounded wildcard parameterized type , is type-unsafe. Since the type of T is not known at runtime, the array created is actually an Object[]. So the above method at runtime will look like:. Here's the problem. You have just assigned an Object[] to a reference of Integer[]. The above code will compile fine, but will fail at runtime. The above code have the same implications as explained above.
If you notice, the compiler would be giving you an Unchecked Cast Warning there, as you are typecasting to an array of unknown component type. That means, the cast may fail at runtime. For e. The issue is the same.
So, had the creation of such arrays allowed, let's see what could happen:. Now the ArrayStoreCheck in the above case will succeed at runtime although that should have thrown an ArrayStoreException.
And that makes sense, as there is no type associated at all. So there is nothing to loose as a result of type erasure. So, it is perfectly type-safe to create an array of such type. So, it won't issue an ArrayStoreException at runtime. We can also use a for loop inside another for loop to get the elements of a two-dimensional array we still have to point to the two indexes :.
Create an array of type String called cars. We just launched W3Schools videos. Get certified by completing a course today!
If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:. Report Error. Your message has been sent to W3Schools. SuppressWarnings "unchecked" comes to the rescue! Just be careful to always apply it to as small a scope as possible as it does obscure potential problems in your code. Priyesh Diukar Priyesh Diukar 1, 11 11 silver badges 18 18 bronze badges.
Tom Hawtin - tackline Tom Hawtin - tackline k 30 30 gold badges silver badges bronze badges. It is confusing in the beginning. Action i an interface, it is SomeAction we are trying get an instance of. We only have the name of SomeAction available at runtime. But assuming no exception is thrown there, the second line is guaranteed to work.
What you are really describing is that SomeAction. Show 3 more comments. MasterAM This doesn't really provide a full answer to the question. If you think you have something to add, edit this answer.
Sign up or log in Sign up using Google. Sign up using Facebook. Sign up using Email and Password. Post as a guest Name. Email Required, but never shown. The Overflow Blog. Podcast Making Agile work for data science. Stack Gives Back Featured on Meta. New post summary designs on greatest hits now, everywhere else eventually. Visit chat.
0コメント