CKTIS / Java
Ruwe typen `List` en `ArrayList`
De ruwe typen `List` en `ArrayList` omzeilen de controle van het elementtype tijdens compilatie. Toewijzing aan `List<String>` controleert de inhoud niet en haalt geen typeargument terug.
Versie: Java SE 21
Syntax
import java.util.ArrayList;
import java.util.List;
class RawTypesSyntax {
// Raw types: no type argument list
List raw = new ArrayList();
// Parameterized types: <> tells the compiler to infer String
List<String> strings = new ArrayList<>();
// Unknown element type, not a raw type
List<?> unknown = strings;
// Object is an explicit element type, not a raw type
List<Object> objects = new ArrayList<>();
}In Java SE 21 is List<E> een generieke interface en ArrayList<E> een klasse die deze interface implementeert. In List raw = new ArrayList(); zijn zowel het type van de variabele als het type van het gemaakte object ruw: de lijsten met typeargumenten ontbreken. Ruwe typen zijn bedoeld voor compatibiliteit met oudere code. In List<String> strings = new ArrayList<>(); geeft <> geen ruw type aan: de compiler leidt String af.
Via een referentie van een ruw type accepteert add door type-erasure een Object in plaats van een specifiek elementtype te eisen. De aanroep levert een unchecked-waarschuwing op. Het statische retourtype van get(int) is Object, maar de aanroep zelf geeft die waarschuwing niet omdat de int-parameter niet verandert. Met -Xlint:rawtypes,unchecked meldt javac zowel het gebruik van ruwe typen als ongecontroleerde bewerkingen.
Een ruwe lijst toewijzen aan List<String> is een ongecontroleerde conversie. Die controleert en kopieert de elementen niet en haalt geen typeargument terug. Beide referenties verwijzen naar dezelfde lijst. Als een gelezen element niet compatibel is met String, kan de door de compiler ingevoegde cast een ClassCastException veroorzaken.
Gebruik List<String> als het elementtype bekend is. List<?> staat voor een onbekend elementtype: je kunt elementen als Object lezen, maar via die referentie kun je geen ander element dan null toevoegen. List<Object> geeft Object expliciet op als elementtype en accepteert waarden van verschillende referentietypen zonder unchecked-waarschuwing. Geeft een oudere API een ruwe lijst terug, controleer dan de elementen voordat je ze naar een geparametriseerde lijst kopieert.
Voorbeelden
import java.util.ArrayList;
import java.util.List;
public class RawTypesDemo {
public static void main(String[] args) {
List raw = new ArrayList();
raw.add("Java");
raw.add(21);
Object first = raw.get(0);
System.out.println(first);
List<String> strings = raw;
try {
String second = strings.get(1);
System.out.println(second);
} catch (ClassCastException ex) {
System.out.println("ClassCastException");
}
}
}Resultaat
Java ClassCastException
De ruwe lijst accepteert `"Java"` en `21`, dat door boxing een `Integer` wordt. Het programma toont `Java`, vangt een `ClassCastException` op bij het lezen van het tweede element als `String` en toont de naam van de uitzondering.
Gerelateerde lessen
- Java · Les 36 · Gemiddeld · Versie: 2