What is a raw type and why shouldn t we use it

Question

Questions    What are raw types in Java  and why do I often hear that they shouldn t be used in new code  What is the alternative if we can t use raw types  and how is it better

User · Answer

Raw types are fine when they express what you want to express.

For example, a deserialisation function might return a List, but it doesn't know the list's element type. So List is the appropriate return type here.

User · Answer

What is a raw type and why do I often hear that they shouldn t be used in new code   A  raw type  is the use of a generic class without specifying a type argument s  for its parameterized type s   e g  using List instead of List lt String gt   When generics were introduced into Java  several classes were updated to use generics   Using these class as a  raw type   without specifying a type argument  allowed legacy code to still compile    Raw types  are used for backwards compatibility  Their use in new code is not recommended because using the generic class with a type argument allows for stronger typing  which in turn may improve code understandability and lead to catching potential problems earlier   What is the alternative if we can t use raw types  and how is it better   The preferred alternative is to use generic classes as intended - with a suitable type argument  e g  List lt String gt    This allows the programmer to specify types more specifically  conveys more meaning to future maintainers about the intended use of a variable or data structure  and it allows compiler to enforce better type-safety   These advantages together may improve code quality and help prevent the introduction of some coding errors   For example  for a method where the programmer wants to ensure a List variable called  names  contains only Strings   List lt String gt  names   new ArrayList lt String gt     names add  John                OK names add new Integer 1        compile error

User · Answer

private static List lt String gt  list   new ArrayList lt String gt       You should specify the type-parameter    The warning advises that types that are defined to support generics should be parameterized  rather than using their raw form   List is defined to support generics  public class List lt E gt   This allows many type-safe operations  that are checked compile-time

User · Answer

Here I am Considering multiple cases  through which you can clearify  the concept  1  ArrayList lt String gt  arr   new ArrayList lt String gt     2  ArrayList lt String gt  arr   new ArrayList    3  ArrayList arr   new ArrayList lt String gt       Case 1  ArrayList lt String gt  arr it is a ArrayList reference variable with type String which reference to a ArralyList Object of Type String  It means it can hold only String type Object   It is a Strict to String not  a Raw Type so  It will never raise an warning        arr add  hello      alone statement will compile successfully and no warning       arr add 23      prone to compile time error         error  no suitable method found for add int    Case 2  In this case ArrayList lt String gt  arr is a strict type but your Object new ArrayList    is a raw type        arr add  hello      alone this compile but raise the warning      arr add 23      again prone to compile time error        error  no suitable method found for add int    here arr is a Strict type  So  It will raise compile time error when adding a integer      Warning  - A Raw Type Object is referenced to a Strict type Referenced Variable of ArrayList    Case 3  In this case ArrayList arr is a raw type but your Object new ArrayList lt String gt     is a Strict type        arr add  hello          arr add 23      compiles fine but raise the warning    It will add any type of Object into it because arr is a Raw Type      Warning  - A Strict Type Object is referenced to a raw type referenced Variable

User · Answer

What are raw types in Java  and why do I often hear that they shouldn t be used in new code    Raw-types are ancient history of the Java language  In the beginning there were Collections and they held Objects nothing more and nothing less  Every operation on Collections required casts from Object to the desired type   List aList   new ArrayList    String s    Hello World    aList add s   String c    String aList get 0     While this worked most of the time  errors did happen  List aNumberList   new ArrayList    String one    1    Number one aNumberList add one   Integer iOne    Integer aNumberList get 0    Insert ClassCastException here   The old typeless collections could not enforce type-safety so the programmer had to remember what he stored within a collection  Generics where invented to get around this limitation  the developer would declare the stored type once and the compiler would do it instead   List lt String gt  aNumberList   new ArrayList lt String gt     aNumberList add  one    Integer iOne   aNumberList get 0    Compile time error String sOne   aNumberList get 0    works fine   For Comparison      Old style collections now known as raw types List aList   new ArrayList      Could contain anything    New style collections with Generics List lt String gt  aList   new ArrayList lt String gt       Contains only Strings   More complex the Compareable interface     raw  not type save can compare with Other classes class MyCompareAble implements CompareAble      int id     public int compareTo Object other      return this id -   MyCompareAble other  id       Generic class MyCompareAble implements CompareAble lt MyCompareAble gt       int id     public int compareTo MyCompareAble other      return this id - other id       Note that it is impossible to implement the CompareAble interface with compareTo MyCompareAble  with raw types  Why you should not use them    Any Object stored in a Collection has to be cast before it can be used Using generics enables compile time checks Using raw types is the same as storing each value as Object   What the compiler does  Generics are backward compatible  they use the same java classes as the raw types do  The magic happens mostly at compile time   List lt String gt  someStrings   new ArrayList lt String gt     someStrings add  one    String one   someStrings get 0     Will be compiled as   List someStrings   new ArrayList    someStrings add  one     String one    String someStrings get 0     This is the same code you would write if you used the raw types directly  Thought I m not sure what happens with the CompareAble interface  I guess that it creates two compareTo functions  one taking a MyCompareAble and the other taking an Object and passing it to the first after casting it   What are the alternatives to raw types  Use generics

