Java问题中的泛型和类型擦除

Question

我目前面临以下问题：

我正在尝试将递归算法重构为迭代算法。 此递归算法的作用是：

向method1传递了一些初始参数。 基于在method1开头发生的处理，使用这些参数调用method2 。 现在，method2使用一些条件，并根据满足的条件再次使用适当的参数调用method1。

现在，根据我上面提供的链接上的答案，我做了同样的事情。 但是我必须传递参数，所以我这样做：

Stack<ArrayList<Object>> stack （ ArrayList<Object>对象的堆栈）

ArrayList<Object> parametersForSync = new ArrayList<Object>();
ArrayList<Object> paramForHandle = new ArrayList<Object>();

（每个对象数组列表都是要传递给这两个方法的参数的列表 。第一个数组列表用于第一个方法，第二个数组用于第二个方法。）

假设我正确地弹出和推入数组列表，但我遇到以下问题，这是我的主要问题，也是该问题的原因：

在method2中，我必须检查对象（ 位于数组列表中并传递给方法 ）是否是我的另一个类的instanceof 。 现在，我有一些条件实际上并没有得到满足。

这是因为java的类型擦除吗？ 反正有什么要克服的？

如果我的解释在某些时候不清楚，请让我澄清一下。

编辑：下面是替换如下递归的代码：

syncWithServer(parameter set x){
    handleResultArray(parameter set y);
};
handleResultArray(parameter set ){
    syncWithServer(parameter set w)
}

================================================== =========

Stack<ArrayList<Object>> stack = new Stack<ArrayList<Object>>();
ArrayList<Object> paramList = new ArrayList<Object>();
paramList.add(oeHelper);
paramList.add(false);
paramList.add(domain);
paramList.add(null);
paramList.add(true);
paramList.add(10000);
paramList.add(true);

