RecyclerView更新技巧：解决输入框刷新问题

问题背景与分析

在Android应用开发中，当用户需要搜索或筛选列表数据时，通常会结合EditText和RecyclerView来实现。一个常见的问题是，当用户使用软键盘输入时，RecyclerView无法实时更新搜索结果，但在软键盘关闭后或使用物理键盘时却能正常工作。

现有代码中的问题根源在于数据加载和UI更新的异步处理方式。在原始实现中：

1. TextWatcher的afterTextChanged方法中，每次文本变化都会创建一个新的JTAdapter实例。
2. JTAdapter的构造函数内部启动了一个新的线程来查询和过滤应用列表。这是一个耗时操作。
3. 在创建新JTAdapter后，立即调用recyclerView.setAdapter(jtAdapter)和jtAdapter.notifyDataSetChanged()。

由于应用列表的查询和过滤是在后台线程中异步进行的，当setAdapter和notifyDataSetChanged被调用时，新创建的jtAdapter内部的jtList可能尚未被后台线程填充完毕。这导致RecyclerView显示的是一个空列表或旧数据。当软键盘关闭时，可能由于某些系统事件（如布局重绘）或后台线程最终完成数据加载，UI才得以更新。而使用物理键盘时，由于输入速度可能更快，或者事件处理机制不同，可能不会出现相同的延迟感知。

解决方案：利用Filterable接口实现高效过滤

为了解决上述问题，Android提供了一个标准的Filterable接口，结合Filter类，可以优雅地处理列表数据的过滤和UI更新。这种方法的核心思想是：

1. Adapter维护一个完整的原始数据集。
2. 当需要过滤时，Filter的performFiltering方法在后台线程执行过滤逻辑。
3. 过滤完成后，Filter的publishResults方法在UI线程更新Adapter的当前数据集并通知RecyclerView刷新。

1. 修改Adapter实现Filterable接口

首先，我们需要修改JTAdapter类，使其实现Filterable接口。这将要求我们实现getFilter()方法。

import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.graphics.drawable.Drawable;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Filter;
import android.widget.Filterable;
import android.widget.ImageView;
import android.widget.TextView;

import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;

public class JTAdapter extends RecyclerView.Adapter implements Filterable {

    private List jtList; // 当前显示的数据列表
    private List jtListAll; // 完整的原始数据列表
    private Context context;

    public JTAdapter(Context c) {
        this.context = c;
        this.jtList = new ArrayList<>();
        this.jtListAll = new ArrayList<>();
        // 初始加载所有应用，并在后台线程处理
        loadAllAppsAsync();
    }

    // 异步加载所有应用
    private void loadAllAppsAsync() {
        new Thread(() -> {
            PackageManager pm = context.getPackageManager();
            Intent i = new Intent(Intent.ACTION_MAIN, null);
            i.addCategory(Intent.CATEGORY_LAUNCHER);
            List allApps = pm.queryIntentActivities(i, 0);

            List tempAllApps = new ArrayList<>();
            for (ResolveInfo ri : allApps) {
                AppInfo app = new AppInfo();
                app.label = ri.loadLabel(pm);
                app.packageName = ri.activityInfo.packageName;
                app.icon = ri.activityInfo.loadIcon(pm);
                tempAllApps.add(app);
            }
            // 排序
            Collections.sort(tempAllApps, Comparator.comparing(o -> o.label.toString()));

            // 更新原始列表和当前列表，并在UI线程通知刷新
            ((android.app.Activity) context).runOnUiThread(() -> {
                jtListAll.clear();
                jtListAll.addAll(tempAllApps);
                jtList.clear();
                jtList.addAll(tempAllApps); // 初始显示所有应用
                notifyDataSetChanged();
            });
        }).start();
    }


    @Override
    public int getItemCount() {
        return jtList.size();
    }