User · Answer

A  raw  type in Java is a class which is non-generic and deals with  raw  Objects  rather than type-safe generic type parameters   For example  before Java generics was available  you would use a collection class like this   LinkedList list   new LinkedList    list add new MyObject     MyObject myObject    MyObject list get 0     When you add your object to the list  it doesn t care what type of object it is  and when you get it from the list  you have to explicitly cast it to the type you are expecting   Using generics  you remove the  unknown  factor  because you must explicitly specify which type of objects can go in the list   LinkedList lt MyObject gt  list   new LinkedList lt MyObject gt     list add new MyObject     MyObject myObject   list get 0     Notice that with generics you don t have to cast the object coming from the get call  the collection is pre-defined to only work with MyObject   This very fact is the main driving factor for generics   It changes a source of runtime errors into something that can be checked at compile time

User · Answer

tutorial page     A raw type is the name of a generic class or interface without any type arguments  For example  given the generic Box class     public class Box lt T gt        public void set T t                               To create a parameterized type of Box  you supply an actual type argument for the formal type parameter T     Box lt Integer gt  intBox   new Box lt  gt       If the actual type argument is omitted  you create a raw type of Box     Box rawBox   new Box

User · Answer

What is saying is that your list is a List of unespecified objects  That is that Java does not know what kind of objects are inside the list  Then when you want to iterate the list you have to cast every element  to be able to access the properties of that element  in this case  String    In general is a better idea to parametrize the collections  so you don t have conversion problems  you will only be able to add elements of the parametrized type and your editor will offer you the appropiate methods to select   private static List lt String gt  list   new ArrayList lt String gt

User · Answer

