Каков, по-видимому, правильный пример кода Java, вызывающего загрязнение кучи?

Question

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

public static <T> LinkedList<T> list(T... elements) {
    ...
}

Мне кажется, что если я уверен, что не буду использовать какие-то странные приведения в моих методах, я должен просто использовать @SafeVarargs и двигаться дальше. Но так ли это, или мне нужно быть осторожнее? Есть ли явно правильный код, который на самом деле небезопасен при использовании параметризованных varargs?

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

public static void faultyMethod(List<String>... l) {
    Object[] objectArray = l;     // Valid
    objectArray[0] = Arrays.asList(42);
    String s = l[0].get(0);       // ClassCastException thrown here
}

Что поучительно, но довольно нереально; опытные программисты вряд ли напишут такой код. Другой пример:

Pair<String, String>[] method(Pair<String, String>... lists) { 
   Object[] objs = lists; 
   objs[0] = new Pair<String, String>("x", "y");  
   objs[1] = new Pair<Long, Long>(0L, 0L);  // corruption !!! 
   return lists; 
}

Что опять же довольно очевидно смешивает типы нереальным образом.

Итак, есть ли более тонкие случаи, когда загрязнение кучи происходит под параметризованными varargs? Имею ли я право использовать @SafeVarargs, если я не преобразовываю переменные таким образом, чтобы терять вводимую информацию или неправильно смешивать типы? Другими словами, могу ли я рассматривать это предупреждение как не очень важную формальность?

java variadic-functions heap-pollution

13

user118967 2 Янв 2018 в 23:01

Answer 1

Объявить универсальные массивы T[] в Java проблематично, потому что их тип неизвестен во время выполнения и, как следствие, они могут быть использованы неправильно, как показывают примеры в вопросе. Таким образом, компилятор Java выдает предупреждения всякий раз, когда это происходит.

Например, если мы объявим общий массив, как в

T[] tArray = (T[]) new Object[] { 42 };

Мы получаем предупреждение о непроверенном приведении.

Помимо таких приведений, единственный другой способ ввести универсальный массив в программу - это использовать универсальный varargs. Например, в

void bar() {
    foo(new Integer[]{ 42 })
}

void foo(T... args) {
}

Здесь снова вводится общий массив, но другим способом, чем непроверенное приведение, поэтому он получает свое собственное предупреждение, чтобы убедиться, что пользователь не злоупотребляет им.

В самом деле, до тех пор, пока массив не преобразуется в массив другого типа, кажется, что использование @SafeVarargs должно быть безопасным, за исключением преобразований нетипичных типов.

2

user118967 22 Фев 2019 в 22:40

Answer 2

Хороший вопрос. Меня это тоже довольно долго беспокоило. Здесь есть две вещи - вас не заботит фактический тип среды выполнения элементов в массиве, как в примере, который вы показали:

public static <T> LinkedList<T> list(T... elements) {
    // suppose you iterate over them and add
}

Вот где @SafeVarargs хорошо, безопасно.

И второй - это когда вы ДОЛЖНЫ заботиться о типе времени выполнения элементов в массиве (даже если это произошло случайно). Массивы в java не могут быть универсальными, поэтому вы не можете создать тип T [] ts = new T[10], но можете объявить тип T[] ts..., и поскольку массивы ковариантны, вы можете преобразовать Object[] в T[] - если вы знаете, что типы совпадают.

Все это становится интересным, когда вы передаете общий массив :

// create a single element "generic" array
static <T> T[] singleElement(T elem) {
    @SuppressWarnings("unchecked")
    T[] array = (T[]) new Object[] { elem };
    return self(array);
}

// @SafeVarargs
static <T> T[] self(T... ts) {
    return ts;
}

Вызов этого с помощью Integer[] ints = singleElement(1); выглядит совершенно законным, но не работает во время выполнения, поэтому размещение @SafeVarargs будет небезопасным.

Он сломается, потому что этот случай (T[]) фактически бесполезен и не требует каких-либо проверок времени компиляции. Даже если вы переписали этот метод как:

 static <T> T[] singleElement(T elem) {
    @SuppressWarnings("unchecked")
    T[] array = (T[]) new Object[]{elem};
    System.out.println(array.getClass());
    return array;
}

Это все равно не сработает.

9

Eugene 5 Ноя 2018 в 17:32

Каков, по-видимому, правильный пример кода Java, вызывающего загрязнение кучи?

2 ответа

Похожие вопросы

Связанные вопросы

Новые вопросы

java