    @Override
    public void onBindViewHolder(@NonNull JTAdapter.ViewHolder viewHolder, int i) {
        try {
            String appLabel = jtList.get(i).label.toString();
            Drawable appIcon = jtList.get(i).icon;
            TextView textView = viewHolder.textView;
            textView.setText(appLabel);
            ImageView imageView = viewHolder.img;
            imageView.setImageDrawable(appIcon);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @NonNull
    @Override
    public JTAdapter.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        LayoutInflater inflater = LayoutInflater.from(parent.getContext());
        View view = inflater.inflate(R.layout.jt_item_row_layout, parent, false);
        return new ViewHolder(view);
    }

    @Override
    public Filter getFilter() {
        return new Filter() {
            @Override
            protected FilterResults performFiltering(CharSequence charSequence) {
                String charString = charSequence.toString().toLowerCase(Locale.getDefault());
                List filteredList = new ArrayList<>();

                if (charString.isEmpty()) {
                    filteredList.addAll(jtListAll); // 如果搜索框为空，显示所有应用
                } else {
                    for (AppInfo app : jtListAll) {
                        if (app != null && app.label.toString().toLowerCase(Locale.getDefault()).startsWith(charString)) {
                            filteredList.add(app);
                        }
                    }
                }
                // 过滤结果排序
                Collections.sort(filteredList, Comparator.comparing(o -> o.label.toString()));

                FilterResults filterResults = new FilterResults();
                filterResults.values = filteredList;
                return filterResults;
            }

            @Override
            protected void publishResults(CharSequence charSequence, FilterResults filterResults) {
                jtList.clear();
                jtList.addAll((Collection) filterResults.values);
                notifyDataSetChanged(); // 在UI线程通知数据已更新
            }
        };
    }

    public static class ViewHolder extends RecyclerView.ViewHolder {
        public TextView textView;
        public ImageView img;

        public ViewHolder(View itemView) {
            super(itemView);
            textView = itemView.findViewById(R.id.jt_app_name);
            img = itemView.findViewById(R.id.jt_app_icon);

            itemView.setOnClickListener(v -> {
                int pos = getAdapterPosition();
                if (pos != RecyclerView.NO_POSITION) { // 确保位置有效
                    Context context = v.getContext();
                    Intent launchIntent = context.getPackageManager().getLaunchIntentForPackage(jtList.get(pos).packageName.toString());
                    if (launchIntent != null) {
                        context.startActivity(launchIntent);
                    }
                }
            });
        }
    }

    // 假设AppInfo类定义如下
    public static class AppInfo {
        public CharSequence label;
        public CharSequence packageName;
        public Drawable icon;
    }
}

关键改动点：

• jtList和jtListAll： jtList用于存储当前RecyclerView显示的数据，jtListAll存储所有应用的完整列表。
• 构造函数： 接收Context，并调用loadAllAppsAsync()在后台线程异步加载所有应用到jtListAll和jtList，并在加载完成后在UI线程调用notifyDataSetChanged()。
• getFilter()方法： 返回一个Filter实例。
  • performFiltering(CharSequence charSequence)：这个方法在后台线程执行。它根据charSequence（用户输入）从jtListAll中过滤数据，并将过滤后的结果封装在FilterResults中返回。
  • publishResults(CharSequence charSequence, FilterResults filterResults)：这个方法在UI线程执行。它接收performFiltering返回的FilterResults，清空jtList，添加新的过滤结果，然后调用notifyDataSetChanged()通知RecyclerView刷新。

2. 修改Fragment中的TextWatcher

接下来，我们需要修改Fragment中的TextWatcher，使其在文本变化后调用Adapter的filter.filter()方法，而不是重新创建Adapter。

import android.content.Context;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.TextView;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.core.content.ContextCompat;
import androidx.fragment.app.Fragment;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class MySearchFragment extends Fragment { // 假设Fragment名为MySearchFragment
    private RecyclerView recyclerView;
    private GridLayoutManager layoutManager;
    private EditText jt;
    private JTAdapter jtAdapter; // 声明为成员变量

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment_my_search, container, false); // 假设布局文件名为fragment_my_search
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        recyclerView = view.findViewById(R.id.justtype_view);
        layoutManager = new GridLayoutManager(getContext(), 4);
        recyclerView.setLayoutManager(layoutManager);
        jt = view.findViewById(R.id.jtInput);
        jt.requestFocus();
        jt.setFocusableInTouchMode(true); // 确保可获取焦点
        jt.setFocusable(true);