What is a raw type  The Java Language Specification defines a raw type as follows  JLS 4 8 Raw Types  A raw type is defined to be one of   The reference type that is formed by taking the name of a generic type declaration without an accompanying type argument list   An array type whose element type is a raw type   A non-static member type of a raw type R that is not inherited from a superclass or superinterface of R     Here s an example to illustrate  public class MyType lt E gt        class Inner         static class Nested              public static void main String   args            MyType mt              warning  MyType is a raw type         MyType Inner inn       warning  MyType Inner is a raw type          MyType Nested nest     no warning  not parameterized type         MyType lt Object gt  mt1     no warning  type parameter given         MyType lt   gt  mt2          no warning  type parameter given  wildcard OK            Here  MyType lt E gt  is a parameterized type  JLS 4 5   It is common to colloquially refer to this type as simply MyType for short  but technically the name is MyType lt E gt   mt has a raw type  and generates a compilation warning  by the first bullet point in the above definition  inn also has a raw type by the third bullet point  MyType Nested is not a parameterized type  even though it s a member type of a parameterized type MyType lt E gt   because it s static  mt1  and mt2 are both declared with actual type parameters  so they re not raw types   What s so special about raw types  Essentially  raw types behaves just like they were before generics were introduced  That is  the following is entirely legal at compile-time  List names   new ArrayList       warning  raw type  names add  quot John quot    names add  quot Mary quot    names add Boolean FALSE      not a compilation error   The above code runs just fine  but suppose you also have the following  for  Object o   names        String name    String  o      System out println name        throws ClassCastException          java lang Boolean cannot be cast to java lang String  Now we run into trouble at run-time  because names contains something that isn t an instanceof String  Presumably  if you want names to contain only String  you could perhaps still use a raw type and manually check every add yourself  and then manually cast to String every item from names  Even better  though is NOT to use a raw type and let the compiler do all the work for you  harnessing the power of Java generics  List lt String gt  names   new ArrayList lt String gt     names add  quot John quot    names add  quot Mary quot    names add Boolean FALSE      compilation error   Of course  if you DO want names to allow a Boolean  then you can declare it as List lt Object gt  names  and the above code would compile  See also  Java Tutorials Generics   How s a raw type different from using  lt Object gt  as type parameters  The following is a quote from Effective Java 2nd Edition  Item 23  Don t use raw types in new code   Just what is the difference between the raw type List and the parameterized type List lt Object gt   Loosely speaking  the former has opted out generic type checking  while the latter explicitly told the compiler that it is capable of holding objects of any type  While you can pass a List lt String gt  to a parameter of type List  you can t pass it to a parameter of type List lt Object gt   There are subtyping rules for generics  and List lt String gt  is a subtype of the raw type List  but not of the parameterized type List lt Object gt   As a consequence  you lose type safety if you use raw type like List  but not if you use a parameterized type like List lt Object gt    To illustrate the point  consider the following method which takes a List lt Object gt  and appends a new Object    void appendNewObject List lt Object gt  list       list add new Object        Generics in Java are invariant  A List lt String gt  is not a List lt Object gt   so the following would generate a compiler warning  List lt String gt  names   new ArrayList lt String gt     appendNewObject names      compilation error   If you had declared appendNewObject to take a raw type List as parameter  then this would compile  and you d therefore lose the type safety that you get from generics  See also  What is the difference between  lt E extends Number gt  and  lt Number gt   java generics  not  covariance   How s a raw type different from using  lt   gt  as a type parameter  List lt Object gt   List lt String gt   etc are all List lt   gt   so it may be tempting to just say that they re just List instead  However  there is a major difference  since a List lt E gt  defines only add E   you can t add just any arbitrary object to a List lt   gt   On the other hand  since the raw type List does not have type safety  you can add just about anything to a List  Consider the following variation of the previous snippet  static void appendNewObject List lt   gt  list        list add new Object        compilation error           List lt String gt  names   new ArrayList lt String gt     appendNewObject names      this part is fine   The compiler did a wonderful job of protecting you from potentially violating the type invariance of the List lt   gt   If you had declared the parameter as the raw type List list  then the code would compile  and you d violate the type invariant of List lt String gt  names   A raw type is the erasure of that type Back to JLS 4 8   It is possible to use as a type the erasure of a parameterized type or the erasure of an array type whose element type is a parameterized type  Such a type is called a raw type        The superclasses  respectively  superinterfaces  of a raw type are the erasures of the superclasses  superinterfaces  of any of the parameterizations of the generic type  The type of a constructor  instance method  or non-static field of a raw type C that is not inherited from its superclasses or superinterfaces is the raw type that corresponds to the erasure of its type in the generic declaration corresponding to C   In simpler terms  when a raw type is used  the constructors  instance methods and non-static fields are also erased  Take the following example  class MyType lt E gt        List lt String gt  getNames             return Arrays asList  quot John quot    quot Mary quot               public static void main String   args            MyType rawType   new MyType               unchecked warning             required  List lt String gt  found  List         List lt String gt  names   rawType getNames               compilation error             incompatible types  Object cannot be converted to String         for  String str   rawType getNames                System out print str            When we use the raw MyType  getNames becomes erased as well  so that it returns a raw List  JLS 4 6 continues to explain the following   Type erasure also maps the signature of a constructor or method to a signature that has no parameterized types or type variables  The erasure of a constructor or method signature s is a signature consisting of the same name as s and the erasures of all the formal parameter types given in s  The return type of a method and the type parameters of a generic method or constructor also undergo erasure if the method or constructor s signature is erased  The erasure of the signature of a generic method has no type parameters   The following bug report contains some thoughts from Maurizio Cimadamore  a compiler dev  and Alex Buckley  one of the authors of the JLS  on why this sort of behavior ought to occur  https   bugs openjdk java net browse JDK-6400189   In short  it makes the specification simpler    If it s unsafe  why is it allowed to use a raw type  Here s another quote from JLS 4 8   The use of raw types is allowed only as a concession to compatibility of legacy code  The use of raw types in code written after the introduction of genericity into the Java programming language is strongly discouraged  It is possible that future versions of the Java programming language will disallow the use of raw types   Effective Java 2nd Edition also has this to add   Given that you shouldn t use raw types  why did the language designers allow them  To provide compatibility  The Java platform was about to enter its second decade when generics were introduced  and there was an enormous amount of Java code in existence that did not use generics  It was deemed critical that all this code remains legal and interoperable with new code that does use generics  It had to be legal to pass instances of parameterized types to methods that were designed for use with ordinary types  and vice versa  This requirement  known as migration compatibility  drove the decision to support raw types   In summary  raw types should NEVER be used in new code  You should always use parameterized types   Are there no exceptions  Unfortunately  because Java generics are non-reified  there are two exceptions where raw types must be used in new code   Class literals  e g  List class  not List lt String gt  class instanceof operand  e g  o instanceof Set  not o instanceof Set lt String gt   See also  Why is Collection lt String gt  class Illegal

