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

Question

我目前面临以下问题：

我正在尝试 refactor 将递归算法转换为迭代算法。这个递归算法的作用是这样的：

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

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

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

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

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

假设我将数组列表正确地弹出并压入堆栈，我面临以下问题，这是我的主要问题和这个问题的原因：

在方法 2 中，我必须检查对象（在数组列表中并传递给方法）是否是一个 instanceof 另一个 class 我的。现在我有一些条件没有得到满足，而实际上它们应该得到满足。

这是因为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;
}

第二种方法应该return来自其中一个条件，但满足none条件

Answer 1

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

Type erasure ensures that no new classes are created for parameterized types; consequently, generics incur no runtime overhead.

因此在运行时，您的 classes 只是普通的 classes 并且您的对象是它们的本来面目，但它不会删除基本类型信息。

为什么不把log语句放进去打印出对象的class呢？

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

Generics and type erasure in Java issue

java

arrays

generics

arraylist

type-erasure