Android 排序后，notifyDataSetChanged不会更新自定义对象的listView

我正在尝试在CustomArrayAdapter中对集合进行排序，并调用以更新视图。但是，视图不会得到更新

我想对两个值（日期和金额）进行排序，并为它们设置一个自定义比较器

我可以看到数据本身发生了变化（即，如果列表项在排序后已超出视图范围，并且当它获得视图时，它显示的数据是排序后应该存在的正确数据）

第二个问题是关于过滤器的。现在实现过滤器的方式，也不会更新视图

这是代码

public class SearchActivity extends BListActivity {

private Bundle sessionInfo;
private TransactionDetailsHandler transactionDetailsHandler = new TransactionDetailsHandler();
private static boolean ascDate = false;
private static boolean ascAmount = false;

private ArrayList<TransactionDetails> transactionDetails;
private ArrayList<TransactionDetails> filterResults;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    sessionInfo = getIntent().getExtras();
    final String sessionId = sessionInfo.getString("sessionId");
    final String transactionResponse = sessionInfo
            .getString(C.TRN_DETAIL_KEY);

    try {
        Xml.parse(transactionResponse, transactionDetailsHandler);
    } catch (Exception ex) {
        ex.printStackTrace();
    }

    final ArrayAdapter<TransactionDetails> adapter = getArrayAdapter();

    findViewById(R.id.amount_btn).setOnClickListener(
            new View.OnClickListener() {
                public void onClick(View v) {

                    if (ascDate) {
                        adapter.sort(new TransactionDetailAmountComparatorAsc());
                        ascDate = false;
                    } else {
                        adapter.sort(new TransactionDetailAmountComparatorDesc());
                        ascDate = true;
                    }

                    adapter.notifyDataSetChanged();
                }
            });

    findViewById(R.id.date_btn).setOnClickListener(
            new View.OnClickListener() {
                public void onClick(View v) {
                    if (ascAmount) {
                        adapter.sort(new TransactionDetailDateComparatorAsc());
                        ascAmount = false;
                    } else {
                        adapter.sort(new TransactionDetailDateComparatorDesc());
                        ascAmount = true;
                    }

                    adapter.notifyDataSetChanged();
                }
            });

    findViewById(R.id.search_btn).setOnClickListener(
            new View.OnClickListener() {
                public void onClick(View v) {
                    findViewById(R.id.buttonLL).setVisibility(View.GONE);
                    findViewById(R.id.searchLL).setVisibility(View.VISIBLE);

                }
            });

    findViewById(R.id.cancel_btn).setOnClickListener(
            new View.OnClickListener() {
                public void onClick(View v) {
                    findViewById(R.id.searchLL).setVisibility(View.GONE);
                    findViewById(R.id.buttonLL).setVisibility(View.VISIBLE);

                }
            });

    TextWatcher filterTextWatcher = new TextWatcher() {
        public void afterTextChanged(Editable s) {
        }

        public void beforeTextChanged(CharSequence s, int start, int count,
                int after) {
        }

        public void onTextChanged(CharSequence s, int start, int before,
                int count) {
            System.out.println("XXXX Constraint = " + s);
            adapter.getFilter().filter(s);
        }
    };

    EditText et = (EditText) findViewById(R.id.edit_box);
    et.addTextChangedListener(filterTextWatcher);

}

protected ArrayAdapter<TransactionDetails> getArrayAdapter() {
    transactionDetails = transactionDetailsHandler
            .getTransactionDetailsList();
    filterResults = transactionDetails;
    return new SearchListAdapter(this,
            (List<TransactionDetails>) transactionDetails);
}

protected class SearchListAdapter extends ArrayAdapter<TransactionDetails> {
    private int rId;
    private List<TransactionDetails> data;
    private Filter filter;

    public SearchListAdapter(Context context, List<TransactionDetails> data) {
        super(context, R.layout.search_list_item, data);
        this.rId = R.layout.search_list_item;
        this.data = data;
    }