User · Answer

The compiler wants you to write this   private static List lt String gt  list   new ArrayList lt String gt       because otherwise  you could add any type you like into list  making the instantiation as new ArrayList lt String gt    pointless  Java generics are a compile-time feature only  so an object created with new ArrayList lt String gt    will happily accept Integer or JFrame elements if assigned to a reference of the  raw type  List - the object itself knows nothing about what types it s supposed to contain  only the compiler does

User · Answer

A raw type is the name of a generic class or interface without any type arguments  For example  given the generic Box class  public class Box lt T gt        public void set T t                              To create a parameterized type of Box lt T gt   you supply an actual type argument for the formal type parameter T  Box lt Integer gt  intBox   new Box lt  gt      If the actual type argument is omitted  you create a raw type of Box lt T gt   Box rawBox   new Box     Therefore  Box is the raw type of the generic type Box lt T gt   However  a non-generic class or interface type is not a raw type  Raw types show up in legacy code because lots of API classes  such as the Collections classes  were not generic prior to JDK 5 0  When using raw types  you essentially get pre-generics behavior     a Box gives you Objects  For backward compatibility  assigning a parameterized type to its raw type is allowed  Box lt String gt  stringBox   new Box lt  gt     Box rawBox   stringBox                   OK  But if you assign a raw type to a parameterized type  you get a warning  Box rawBox   new Box                 rawBox is a raw type of Box lt T gt  Box lt Integer gt  intBox   rawBox         warning  unchecked conversion  You also get a warning if you use a raw type to invoke generic methods defined in the corresponding generic type  Box lt String gt  stringBox   new Box lt  gt     Box rawBox   stringBox  rawBox set 8       warning  unchecked invocation to set T   The warning shows that raw types bypass generic type checks  deferring the catch of unsafe code to runtime  Therefore  you should avoid using raw types  The Type Erasure section has more information on how the Java compiler uses raw types  Unchecked Error Messages As mentioned previously  when mixing legacy code with generic code  you may encounter warning messages similar to the following   Note  Example java uses unchecked or unsafe operations  Note  Recompile with -Xlint unchecked for details   This can happen when using an older API that operates on raw types  as shown in the following example  public class WarningDemo       public static void main String   args           Box lt Integer gt  bi          bi   createBox               static Box createBox            return new Box             The term  quot unchecked quot  means that the compiler does not have enough type information to perform all type checks necessary to ensure type safety  The  quot unchecked quot  warning is disabled  by default  though the compiler gives a hint  To see all  quot unchecked quot  warnings  recompile with -Xlint unchecked  Recompiling the previous example with -Xlint unchecked reveals the following additional information  WarningDemo java 4  warning   unchecked  unchecked conversion found     Box required  Box lt java lang Integer gt          bi   createBox                            1 warning  To completely disable unchecked warnings  use the -Xlint -unchecked flag  The  SuppressWarnings  quot unchecked quot   annotation suppresses unchecked warnings  If you are unfamiliar with the  SuppressWarnings syntax  see Annotations  Original source  Java Tutorials

