Какова концепция стирания в дженериках в Java?

Question

Какова концепция стирания в дженериках в Java?

Answer 1

Это в основном способ реализации дженериков в Java с помощью хитрости компилятора. Скомпилированный универсальный код на самом деле просто использует java.lang.Object везде, где вы говорите о T (или некотором другом параметре типа) - и есть некоторые метаданные, чтобы сообщить компилятору, что это действительно универсальный тип.

Когда вы компилируете некоторый код для универсального типа или метода, компилятор понимает, что вы действительно имеете в виду (то есть, что такое аргумент типа для T), и проверяет в компиляции , что вы делает все правильно, но выданный код снова говорит только о java.lang.Object - компилятор генерирует дополнительные приведения при необходимости. Во время выполнения a List<String> и a List<Date> абсолютно одинаковы; дополнительная информация о типе была стерта компилятором.

Сравните это, скажем, с C #, где информация сохраняется во время выполнения, позволяя коду содержать выражения, такие как typeof(T), что эквивалентно T.class - за исключением того, что последний является недействительным. (Заметим, что между обобщениями .NET и обобщениями Java есть и другие различия.) Стирание типов является источником многих «странных» предупреждений / сообщений об ошибках при работе с обобщениями Java.

Другие ресурсы:

• Документация Oracle
• Википедия
• Руководство по обобщению Java для Гилада Брачи (PDF - настоятельно рекомендуется; иногда может потребоваться изменение ссылки)
• Часто задаваемые вопросы по Java от Angelika Langer

Answer 2

Как дополнительное замечание, это интересное упражнение, чтобы на самом деле увидеть, что делает компилятор, когда он выполняет стирание - что делает концепцию немного легче понять. Существует специальный флаг, который вы можете передать компилятору для вывода java-файлов, у которых были удалены общие и вставленные приведения. Пример:

javac -XD-printflat -d output_dir SomeFile.java

-printflat - это флаг, который передается компилятору, который генерирует файлы. (Часть -XD - это то, что говорит javac передать ее исполняемому файлу, который на самом деле выполняет компиляцию, а не просто javac, но я отвлекся ...) -d output_dir необходим, потому что компилятору нужно место поставить новые файлы .java.

Это, конечно, больше, чем просто стирание; все автоматические вещи, которые делает компилятор, выполняются здесь. Например, конструкторы по умолчанию также вставляются, новые циклы for в стиле foreach расширяются до обычных циклов for и т. Д. Приятно видеть мелочи, которые происходят автоматически.

Answer 3

Erasure, буквально означает, что информация о типе, которая присутствует в исходном коде, стирается из скомпилированного байт-кода. Позвольте нам понять это с помощью некоторого кода.

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class GenericsErasure {
    public static void main(String args[]) {
        List<String> list = new ArrayList<String>();
        list.add("Hello");
        Iterator<String> iter = list.iterator();
        while(iter.hasNext()) {
            String s = iter.next();
            System.out.println(s);
        }
    }
}

Если вы скомпилируете этот код, а затем декомпилируете его с помощью декомпилятора Java, вы получите нечто подобное. Обратите внимание, что декомпилированный код не содержит следов информации о типе, присутствующей в исходном исходном коде.

import java.io.PrintStream;
import java.util.*;

public class GenericsErasure
{

    public GenericsErasure()
    {
    }

    public static void main(String args[])
    {
        List list = new ArrayList();
        list.add("Hello");
        String s;
        for(Iterator iter = list.iterator(); iter.hasNext(); System.out.println(s))
            s = (String)iter.next();

    }
} 

Answer 4

Чтобы завершить уже очень полный ответ Джона Скита, вы должны понять концепцию стирания типа , вытекающую из необходимости совместимости с предыдущими версиями Java .

Изначально представленный на EclipseCon 2007 (больше не доступен), совместимость включала в себя следующие пункты:

• Совместимость с исходным кодом (приятно иметь ...)
• Бинарная совместимость (должна быть!)
• Совместимость миграции
  • Существующие программы должны продолжать работать
  • Существующие библиотеки должны иметь возможность использовать универсальные типы
  • Должен иметь!

Оригинальный ответ:

Таким образом:

new ArrayList<String>() => new ArrayList()

Есть предложения для большего овефикации . Reify - «Рассматривайте абстрактное понятие как реальное», где языковые конструкции должны быть понятиями, а не просто синтаксическим сахаром.

Я должен также упомянуть checkCollection метод Java 6, который возвращает динамически безопасное для типов представление указанной коллекции. Любая попытка вставить элемент неправильного типа приведет к немедленному ClassCastException.

Механизм обобщений на языке обеспечивает проверку типов во время компиляции (статическую), но этот механизм можно победить с помощью непроверенных приведений .

Обычно это не проблема, поскольку компилятор выдает предупреждения обо всех таких непроверенных операциях.

Однако бывают случаи, когда одной лишь статической проверки типов недостаточно, например:

• когда коллекция передается в стороннюю библиотеку и обязательно, чтобы код библиотеки не повредил коллекцию, вставив элемент неправильного типа.
• программа завершается с ошибкой ClassCastException, указывая на то, что неправильно заданный элемент был помещен в параметризованную коллекцию. К сожалению, исключение может произойти в любое время после вставки ошибочного элемента, поэтому обычно оно дает мало информации или вообще не содержит информации о реальном источнике проблемы.

---

Обновление июль 2012, почти четыре года спустя:

Теперь (2012) подробно описано в " Правилах совместимости миграции API (проверка подписи) "

Язык программирования Java реализует обобщенные типы с использованием стирания, что гарантирует, что унаследованные и универсальные версии обычно генерируют идентичные файлы классов, за исключением некоторой вспомогательной информации о типах. Двоичная совместимость не нарушена, поскольку можно заменить устаревший файл класса универсальным файлом класса, не изменяя и не перекомпилируя код клиента.

Для облегчения взаимодействия с неуниверсальным унаследованным кодом также можно использовать стирание параметризованного типа в качестве типа. Такой тип называется raw type ( Спецификация языка Java 3 / 4.8 ). Разрешение необработанного типа также обеспечивает обратную совместимость исходного кода.

В соответствии с этим следующие версии класса java.util.Iterator являются двоичными и обратно совместимыми с исходным кодом:

Class java.util.Iterator as it is defined in Java SE version 1.4:

public interface Iterator {
    boolean hasNext();
    Object next();
    void remove();
}

Class java.util.Iterator as it is defined in Java SE version 5.0:

public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

Answer 5

Дополняет уже дополненный ответ Джона Скита ...

Было упомянуто, что реализация дженериков посредством стирания приводит к некоторым раздражающим ограничениям (например, нет new T[42]). Также было упомянуто, что основной причиной таких действий была обратная совместимость в байт-коде. Это также (в основном) правда. Сгенерированный байт-код -target 1.5 несколько отличается от просто обессахаренного приведения -target 1.4. Технически, даже возможно (посредством огромного обмана) получить доступ к экземплярам универсального типа во время выполнения , доказывая, что в байт-коде действительно что-то есть.

Более интересным моментом (который не был поднят) является то, что реализация обобщений с использованием стирания предлагает немного больше гибкости в том, что может достичь система типов высокого уровня. Хорошим примером этого может быть реализация JVM в Scala против CLR. На JVM возможно реализовать более высокие виды напрямую, потому что сама JVM не накладывает ограничений на универсальные типы (так как эти "типы" фактически отсутствуют). Это контрастирует с CLR, который знает во время выполнения об экземплярах параметров. Из-за этого у CLR должна быть некоторая концепция того, как следует использовать дженерики, сводя на нет попытки расширить систему непредвиденными правилами. В результате высшие виды Scala в CLR реализованы с использованием странной формы стирания, эмулируемой внутри самого компилятора, что делает их не полностью совместимыми с простыми устаревшими обобщениями .NET.

Erasure может быть неудобным, когда вы хотите делать непослушные вещи во время выполнения, но он предлагает наибольшую гибкость авторам компилятора. Я предполагаю, что это одна из причин, почему это не исчезнет в ближайшее время.

Answer 6

Насколько я понимаю (будучи .NET парнем), JVM не имеет понятия обобщения, поэтому компилятор заменяет параметры типа на Object и выполняет все приведение за вас.

Это означает, что универсальные шаблоны Java являются не чем иным, как синтаксическим сахаром и не обеспечивают какого-либо улучшения производительности для типов значений, которые требуют упаковки / распаковки при передаче по ссылке.

Answer 7

Есть хорошие объяснения. Я только добавляю пример, чтобы показать, как стирание типов работает с декомпилятором.

Оригинальный класс,

import java.util.ArrayList;
import java.util.List;


public class S<T> {

    T obj; 

    S(T o) {
        obj = o;
    }

    T getob() {
        return obj;
    }

    public static void main(String args[]) {
        List<String> list = new ArrayList<>();
        list.add("Hello");

        // for-each
        for(String s : list) {
            String temp = s;
            System.out.println(temp);
        }

        // stream
        list.forEach(System.out::println);
    }
}

Декомпилированный код из его байт-кода,

import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Objects;
import java.util.function.Consumer;

public class S {

   Object obj;


   S(Object var1) {
      this.obj = var1;
   }

   Object getob() {
      return this.obj;
   }

   public static void main(String[] var0) {

   ArrayList var1 = new ArrayList();
   var1.add("Hello");


   // for-each
   Iterator iterator = var1.iterator();

   while (iterator.hasNext()) {
         String string;
         String string2 = string = (String)iterator.next();
         System.out.println(string2);
   }


   // stream
   PrintStream printStream = System.out;
   Objects.requireNonNull(printStream);
   var1.forEach(printStream::println);


   }
}