    @Override
    public View getView(int position, View cv, ViewGroup parent) {
        cv = getLayoutInflater().inflate(rId, parent, false);
        TransactionDetails item = data.get(position);

        ((TextView) cv.findViewById(R.id.t_id)).setText(item.getTrnId());
        ((TextView) cv.findViewById(R.id.date)).setText(item
                .getTrnDatetime());
        ((TextView) cv.findViewById(R.id.amount)).setText(item
                .getTrnAmount());
        ((TextView) cv.findViewById(R.id.card_num))
                .setText("XXXX XXXX XXXX " + item.getTrnMaskedCard());

        try {
            if (item.getTrnCardType() != null
                    && item.getTrnCardType().trim().length() > 0)
                ((ImageView) cv.findViewById(R.id.card_img))
                        .setImageResource(Integer.parseInt(item
                                .getTrnCardType()));
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        ((TextView) cv.findViewById(R.id.result)).setText(item
                .getTrnStatus());
        return cv;
    }

    @Override
    public Filter getFilter() {
        if (filter == null)
            filter = new TransactionDetailFilter();
        return filter;
    }

    private class TransactionDetailFilter extends Filter {
        @Override
        protected FilterResults performFiltering(CharSequence constraint) {
            System.out.println("XXXX Started filtering with Constraint = "
                    + constraint);
            FilterResults results = new FilterResults();
            String prefix = constraint.toString().toLowerCase();

            if (prefix == null || prefix.length() == 0) {
                ArrayList<TransactionDetails> list = new ArrayList<TransactionDetails>(
                        transactionDetails);
                results.values = list;
                results.count = list.size();
            } else {
                final ArrayList<TransactionDetails> list = new ArrayList<TransactionDetails>(
                        transactionDetails);
                final ArrayList<TransactionDetails> nlist = new ArrayList<TransactionDetails>();
                int count = list.size();
                System.out
                        .println("XXXX List to be search size = " + count);
                for (int i = 0; i < count; i++) {
                    final TransactionDetails details = list.get(i);
                    System.out.println("XXXX List to be searched = "
                            + details.toString());
                    if (details.getTrnId().startsWith(prefix)
                            || details.getTrnDatetime().startsWith(prefix)
                            || details.getTrnAmount().startsWith(prefix)
                            || details.getTrnMaskedCard()
                                    .startsWith(prefix)
                            || details.getTrnStatus().startsWith(prefix)) {
                        System.out.println("XXXX Adding result "
                                + details.toString());
                        nlist.add(details);
                    }
                }
                results.values = nlist;
                results.count = nlist.size();
            }
            System.out.println("XXXX Ended filtering with Constraint = "
                    + constraint + " . Result size = " + results.count);
            return results;
        }

        @SuppressWarnings("unchecked")
        @Override
        protected void publishResults(CharSequence constraint,
                FilterResults results) {
            System.out.println("XXXX Preparing to publish results. Result size = "+ results.count);
            ArrayList<TransactionDetails> fitems = (ArrayList<TransactionDetails>) results.values;

            clear();
            int count = fitems.size();

            for (int i = 0; i < count; i++) {
                TransactionDetails details = (TransactionDetails) fitems
                        .get(i);
                add(details);
            }
            notifyDataSetChanged();
            System.out.println("XXXX Finished publishing results.");

        }

    }

    @Override
    public void add(TransactionDetails item) {
        System.out.println("XXXX Adding items to be published." + item.toString());
        filterResults.add(item);
    }
}

// -------------------------------------------------------------------------------------------------------------------------------------------------
class TransactionDetailAmountComparatorAsc implements
        Comparator<TransactionDetails> {
    public int compare(TransactionDetails detail1,
            TransactionDetails detail2) {
        float f = Float.parseFloat(detail1.getTrnAmount())
                - Float.parseFloat(detail2.getTrnAmount());
        if (f > 0)
            return 1;
        if (f < 1)
            return -1;

        return 0;
    }
}

class TransactionDetailAmountComparatorDesc implements
        Comparator<TransactionDetails> {
    public int compare(TransactionDetails detail1,
            TransactionDetails detail2) {
        float f = Float.parseFloat(detail1.getTrnAmount())
                - Float.parseFloat(detail2.getTrnAmount());
        if (f > 0)
            return -1;
        if (f < 1)
            return 1;

        return 0;
    }
}

class TransactionDetailDateComparatorAsc implements
        Comparator<TransactionDetails> {
    public int compare(TransactionDetails detail1,
            TransactionDetails detail2) {
        detail1.getTrnDatetime();
        detail2.getTrnDatetime();
        String pattern = "MM/dd/yy HH:mm";
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        try {
            Date date1 = format.parse(detail1.getTrnDatetime());
            Date date2 = format.parse(detail2.getTrnDatetime());
            return date1.compareTo(date2);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return 0;
    }
}

class TransactionDetailDateComparatorDesc implements
        Comparator<TransactionDetails> {
    public int compare(TransactionDetails detail1,
            TransactionDetails detail2) {
        detail1.getTrnDatetime();
        detail2.getTrnDatetime();
        String pattern = "MM/dd/yy HH:mm";
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        try {
            Date date1 = format.parse(detail1.getTrnDatetime());
            Date date2 = format.parse(detail2.getTrnDatetime());
            return -(date1.compareTo(date2));
        } catch (Exception e) {
            e.printStackTrace();
        }

        return 0;
    }
}

@Override
public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
    position -= ((ListView) parent).getHeaderViewsCount();
    TransactionDetails details = (TransactionDetails) parent.getAdapter()
            .getItem(position);

    Bundle b = new Bundle(sessionInfo);
    b.putSerializable(C.TRN_DETAIL_KEY, details);
    Util.openView(SearchActivity.this, TransDetailActivity.class, b);
}

@Override
protected int getContentView() {
    return R.layout.search_layout;
}

@Override
protected int getStringArrayID() {
    return 0;
}

@Override
protected Class<?>[] getDestinations() {
    return null;
}

@Override
protected int getTitleId() {
    return R.string.search;
}

公共类SearchActivity扩展了BListActivity{
私有包sessionInfo；
私有TransactionDetailsHandler TransactionDetailsHandler=新TransactionDetailsHandler（）；
私有静态布尔值ascDate=false；
私有静态布尔值ascmount=false；
私人ArrayList交易详情；
私有ArrayList筛选器结果；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
sessionInfo=getIntent（）.getExtras（）；
最终字符串sessionId=sessionInfo.getString（“sessionId”）；
最终字符串transactionResponse=sessionInfo
.getString（C.TRN\u详细信息\u键）；
试一试{
parse（transactionResponse，transactionDetailsHandler）；
}捕获（例外情况除外）{
例如printStackTrace（）；
}
最终ArrayAdapter适配器=getArrayAdapter（）；
findViewById（R.id.amount\u btn）.setOnClickListener(
新建视图。OnClickListener（）{
公共void onClick（视图v）{
如果（截止日期）{
sort（新TransactionDetailAmountComparatorAsc（））；
ascDate=false；
}否则{
sort（新TransactionDetailAmountComparatorDesc（））；
ascDate=true；
}
adapter.notifyDataSetChanged（）；
}
});
findViewById（R.id.date\u btn）.setOnClickListener(
新建视图。OnClickListener（）{
公共void onClick（视图v）{
如果（金额）{
sort（新TransactionDetailDateComparatorAsc（））；
ascAmount=false；
}否则{
sort（新TransactionDetailDateComparatorDesc（））；
ascAmount=真；
}
adapter.notifyDataSetChanged（）；
}
});
findViewById（R.id.search\u btn）.setOnClickListener(
新建视图。OnClickListener（）{
公共void onClick（视图v）{
findViewById（R.id.buttonLL）.setVisibility（View.GONE）；
findViewById（R.id.searchLL）.setVisibility（View.VISIBLE）；
}
});
findViewById（R.id.cancel\u btn）.setOnClickListener(
新建视图。OnClickListener（）{
公共void onClick（视图v）{
findViewById（R.id.searchLL）.setVisibility（View.GONE）；
findViewById（R.id.buttonLL）.setVisibility（View.VISIBLE）；
}
});
TextWatcher filterTextWatcher=新的TextWatcher（）{
公共无效后文本已更改（可编辑）{
}
更改前的公共无效（字符序列、整数开始、整数计数、，
整数后）{
}
public void onTextChanged（字符序列，int start，int before，
整数计数）{
System.out.println（“XXXX约束=”+s）；
adapter.getFilter（）.filter；
}
};
EditText et=（EditText）findViewById（R.id.edit_框）；
et.addTextChangedListener（filterTextWatcher）；
}
受保护的ArrayAdapter getArrayAdapter（）{
transactionDetails=transactionDetailsHandler
.getTransactionDetailsList（）；
filterResults=交易详情；
返回新的SearchListAdapter（此，
（列表）交易详情）；
}
受保护的类SearchListAdapter扩展了ArrayAdapter{
私人住宅；
私人名单数据；
专用滤波器；
公共SearchListAdapter（上下文、列表数据）{
super（上下文、R.layout.search\u列表项目、数据）；
this.rId=R.layout.search\u list\u项；
这个数据=数据；
}
@凌驾
公共视图getView（内部位置、视图cv、视图组父视图）{
cv=getLayoutInflater（）。充气（rId、父项、false）；
TransactionDetails项=data.get（位置）；
（（TextView）cv.findviewbyd（R.id.t_id））.setText（item.getternid（））；
（（文本视图）cv.findViewById（R.id.date））.setText（项目
.getTrnDatetime（））；
（（文本视图）cv.findViewById（R.id.amount））.setText（项目
.getternamount（））；
（（文本视图）简历findViewById（R.id.card_num））
.setText（“XXXX XXXX XXXX”+item.getTrnMaskedCard（））；
试一试{
如果（item.getTrnCardType（）！=null
&&item.getTrnCardType（）.trim（）.length（）>0）
（（图像视图）简历findViewById（R.id.card_img））
.setImageResource（整数.parseInt（项目
.getTrnCardType（））；
}捕获（例外情况除外）{
例如printStackTrace（）；
}
（（文本视图）cv.findViewById（R.id.result））.setText（项目
.getTrnStatus（））；
返回cv；
}
@凌驾
公共过滤器getFilter（）{
if（filter==null）
filter=新TransactionDetailFilter（）；
回流过滤器；
}
私有类TransactionDetailFilter扩展了筛选器{
@凌驾
受保护的筛选器结果性能筛选（CharSequence约束）{
System.out.println（“XXXX开始使用约束进行筛选=”
+约束）；
FilterResults结果=新的FilterResult