Android 在listview中实现搜索

我想在我的播放列表中进行搜索。我在自定义阵列适配器中实现了getFilter，但它修改了列表，因此，如果我搜索一首歌，它的位置是9，而在我的筛选器中它是唯一的结果，当我单击它时，将播放的歌曲是索引0，而不是9

我的代码：

list.setAdapter(adapter);

    inputSearch.addTextChangedListener(new TextWatcher() {

        @Override
        public void onTextChanged(CharSequence cs, int start, int before, int count) {
            // When user changed the Text
            adapter.getFilter().filter(cs);
        }

        @Override
        public void beforeTextChanged(CharSequence arg0, int arg1, int arg2,
                                      int arg3) {
            // TODO Auto-generated method stub

        }

        @Override
        public void afterTextChanged(Editable arg0) {
            // TODO Auto-generated method stub
        }
    });

侦听单个列表项单击

lv.setOnItemClickListener(new OnItemClickListener() {

        @Override
        public void onItemClick(AdapterView<?> parent, View view,
                                int position, long id) {
            // getting listitem index
            int songIndex = position;

            // Starting new intent
            Intent in = new Intent(getApplicationContext(),
                    MusicPlayerActivity.class);
            // Sending songIndex to PlayerActivity
            in.putExtra("songIndex", songIndex);
            setResult(SELECT_SONG, in);
            // Closing PlayListView
            finish();
        }
    });

lv.setOnItemClickListener（新的OnItemClickListener（）{
@凌驾
public void onItemClick（AdapterView父级、视图、，
内部位置，长id）{
//获取列表项索引
指数=位置；
//开始新的意图
Intent in=新的Intent（getApplicationContext（），
音乐课（实用性、课堂）；
//正在向PlayerActivity发送歌曲索引
in.putExtra（“歌曲索引”，songIndex）；
setResult（选择歌曲，在中）；
//关闭播放视图
完成（）；
}
});

播放列表适配器中的我的代码：

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

private class SongFilter extends Filter
{
   @Override
   protected FilterResults performFiltering(CharSequence constraint) {
            FilterResults results = new FilterResults();
           /* results.values = origonalList;
            results.count = origonalList.size();*/
            // We implement here the filter logic
            if (constraint == null || constraint.length() == 0) {
                synchronized (this)
                {
                    // No filter implemented we return all the list
                    results.values = MainAppConfig.playerService.getPlaylist();
                    results.count = MainAppConfig.playerService.getPlaylist().size();
                }
            }
            else {
                // We perform filtering operation
                ArrayList<Song> filter = new ArrayList<>();
                ArrayList<Song> items = new ArrayList<>();

                synchronized (this)
                {
                    items.addAll(songList);
                }

                for (Song song : items ) {
                    if (song.getFileName().toUpperCase().startsWith(constraint.toString().toUpperCase()))
                        filter.add(song);
                }

                results.values = filter;
                results.count = filter.size();
            }
            return results;
        }

        @Override
        protected void publishResults(CharSequence constraint,
                                      FilterResults results) {
            filteredList = (ArrayList)results.values;
            notifyDataSetChanged();
            clear();
            Log.d("Filter", "Starting to publish the results with " + songList.size() + " items");
            for (int i = 0;  i < filteredList.size(); i++){
                add(filteredList.get(i));
            }
            Log.d("Filter", "Finished publishing results");
            notifyDataSetInvalidated();
        }
}

@覆盖
公共过滤器getFilter（）
{
if（filter==null）{
filter=新歌曲过滤器（）；
}
回流过滤器；
}
私有类SongFilter扩展了过滤器
{
@凌驾
受保护的筛选器结果性能筛选（CharSequence约束）{
FilterResults results=新的FilterResults（）；
/*结果.值=原点；
results.count=origonalist.size（）*/
//我们在这里实现过滤逻辑
if（constraint==null | | constraint.length（）==0）{
已同步（此）
{
//没有实现过滤器，我们返回所有列表
results.values=MainAppConfig.playerService.getPlaylist（）；
results.count=MainAppConfig.playerService.getPlaylist（）.size（）；
}
}
否则{
//我们执行过滤操作
ArrayList过滤器=新的ArrayList（）；
ArrayList items=新建ArrayList（）；
已同步（此）
{
items.addAll（歌曲列表）；
}
用于（歌曲：项目）{
if（song.getFileName（）.toUpperCase（）.startsWith（constraint.toString（）.toUpperCase（）））
添加（歌曲）；
}
结果.值=过滤器；
results.count=filter.size（）；
}
返回结果；
}
@凌驾
受保护的无效发布结果（CharSequence约束，
FilterResults（结果）{
filteredList=（ArrayList）results.values；
notifyDataSetChanged（）；
清除（）；
Log.d（“Filter”，“开始使用“+songList.size（）+”items”发布结果”）；
对于（int i=0；i

此时，列表视图不知道项目在适配器中的原始位置，但您可以通过以下方式找到它：

Song song = parent.getItemAtPosition(position);
MainAppConfig.playerService.getPlaylist().indexOf(song);