User · Answer

Avoid raw types     Raw types refer to using a generic type without specifying a type parameter    For example    A list is a raw type  while List lt String gt  is a parameterized type   When generics were introduced in JDK 1 5  raw types were retained only to maintain backwards compatibility with older versions of Java  Although using raw types is still possible   They should be avoided    They usually require casts They aren t type safe  and some important kinds of errors will only appear at runtime They are less expressive  and don t self-document in the same way as parameterized types Example   import java util     public final class AvoidRawTypes    void withRawType            Raw List doesn t self-document         doesn t state explicitly what it can contain      List stars   Arrays asList  Arcturus    Vega    Altair         Iterator iter   stars iterator         while  iter hasNext               String star    String  iter next      cast needed          log star             void withParameterizedType          List  lt  String  gt  stars   Arrays asList  Spica    Regulus    Antares         for  String star  stars             log star             private void log Object message         System out println Objects toString message             For reference  https   docs oracle com javase tutorial java generics rawTypes html

User · Answer

Here s another case where raw types will bite you  public class StrangeClass lt T gt       SuppressWarnings  quot unchecked quot     public  lt X gt  X getSomethingElse         return  X  quot Testing something else  quot          public static void main String   args        final StrangeClass lt String gt  withGeneric      new StrangeClass lt  gt         final StrangeClass         withoutGeneric   new StrangeClass        final String               value1                                 value2          Compiles     value1   withGeneric getSomethingElse            Produces compile error         incompatible types  java lang Object cannot be converted to java lang String     value2   withoutGeneric getSomethingElse           This is counter-intuitive because you d expect the raw type to only affect methods bound to the class type parameter  but it actually also affects generic methods with their own type parameters  As was mentioned in the accepted answer  you lose all support for generics within the code of the raw type  Every type parameter is converted to its erasure  which in the above example is just Object

User · Answer

I found this page after doing some sample exercises and having the exact same puzzlement                  I went from this code as provide by the sample                  public static void main String   args  throws IOException        Map wordMap   new HashMap        if  args length  gt  0            for  int i   0  i  lt  args length  i                  countWord wordMap  args i                    else           getWordFrequency System in  wordMap             for  Iterator i   wordMap entrySet   iterator    i hasNext               Map Entry entry    Map Entry  i next            System out println entry getKey         t    entry getValue                                    To This code                           public static void main String   args  throws IOException          replace with TreeMap to get them sorted by name     Map lt String  Integer gt  wordMap   new HashMap lt String  Integer gt         if  args length  gt  0            for  int i   0  i  lt  args length  i                  countWord wordMap  args i                    else           getWordFrequency System in  wordMap             for  Iterator lt Entry lt String  Integer gt  gt  i   wordMap entrySet   iterator    i hasNext               Entry lt String  Integer gt  entry     i next            System out println entry getKey         t    entry getValue                                                                                                 It may be safer but took 4  hours to demuddle the philosophy

User · Answer

A raw-type is the a lack of a type parameter when using a generic type   Raw-type should not be used because it could cause runtime errors  like inserting a double into what was supposed to be a Set of ints   Set set   new HashSet    set add 3 45     ok   When retrieving the stuff from the Set  you don t know what is coming out  Let s assume that you expect it to be all ints  you are casting it to Integer  exception at runtime when the double 3 45 comes along   With a type parameter added to your Set  you will get a compile error at once  This preemptive error lets you fix the problem before something blows up during runtime  thus saving on time and effort    Set lt Integer gt  set   new HashSet lt Integer gt     set add 3 45     NOT ok

[java] What is a raw type and why shouldn't we use it?

Examples related to java

Examples related to generics

Examples related to raw-types