Java：InstanceofおよびGenerics

値のインデックスのジェネリックデータ構造を調べる前に、それがthisパラメーター化されている型のインスタンスでさえあるかどうかを確認したいと思います。

しかし、これを行うとEclipseは不平を言います。

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

これはエラーメッセージです。

型パラメーターEに対してinstanceofチェックを実行できません。ジェネリック型情報は実行時に消去されるため、代わりにその消去オブジェクトを使用してください

それを行うためのより良い方法は何ですか？

エラーメッセージはそれをすべて言います。実行時にタイプがなくなったので、それをチェックする方法はありません。

次のようにオブジェクトのファクトリを作成することで、それをキャッチできます。

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

次に、オブジェクトのコンストラクターにその型を格納し、変数を変更して、メソッドが次のようになるようにします。

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

ジェネリックでのランタイム型チェックの2つのオプション：

オプション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を使用すると、無料のnullチェックを取得します。使用できないため、素手でnullを確認する必要があるかもしれません。

古い投稿ですが、一般的な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;
    }
}

上記の場合、実行時にgetParameterizedClass（）からString.classを取得し、それをキャッシュして、複数のチェックでリフレクションオーバーヘッドが発生しないようにします。他のパラメーター化された型は、ParameterizedType.getActualTypeArguments（）メソッドからインデックスによって取得できることに注意してください。

私は同じ問題を抱えていましたが、これが私の解決策です（非常に謙虚、@ george：今回はコンパイルして動作しています...）。

私の問題は、Observerを実装する抽象クラスの中にありました。Observableは、任意の種類のオブジェクトである可能性のあるObjectクラスでメソッドupdate（...）を起動します。

タイプ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が問題になることがあります。それ以外の場合はYishaiの回答を参照してください。

オブジェクトの実行時タイプは、フィルタリングするのが比較的恣意的な条件です。コレクションからそのような汚さを遠ざけることをお勧めします。これは、コレクションに渡されたフィルターにコレクションを委任することで簡単に実現できます。

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;
             }
         }}
     );