        if (jt.requestFocus()) {
            InputMethodManager imm = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
            if (imm != null) {
                imm.showSoftInput(jt, InputMethodManager.SHOW_IMPLICIT);
            }
        }

        Window w = requireActivity().getWindow();
        w.setStatusBarColor(ContextCompat.getColor(requireActivity(), R.color.status));
        recyclerView.setVisibility(View.INVISIBLE); // 初始隐藏，待数据加载完成再显示

        // 只创建一次Adapter实例
        jtAdapter = new JTAdapter(requireContext());
        recyclerView.setAdapter(jtAdapter);

        // 初始加载完成后，显示RecyclerView
        // jtAdapter的构造函数中会调用notifyDataSetChanged，此时可以根据jtList是否为空决定显示或隐藏
        // 或者在jtAdapter的loadAllAppsAsync()完成回调中设置setVisibility
        // 这里简化处理，假设初始加载后会显示
        recyclerView.setVisibility(View.VISIBLE);


        jt.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                // 不做任何操作
            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                // 不做任何操作
            }

            @Override
            public void afterTextChanged(Editable s) {
                // 当文本变化时，调用Adapter的filter方法进行过滤
                jtAdapter.getFilter().filter(s.toString());

                // 根据搜索结果决定RecyclerView的可见性
                if (s.length() > 0) {
                    recyclerView.setVisibility(View.VISIBLE);
                } else {
                    // 如果搜索框为空，Filter会显示所有应用，所以也应该可见
                    recyclerView.setVisibility(View.VISIBLE);
                }
                // textChange(view); // 如果有其他UI更新逻辑，可以在这里调用
            }
        });
    }
}

关键改动点：

• jtAdapter作为成员变量： 确保JTAdapter只被创建一次。
• TextWatcher： 在afterTextChanged方法中，不再创建新的Adapter，而是直接调用jtAdapter.getFilter().filter(s.toString())来触发过滤过程。
• RecyclerView可见性： 初始时可以隐藏RecyclerView，待Adapter加载完初始数据后（在loadAllAppsAsync的回调中）再设置为可见。在afterTextChanged中，根据搜索文本长度决定可见性，但由于空字符串也会显示所有应用，所以通常保持可见。

注意事项与最佳实践

1. UI线程安全： Filter机制已经确保performFiltering在后台线程运行，publishResults在UI线程运行，因此无需手动处理线程切换。
2. 数据完整性： 确保jtListAll（原始数据列表）在整个生命周期中保持不变，这样每次过滤都能基于完整的数据集。
3. 性能优化：
   • 避免在onBindViewHolder中执行耗时操作。
   • 对于大量数据的过滤，可以考虑引入延迟（debounce）机制，即用户停止输入一段时间后再触发过滤，以减少不必要的频繁计算。
   • 如果数据量特别大，可以考虑使用DiffUtil来优化RecyclerView的局部更新，而不是每次都调用notifyDataSetChanged()。
4. 错误处理： 在数据加载和过滤过程中，应加入适当的错误处理机制，例如网络请求失败、权限不足等。
5. 内存管理： 确保AppInfo对象和相关资源（如Drawable）在不再需要时能被正确释放，避免内存泄漏。特别是对于Drawable，如果应用图标数量很多，需要注意其内存占用。
6. 用户体验： 在数据加载或过滤时，可以显示一个加载指示器（如ProgressBar），告知用户正在进行操作，提升用户体验。

总结

通过采用Filterable接口和Filter机制，我们能够以一种更规范、高效且线程安全的方式处理RecyclerView的实时搜索和过滤功能。这种方法避免了在每次文本变化时重复创建Adapter的性能开销和潜在的UI更新问题，确保了软键盘输入时RecyclerView能够实时、流畅地更新，从而显著提升了应用的用户体验。