Java 无法解析方法getFilter（）方法

它显示了相同的错误，但是我尝试实现这个函数。我不明白是什么造成了问题，因为这只是类中的另一个函数。 我是通过使用带有RecyclerAdapter的SearchView实现此功能的。我见过其他代码，但都是以相同的类型实现的。 这是最新的

class ProductsRecyclerAdapter扩展了RecyclerView。适配器实现可过滤{
List productList=Collections.emptyList（）；
语境；
List filteredProductList=Collections.emptyList（）；
公共产品RecyclerAdapter（列表产品列表、上下文）{
this.productList=productList；
this.context=上下文；
filteredProductList=产品列表；
}
公共类MyViewHolder扩展了RecyclerView.ViewHolder{
TextView产品名称；
ImageView产品图片；
CardView产品目录卡；
AVLoadingIndicator查看进度\球\图像；
公共MyViewHolder（视图）{
超级（视图）；
product\u name=view.findviewbyd（R.id.product\u name）；
product\u image=view.findviewbyd（R.id.product\u image）；
产品目录卡=view.findviewbyd（R.id.product目录卡）；
progress\u ball\u image=view.findviewbyd（R.id.progress\u ball\u image）；
}
}
@凌驾
公共MyViewHolder onCreateViewHolder（视图组父级，int-viewType）{
View itemView=LayoutFlater.from（parent.getContext（））.flate（R.layout.product\u entity\u design，parent，false）；
返回新的MyViewHolder（itemView）；
}
@凌驾
公共无效onBindViewHolder（最终MyViewHolder，最终int位置）{
holder.product\u name.setText（productList.get（position）.about）；
holder.progress\u ball\u image.setVisibility（View.VISIBLE）；
毕加索。与（上下文）
.load（productList.get（position）.image.get（0.url）
.centerInside（）
.调整大小（200200）
.memoryPolicy（memoryPolicy.NO_STORE）
.into（holder.product_图像，新回调（）{
@凌驾
成功时的公共无效（）{
holder.progress_ball_image.smoothToHide（）；
}
@凌驾
公开无效{
}
});
holder.product\u catalog\u card.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图v）{
Intent Intent=新的Intent（v.getContext（），ProductDetail.class）；
intent.putExtra（“产品”，productList.get（位置））；
v、 getContext（）.startActivity（意图）；
}
});
}
@凌驾
public int getItemCount（）{
返回productList.size（）；
}
@凌驾
公共过滤器getFilter（）{
返回新筛选器（）{
@凌驾
受保护过滤器结果执行过滤（CharSequence CharSequence）{
String charString=charSequence.toString（）；
if（charString.isEmpty（））{
filteredProductList=产品列表；
}否则{
ArrayList filteredList=新建ArrayList（）；
对于（ProductEntity ProductEntity:productList）{
if（productEntity.about.toLowerCase（）.contains（charString））{
filteredList.add（productEntity）；
}
}
filteredProductList=filteredList；
}
FilterResults FilterResults=新的FilterResults（）；
filterResults.values=filteredProductList；
返回过滤器结果；
}
@凌驾
受保护的无效发布结果（CharSequence CharSequence、FilterResults FilterResults）{
filteredProductList=（ArrayList）filterResults.values；
notifyDataSetChanged（）；
}
};
}
}

---

Rahul Mishra，看，您将变量

productsRecyclerAdapter

声明为RecyclerView.Adapter，但您需要productsRecyclerAdapter。更改变量的类型，它将起作用

我可以看到您的ProductsRecyclerAdapter类具有包可见性。您是否试图在同一个包中使用此适配器？是的，这会造成任何问题。如果我想看的话，我已经在上面的链接中发布了我的全部内容。我刚刚通过创建另一个类来检查它，但这没有帮助。这是一个愚蠢的错误。我沉思了好几个小时。非常感谢你的帮助。

class ProductsRecyclerAdapter extends RecyclerView.Adapter<ProductsRecyclerAdapter.MyViewHolder> implements Filterable {

    List<ProductEntity> productList = Collections.emptyList();
    Context context;
    List<ProductEntity> filteredProductList = Collections.emptyList();

    public ProductsRecyclerAdapter(List<ProductEntity> productList, Context context) {
        this.productList = productList;
        this.context = context;
        filteredProductList = productList;
    }

    public class MyViewHolder extends RecyclerView.ViewHolder {

        TextView product_name;
        ImageView product_image;
        CardView product_catalog_card;
        AVLoadingIndicatorView progress_ball_image ;

        public MyViewHolder(View view) {
            super(view);
            product_name = view.findViewById(R.id.product_name);
            product_image = view.findViewById(R.id.product_image);
            product_catalog_card = view.findViewById(R.id.product_catalog_card);
            progress_ball_image = view.findViewById(R.id.progress_ball_image) ;
        }
    }

    @Override
    public MyViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View itemView = LayoutInflater.from(parent.getContext()).inflate(R.layout.product_entity_design, parent, false);
        return new MyViewHolder(itemView);
    }

    @Override
    public void onBindViewHolder(final MyViewHolder holder, final int position) {
        holder.product_name.setText(productList.get(position).about);
        holder.progress_ball_image.setVisibility(View.VISIBLE) ;
        Picasso.with(context)
                .load(productList.get(position).image.get(0).url)
                .centerInside()
                .resize(200, 200)
                .memoryPolicy(MemoryPolicy.NO_STORE)
                .into(holder.product_image, new Callback() {
                    @Override
                    public void onSuccess() {
                        holder.progress_ball_image.smoothToHide(); ;
                    }

                    @Override
                    public void onError() {

                    }
                });
        holder.product_catalog_card.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(v.getContext(), ProductDetail.class);
                intent.putExtra("product", productList.get(position));
                v.getContext().startActivity(intent);
            }
        });
    }

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

    @Override
    public Filter getFilter() {
        return new Filter() {
            @Override
            protected FilterResults performFiltering(CharSequence charSequence) {
                String charString = charSequence.toString();
                if (charString.isEmpty()) {
                    filteredProductList = productList;
                } else {
                    ArrayList<ProductEntity> filteredList = new ArrayList<>();
                    for (ProductEntity productEntity : productList) {
                        if (productEntity.about.toLowerCase().contains(charString)) {
                            filteredList.add(productEntity);
                        }
                    }
                    filteredProductList = filteredList;
                }

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

            @Override
            protected void publishResults(CharSequence charSequence, FilterResults filterResults) {
                filteredProductList = (ArrayList<ProductEntity>) filterResults.values;
                notifyDataSetChanged();
            }
        };
    }
}