stack.push(paramList);
int counter = 0;
ArrayList<Object> parametersForSync = new ArrayList<Object>();
ArrayList<Object> paramForHandle = new ArrayList<Object>();
while (!stack.isEmpty()) {
    Log.d(TAG, "Loop: " + counter);
    parametersForSync = stack.pop();
    paramForHandle = ((OEHelper) parametersForSync.get(0))
            .syncWithServer(
        // why error here?
        (boolean) parametersForSync.get(1),
        (OEDomain) parametersForSync.get(2),
        (List<Object>) parametersForSync.get(3),
        (boolean) parametersForSync.get(4),
        (int) parametersForSync.get(5),
        (boolean) parametersForSync.get(6));

    parametersForSync = ((OEHelper) paramForHandle.get(3))
            .handleResultArray(
        (OEFieldsHelper) paramForHandle.get(0),
        (JSONArray) paramForHandle.get(1),
        (boolean) paramForHandle.get(2));

    if (parametersForSync.size() != 0) {
        stack.push(parametersForSync);
    }
    counter++;

现在第一种方法：

public ArrayList<Object> syncWithServer(boolean twoWay, OEDomain domain,
        List<Object> ids, boolean limitedData, int limits,
        boolean removeLocalIfNotExists) {
    Log.d(TAG, "syncWithServer");

    List<OEColumn> dbCols = mDatabase.getDatabaseColumns();
    List<OEColumn> dbFinalList = new ArrayList<OEColumn>();
    ArrayList<Object> parametersList = new ArrayList<Object>();

    Log.d(TAG, "Columns & finalList created");
    for (OEColumn col : dbCols) {
        if (!mOne2ManyCols.contains(col.getName())) {
            dbFinalList.add(col);
        }
    }

    OEFieldsHelper fields = new OEFieldsHelper(dbFinalList);
    try {
        if (domain == null) {
            domain = new OEDomain();
        }
        if (ids != null) {
            domain.add("id", "in", ids);
        }
        if (limitedData) {
            mPref = new PreferenceManager(mContext);
            int data_limit = mPref.getInt("sync_data_limit", 60);
            domain.add("create_date", ">=",
                    OEDate.getDateBefore(data_limit));
        }
        if (limits == -1) {
            limits = 50;
        }
        Log.d(TAG, "*****.search_read() started");
        JSONObject result = *****.search_read(mDatabase.getModelName(),
                fields.get(), domain.get(), 0, limits, null, null);
        Log.d(TAG, "***.search_read() returned");
        mAffectedRows = result.getJSONArray("records").length();
        parametersList.add(fields);
        parametersList.add(result.getJSONArray("records"));
        parametersList.add(removeLocalIfNotExists);
        parametersList.add(OEHelper.this);

//此parametersList包含必须用于调用下一个方法的参数

现在第二种方法：

==================================================

public ArrayList<Object> handleResultArray(
        OEFieldsHelper fields, JSONArray results,
        boolean removeLocalIfNotExists) {
    Log.d(TAG, "handleResultArray");

    ArrayList<Object> parametersList = new ArrayList<Object>();
    // ArrayList<Object> parameterStack = new ArrayList<Object>();
    try {
        fields.addAll(results);
        List<OERelationData> rel_models = fields.getRelationData();
        Log.d(TAG, "rel_models: "+rel_models.size());
        for (OERelationData rel : rel_models) {

            // Handling many2many records

            if (rel.getDb().getClass()==OEManyToMany.class
                    /*instanceof OEManyToMany*/) {//TODO type erasure?
                Log.v(TAG, "Syncing ManyToMany Records");
                OEManyToMany m2mObj = (OEManyToMany) rel.getDb();
                OEHelper oe = ((OEDatabase) m2mObj.getDBHelper())
                        .getOEInstance();

                parametersList.add(oe);
                parametersList.add(false);
                parametersList.add(null);
                parametersList.add(rel.getIds());
                parametersList.add(false);
                parametersList.add(0);
                parametersList.add(false);

                return parametersList;
            } else if (rel.getDb().getClass()==OEManyToOne.class
                    /*instanceof OEManyToOne*/) {

                // Handling many2One records
                Log.v(TAG, "Syncing ManyToOne Records");
                // M2OCounter++;
                OEManyToOne m2oObj = (OEManyToOne) rel.getDb();
                OEHelper oe = ((OEDatabase) m2oObj.getDBHelper())
                        .getOEInstance();
                parametersList.add(oe);
                parametersList.add(false);
                parametersList.add(null);
                parametersList.add(rel.getIds());
                parametersList.add(false);
                parametersList.add(0);
                parametersList.add(false);
                // parametersMap.put(Counter, parametersList);
                // parameterStack.add(parametersList);
                return parametersList;
            } else if (rel.getDb().getClass()==OEOneToMany.class
                    /*instanceof OEOneToMany*/) {

                Log.v(TAG, "Syncing OneToMany Records");
                // O2MCounter++;
                OEOneToMany o2mObj = (OEOneToMany) rel.getDb();
                OEHelper oe = ((OEDatabase) o2mObj.getDBHelper())
                        .getOEInstance();
                oe.setOne2ManyCol(o2mObj.getColumnName());
                parametersList.add(oe);
                parametersList.add(false);
                parametersList.add(null);
                parametersList.add(rel.getIds());
                parametersList.add(false);
                parametersList.add(0);
                parametersList.add(false);
                // parametersMap.put(Counter, parametersList);
                // parameterStack.add(parametersList);
                return parametersList;
            } else {

                Log.v(TAG, "Syncing records with no relations"
                        + rel.getDb().getClass().getSimpleName());
                OEHelper oe = ((OEDatabase) rel.getDb()).getOEInstance();
                parametersList.add(oe);
                parametersList.add(false);
                parametersList.add(null);
                parametersList.add(rel.getIds());
                parametersList.add(false);
                parametersList.add(0);
                parametersList.add(false);
                return parametersList;//TODO when nothing matches this returns
            }
        }
        List<Long> result_ids = mDatabase.createORReplace(
                fields.getValues(), removeLocalIfNotExists);
        mResultIds.addAll(result_ids);
        mRemovedRecordss.addAll(mDatabase.getRemovedRecords());

    } catch (Exception e) {
        e.printStackTrace();
    }
    return parametersList;
}

第二种方法应该从一个条件中返回，但不满足任何条件

Answer 1

否-这不是类型擦除问题。 正如甲骨文所说：

类型擦除可确保不会为参数化类型创建新的类； 因此，泛型不会产生运行时开销。

因此，在运行时，您的类只是普通类，而您的对象就是它们的类，但这不会删除基本类型信息。

为什么不放入log语句并打印出对象的类？