Java: Экземпляр и Обобщения

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

Но Затмение жалуется, когда я делаю это:

@Override
public int indexOf(Object arg0) {
    if (!(arg0 instanceof E)) {
        return -1;
    }

Это сообщение об ошибке:

Невозможно выполнить проверку экземпляра для параметра типа E. Вместо этого используйте его объект стирания, поскольку информация общего типа будет удалена во время выполнения

Какой лучший способ сделать это?

Сообщение об ошибке говорит обо всем. Во время выполнения тип исчезает, нет способа проверить это.

Вы можете поймать это, сделав фабрику для своего объекта следующим образом:

 public static <T> MyObject<T> createMyObject(Class<T> type) {
    return new MyObject<T>(type);
 }

А затем в конструкторе объекта сохраните этот тип, такой переменный, чтобы ваш метод мог выглядеть так:

        if (arg0 != null && !(this.type.isAssignableFrom(arg0.getClass()))
        {
            return -1;
        }

Два варианта проверки типов во время выполнения с помощью обобщений:

Вариант 1 - Повредить ваш конструктор

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

Сделайте грязный конструктор так:

public MyCollection<T>(Class<T> t) {

    this.t = t;
}

Затем вы можете использовать isAssignableFrom для проверки типа.

public int indexOf(Object o) {

    if (
        o != null &&

        !t.isAssignableFrom(o.getClass())

    ) return -1;

//...

Каждый раз, когда вы создаете экземпляр своего объекта, вам придется повторяться:

new MyCollection<Apples>(Apples.class);

Вы можете решить, что это того не стоит. В реализации ArrayList.indexOf (...) они не проверяют соответствие типа.

Вариант 2 - Пусть это не удастся

Если вам нужно использовать абстрактный метод, который требует вашего неизвестного типа, тогда все, что вам действительно нужно, это чтобы компилятор прекратил плакать об instanceof . Если у вас есть такой метод:

protected abstract void abstractMethod(T element);

Вы можете использовать это так:

public int indexOf(Object o) {

    try {

        abstractMethod((T) o);

    } catch (ClassCastException e) {

//...

Вы приводите объект к T (ваш универсальный тип), просто чтобы обмануть компилятор. Ваше приведение ничего не делает во время выполнения , но вы все равно получите ClassCastException, когда попытаетесь передать объект неправильного типа в ваш абстрактный метод.

ПРИМЕЧАНИЕ 1. Если вы выполняете дополнительные неконтролируемые приведения в вашем абстрактном методе, ваши ClassCastExceptions будут обнаружены здесь. Это может быть хорошо или плохо, так что подумайте.

ПРИМЕЧАНИЕ 2: Вы получаете бесплатную нулевую проверку при использовании instanceof . Так как вы не можете использовать его, вам может потребоваться проверить на ноль голыми руками.

Старый пост, но простой способ сделать общую проверку экземпляра.

public static <T> boolean isInstanceOf(Class<T> clazz, Class<T> targetClass) {
    return clazz.isInstance(targetClass);
}

При условии, что ваш класс расширяет класс универсальным параметром, вы также можете получить его во время выполнения с помощью отражения, а затем использовать его для сравнения, т.е.

class YourClass extends SomeOtherClass<String>
{

   private Class<?> clazz;

   public Class<?> getParameterizedClass()
   {
      if(clazz == null)
      {
         ParameterizedType pt = (ParameterizedType)this.getClass().getGenericSuperclass();
          clazz = (Class<?>)pt.getActualTypeArguments()[0];
       }
       return clazz;
    }
}

В приведенном выше случае во время выполнения вы получите String.class из getParameterizedClass (), и он будет кэшироваться, поэтому вы не получите никаких дополнительных затрат на отражение при многократных проверках. Обратите внимание, что другие параметризованные типы можно получить по индексу из метода ParameterizedType.getActualTypeArguments ().

У меня была та же проблема, и вот мое решение (очень скромное, @george: на этот раз компиляция И работа ...).

Мой тест был внутри абстрактного класса, который реализует Observer. Обновление метода Observable запускает (...) классом Object, который может быть любым типом Object.

Я только хочу обработать объекты типа T

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

public abstract class AbstractOne<T> implements Observer {

  private Class<T> tClass;
    public AbstractOne(Class<T> clazz) {
    tClass = clazz;
  }

  @Override
  public void update(Observable o, Object arg) {
    if (tClass.isInstance(arg)) {
      // Here I am, arg has the type T
      foo((T) arg);
    }
  }

  public abstract foo(T t);

}

Для реализации нам просто нужно передать класс в конструктор

public class OneImpl extends AbstractOne<Rule> {
  public OneImpl() {
    super(Rule.class);
  }

  @Override
  public void foo(Rule t){
  }
}

Или вы можете поймать неудачную попытку бросить в E, например.

public int indexOf(Object arg0){
  try{
    E test=(E)arg0;
    return doStuff(test);
  }catch(ClassCastException e){
    return -1;
  }
}

С технической точки зрения вам не нужно этого делать, в этом суть универсальности, поэтому вы можете выполнить проверку типа компиляции:

public int indexOf(E arg0) {
   ...
}

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

Тип объекта во время выполнения - относительно произвольное условие для фильтрации. Я предлагаю держать такую ​​грязь подальше от вашей коллекции. Это просто достигается тем, что ваш делегат коллекции передается в конструкцию фильтра.

public interface FilterObject {
     boolean isAllowed(Object obj);
}

public class FilterOptimizedList<E> implements List<E> {
     private final FilterObject filter;
     ...
     public FilterOptimizedList(FilterObject filter) {
         if (filter == null) {
             throw NullPointerException();
         }
         this.filter = filter;
     }
     ...
     public int indexOf(Object obj) {
         if (!filter.isAllows(obj)) {
              return -1;
         }
         ...
     }
     ...
}

     final List<String> longStrs = new FilterOptimizedList<String>(
         new FilterObject() { public boolean isAllowed(Object obj) {
             if (obj == null) {
                 return true;
             } else if (obj instanceof String) {
                 String str = (String)str;
                 return str.length() > = 4;
             } else {
                 return false;
             }
         }}
     );