【Android】RecyclerView详解(二)

最新推荐文章于 2024-06-27 22:39:01 发布
最新推荐文章于 2024-06-27 22:39:01 发布
阅读量5.1k 收藏 1
点赞数 1
分类专栏： android开发进阶 文章标签： android recycler 上拉加载 刷新 瀑布流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangkeke1860/article/details/51577158
版权


上篇文章介绍了RecyclerView的基本使用，今天我们来着重实践一下RecyclerView瀑布流的效果以及上拉加载的功能；如果您对RecyclerView还不太了解的话请先阅读下上篇文章【Android】RecyclerView详解(一)；

首先我们要实现下面这个效果：

这里写图片描述

1.普通瀑布流

  • 开始之前先添加依赖库
    compile 'com.android.support:recyclerview-v7:23.4.0'
    compile 'com.android.support:cardview-v7:23.4.0'
    compile 'com.android.support:appcompat-v7:23.4.0'
    compile 'com.squareup.picasso:picasso:2.5.2'
  • activity_main.xml文件代码问下，很简单就一个RecyclerView组件
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    >

    <android.support.v7.widget.RecyclerView
        android:id="@+id/rv_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        />

</RelativeLayout>
  • item.xml文件代码问下，添加了一个ImageView组件，外层用cardview包裹
<?xml version="1.0" encoding="utf-8"?>
<android.support.v7.widget.CardView
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/cardview"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_margin="5dp"
    app:cardBackgroundColor="@android:color/white"
    app:cardCornerRadius="5dp"
    app:cardElevation="5dp"
    app:contentPadding="10dp" >

    <ImageView
        android:id="@+id/item_image"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:scaleType="fitXY"
        />

</android.support.v7.widget.CardView>
  • 添加适配器Adapter
 class MyAdapter extends RecyclerView.Adapter<ViewHolder>
    {
        public List<String> datas = null;

        public MyAdapter(List<String> datas)
        {
            this.datas = datas;
        }

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

        @Override
        public void onBindViewHolder(ViewHolder viewHolder, int i)
        {
            //加载图片
            ImageLoader.getInstance().displayImage(datas.get(i), ((MyViewHolder)viewHolder).image);
        }

        @Override
        public ViewHolder onCreateViewHolder(ViewGroup viewGroup, int position)
        {
            View view = LayoutInflater.from(viewGroup.getContext()).inflate(R.layout.item, viewGroup, false);
            ViewHolder vh = new MyViewHolder(view);
            return vh;
        }

    }

    public static class MyViewHolder extends RecyclerView.ViewHolder
    {

        public ImageView image;

        public MyViewHolder(View itemView)
        {
            super(itemView);
            image = (ImageView)itemView.findViewById(R.id.item_image);
        }

    }
  • activity中控制显示，至此，简单的瀑布流效果也就完成了，效果图如上图；
recyclerView = (RecyclerView)findViewById(R.id.rv_view);
        // 设置瀑布流布局
        StaggeredGridLayoutManager stagManager = new StaggeredGridLayoutManager(2, StaggeredGridLayoutManager.VERTICAL);
        recyclerView.setLayoutManager(stagManager);
        //模拟数据
        for (int i = 0; i < ImageURL.length; i++)
        {
            datas.add(ImageURL[i]);
        }
        MyAdapter adapter = new MyAdapter(datas);
        recyclerView.setAdapter(adapter);

2.上拉加载

当然这可能无法满足项目使用，一般都会结合上拉和下拉一起使用，关于下拉刷新这里不作介绍，比较简单，这里重点介绍一下RecyclerView各种layoutManager上拉加载功能，此处参考_区长的实现思路，略作改动，下面一起来看下如何实现的吧！

  • 添加上拉加载接口回调OnLoadMoreListener
public interface OnLoadMoreListener<T> {
    /**
     * 加载更多前回调，比如显示Footer的操作
     */
    void onStart();

    /**
     * 加载更多业务处理，如网络请求数据
     */
    void onLoadMore();

    /**
     * 由于onLoadMore可能是异步调用的，所以onFinish需要手动调用，完成数据的刷新，隐藏Footer等
     * @param list onLoadMore中返回的数据
     */
    void onFinish(List<T> list);
}


- 实现上拉加载主要还是要为RecyclerView添加头和尾，目前普遍的方式是根据 getItemViewType方法，依据返回的type类型来加载不同的布局来实现；


  @Override
    public int getItemViewType(int type)


  • 至于RecyclerView何时出发上拉加载操作，Recyclerview给我们提供了OnScrollListener监听，我们可以监听当前显示item的最后一项显示的时候来出发上拉加载操作；
public abstract class OnRecyclerViewScrollListener<T extends String> extends RecyclerView.OnScrollListener implements OnLoadMoreListener<T> {

    public static enum layoutManagerType {
        LINEAR_LAYOUT,
        GRID_LAYOUT,
        STAGGERED_GRID_LAYOUT
    }

    protected layoutManagerType mLayoutManagerType;
    private boolean mIsLoadingMore = false;
    public boolean isLoadingMore() {
        return mIsLoadingMore;
    }
    public void setLoadingMore(boolean loadingMore) {
        mIsLoadingMore = loadingMore;
    }



    private int[] lastPositions;
    private int lastVisibleItemPosition;
    private int currentScrollState = 0;

    @Override
    public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
        super.onScrolled(recyclerView, dx, dy);

        //获取当前layoutManager类型
        RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();
        //指定当前layoutManager类型
        if (mLayoutManagerType == null) {
            if (layoutManager instanceof LinearLayoutManager) {
                mLayoutManagerType = layoutManagerType.LINEAR_LAYOUT;
            } else if (layoutManager instanceof GridLayoutManager) {
                mLayoutManagerType = layoutManagerType.GRID_LAYOUT;
            } else if (layoutManager instanceof StaggeredGridLayoutManager) {
                mLayoutManagerType = layoutManagerType.STAGGERED_GRID_LAYOUT;
            } else {
                throw new RuntimeException("Unsupported LayoutManager used. Valid ones are LinearLayoutManager, GridLayoutManager and StaggeredGridLayoutManager");
            }
        }

        switch (mLayoutManagerType) {
            case LINEAR_LAYOUT:
                //找到当前显示的所有item的最后一项
                lastVisibleItemPosition = ((LinearLayoutManager) layoutManager).findLastVisibleItemPosition();
                break;
            case GRID_LAYOUT:
                //找到当前显示的所有item的最后一项
                lastVisibleItemPosition = ((GridLayoutManager) layoutManager).findLastVisibleItemPosition();
                break;
            case STAGGERED_GRID_LAYOUT:
                //找到当前显示的所有item的最后一项
                StaggeredGridLayoutManager staggeredGridLayoutManager = (StaggeredGridLayoutManager) layoutManager;
                if (lastPositions == null) {
                    lastPositions = new int[staggeredGridLayoutManager.getSpanCount()];
                }
                staggeredGridLayoutManager.findLastVisibleItemPositions(lastPositions);
                lastVisibleItemPosition = findMax(lastPositions);
                break;
            default:
                break;
        }
    }

    /**
     * recyclerView滑动状态改变时调用此方法
     * @param recyclerView
     * @param newState
     */
    @Override
    public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
        super.onScrollStateChanged(recyclerView, newState);
        currentScrollState = newState;
        RecyclerView.LayoutManager layoutManager = recyclerView.getLayoutManager();
        int visibleItemCount = layoutManager.getChildCount();
        int totalItemCount = layoutManager.getItemCount();
        if (visibleItemCount > 0 && currentScrollState == RecyclerView.SCROLL_STATE_IDLE
                && lastVisibleItemPosition >= totalItemCount - 1) {
            if (!isLoadingMore()){
                mIsLoadingMore =true;
                onStart();
                onLoadMore();
            }
        }
    }

    private int findMax(int[] lastPositions) {
        int max = lastPositions[0];
        for (int value : lastPositions) {
            if (value > max) {
                max = value;
            }
        }
        return max;
    }
}


  • 处理的关键还是适配器的处理，下面看下区长封装的Adapter基类
public abstract class RecyclerViewAdapter<T extends String> extends RecyclerView.Adapter<RecyclerView.ViewHolder>
{

    /**
     * 不同的布局类型，0代表头部，1代表尾部，2代表普通布局
     */
    public interface Item
    {
        int TYPE_HEADER = 0;
        int TYPE_FOOTER = 1;
        int TYPE_NORMAL = 2;
    }

    //数据源
    private List<T> list = null;

    //头部layout资源id
    private int headerViewRes;

    //尾部layout资源id
    private int footerViewRes;

    //当前是否有头
    private boolean hasHeader = false;

    //当前是否有尾
    private boolean hasFooter = false;

    public List<T> getList()
    {
        return list;
    }

    public void setList(List<T> list)
    {
        this.list = list;
    }

    /**
     * 判断position位置的item是否是头head
     * @param position
     * @return
     */
    public boolean isHeader(int position)
    {
        return hasHeader() && position == 0;
    }

    /**
     * 判断position位置的item是否是尾foot
     * @param position
     * @return
     */
    public boolean isFooter(int position)
    {
        if (hasHeader())
        {
            return hasFooter() && position == list.size() + 1;
        } else
        {
            return hasFooter() && position == list.size();
        }
    }

    public boolean hasHeader()
    {
        return hasHeader;
    }

    public boolean hasFooter()
    {
        return hasFooter;
    }


    public int getHeaderView()
    {
        return headerViewRes;
    }

    public int getFooterView()
    {
        return footerViewRes;
    }

    /**
     * 设置头部layout布局文件
     *
     * @param headerViewRes
     */
    public void setHeaderView(int headerViewRes)
    {
        if (headerViewRes != 0)
        {
            if (!hasHeader())
            {
                this.headerViewRes = headerViewRes;
                this.hasHeader = true;
                notifyItemInserted(0);
            } else
            {
                this.headerViewRes = headerViewRes;
                notifyDataSetChanged();
            }
        } else
        {
            if (hasHeader())
            {
                this.hasHeader = false;
                notifyItemRemoved(0);
            }
        }
    }

    /**
     * 设置尾部layout布局文件
     *
     * @param footerViewRes
     */
    public void setFooterView(int footerViewRes)
    {
        if (footerViewRes != 0)
        {
            if (!hasFooter())
            {
                this.footerViewRes = footerViewRes;
                this.hasFooter = true;
                if (hasHeader())
                {
                    notifyItemInserted(list.size() + 1);
                } else
                {
                    notifyItemInserted(list.size());
                }
            } else
            {
                this.footerViewRes = footerViewRes;
                notifyDataSetChanged();
            }

        } else
        {
            if (hasFooter())
            {
                this.hasFooter = false;
                if (hasHeader())
                {
                    notifyItemRemoved(list.size() + 1);
                } else
                {
                    notifyItemRemoved(list.size());
                }
            }
        }
    }

    /**
     * 构造函数
     * @param list
     */
    public RecyclerViewAdapter(List<T> list) {
        this.list = list;
    }

    /**
     * 构造函数
     * @param list
     * @param headerViewRes
     */
    public RecyclerViewAdapter(List<T> list, int headerViewRes) {
        this.list = list;
        setHeaderView(headerViewRes);
    }

    /**
     * 构造函数
     * @param list
     * @param headerViewRes
     * @param footerViewRes
     */
    public RecyclerViewAdapter(List<T> list, int headerViewRes,int footerViewRes)
    {
        this.list = list;
        setHeaderView(headerViewRes);
        setFooterView(footerViewRes);
    }


    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType)
    {
        /**
         * 根据不同的类型加载不同的ViewHolder
         */
        if (hasHeader() && viewType == Item.TYPE_HEADER) {
            View v = LayoutInflater.from(parent.getContext()).inflate(getHeaderView(), parent, false);
            return new HeaderViewHolder(v);
        } else if (hasFooter() && viewType == Item.TYPE_FOOTER) {
            View v = LayoutInflater.from(parent.getContext()).inflate(getFooterView(), parent, false);
            return new FooterViewHolder(v);
        } else {
            return onCreateHolder(parent, viewType);
        }
    }

    /*以下是抽象出来的公共方法，用于实现普通布局的处理*/

    public abstract RecyclerView.ViewHolder onCreateHolder(ViewGroup parent, int viewType);

    protected abstract void onBindHeaderView(View headerView);

    protected abstract void onBindFooterView(View footerView);

    protected abstract void onBindItemView(RecyclerView.ViewHolder holder, T item);

    /*抽象结束*/

    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position)
    {
        /**
         * 根据类型来绑定数据
         */

        if (getItemViewType(position) == Item.TYPE_HEADER) {
            HeaderViewHolder headerHolder = (HeaderViewHolder) holder;
            View headerView = headerHolder.itemView;

            onBindHeaderView(headerView);
        } else if (getItemViewType(position) == Item.TYPE_FOOTER) {
            FooterViewHolder footerHolder = (FooterViewHolder) holder;
            View footerView = footerHolder.itemView;

            onBindFooterView(footerView);
        } else {
            T i = getItemByPosition(position);
            onBindItemView(holder, i);

        }
    }

    /**
     * 返回item数量
     * @return
     */
    @Override
    public int getItemCount() {
        int count = 0;
        count += (hasHeader() ? 1 : 0);
        count += (hasFooter() ? 1 : 0);
        count += list.size();
        return count;
    }

    /**
     * 获取position位置的数据值
     * @param position
     * @return
     */
    protected T getItemByPosition(int position) {
        if (hasHeader()) {
            return list.get(position - 1);
        } else {
            return list.get(position);
        }
    }


    @Override
    public int getItemViewType(int position)
    {
        int size = list.size();
        if (hasHeader()) {
            //包含头部并且position为0时返回Header类型
            if (position == 0) {
                return Item.TYPE_HEADER;
            } else {
                if (position == size + 1) {
                    return Item.TYPE_FOOTER;
                } else {
                    return Item.TYPE_NORMAL;
                }
            }

        } else {
            if (position == size) {
                return Item.TYPE_FOOTER;
            } else {
                return Item.TYPE_NORMAL;
            }
        }
    }

    /**
     * 头部viewhodler
     */
    static class HeaderViewHolder extends RecyclerView.ViewHolder {
        public HeaderViewHolder(View itemView) {
            super(itemView);
        }
    }

    /**
     * 尾部viewhodler
     */
    static class FooterViewHolder extends RecyclerView.ViewHolder {
        public FooterViewHolder(View itemView) {
            super(itemView);
        }
    }

}

  • 我们在使用时只需要继承RecyclerViewAdapter，来实现自己需要的adapter，下面我们分别来实现一下，看看效果；

  • LinearLayoutAdapter

public abstract class LinearLayoutAdapter extends RecyclerViewAdapter
{

    public LinearLayoutAdapter(List list)
    {
        super(list);
    }

    public LinearLayoutAdapter(List list, int headerViewRes)
    {
        super(list, headerViewRes);
    }

    public LinearLayoutAdapter(List list, int headerViewRes, int footerViewRes)
    {
        super(list, headerViewRes, footerViewRes);
    }
}


  • MyLinearAdapter继承LinearLayoutAdapter进行细节处理
public class MyLinearAdapter extends LinearLayoutAdapter
{
    public MyLinearAdapter(List list)
    {
        super(list);
    }

    public MyLinearAdapter(List list, int headerViewRes)
    {
        super(list, headerViewRes);
    }

    public MyLinearAdapter(List list, int headerViewRes, int footerViewRes)
    {
        super(list, headerViewRes, footerViewRes);
    }

    @Override
    public RecyclerView.ViewHolder onCreateHolder(ViewGroup parent, int viewType)
    {
        View view= LayoutInflater.from(parent.getContext()).inflate(R.layout.item,parent,false);
        return new ItemViewHolder(view);
    }

    @Override
    protected void onBindHeaderView(View headerView)
    {
        //头部绑定后进行一些处理操作
    }

    @Override
    protected void onBindFooterView(View footerView)
    {
        //尾部绑定后进行一些处理操作
    }

    @Override
    protected void onBindItemView(RecyclerView.ViewHolder holder, String item)
    {
        ItemViewHolder itemViewHolder = (ItemViewHolder) holder;
        Picasso.with(holder.itemView.getContext()).load(item).into(itemViewHolder.icon);
    }

    static class ItemViewHolder extends RecyclerView.ViewHolder {
        ImageView icon;
        public ItemViewHolder(View itemView) {
            super(itemView);
            icon = (ImageView) itemView.findViewById(R.id.item_image);
        }
    }
}
  • Activity中设置相关配置
LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this);
recyclerView.setLayoutManager(linearLayoutManager);
adapter =  new MyLinearAdapter(datas);
recyclerView.setAdapter(adapter);

recyclerView.addOnScrollListener(new OnRecyclerViewScrollListener<String>(){
            @Override
            public void onStart() {
                adapter.setFooterView(R.layout.footer);
                if (adapter.hasHeader()){
                    recyclerView.smoothScrollToPosition(adapter.getItemCount()+1);
                }else{
                    recyclerView.smoothScrollToPosition(adapter.getItemCount());
                }
            }

            @Override
            public void onLoadMore() {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(3000);
                            //手动调用onFinish()
                            onFinish(arrayList);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }

            @Override
            public void onFinish(List<String> contents) {
                Message message=Message.obtain();
                message.obj=contents;
                handler.sendMessage(message);
                setLoadingMore(false);
            }
        });
  • handler中更新界面
private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg)
        {
            List<String> list= (List<String>) msg.obj;
            adapter.getList().addAll(list);
            adapter.notifyDataSetChanged();
            adapter.setFooterView(0);
        }
    };
  • 效果图如下：

这里写图片描述

  • GridLayoutAdapter如下：
public abstract class GridLayoutAdapter<T extends String> extends RecyclerViewAdapter {

    public GridLayoutAdapter(List list) {
        super(list);
    }
    public GridLayoutAdapter(List list, int headerViewRes) {
        super(list, headerViewRes);
    }

    public GridLayoutAdapter(List list, int headerViewRes, int footerViewRes) {
        super(list, headerViewRes, footerViewRes);
    }

    private GridSpanSizeLookup mGridSpanSizeLookup;
    private GridLayoutManager gridManager;
    @Override
    public void onAttachedToRecyclerView(RecyclerView recyclerView) {
        super.onAttachedToRecyclerView(recyclerView);
        RecyclerView.LayoutManager manager = recyclerView.getLayoutManager();
        if (manager instanceof GridLayoutManager) {
            gridManager = ((GridLayoutManager) manager);
            if (mGridSpanSizeLookup == null) {
                mGridSpanSizeLookup = new GridSpanSizeLookup();
            }
            gridManager.setSpanSizeLookup(mGridSpanSizeLookup);
        }
    }

    class GridSpanSizeLookup extends GridLayoutManager.SpanSizeLookup {
        @Override
        public int getSpanSize(int position) {
            if (isHeader(position) || isFooter(position)) {
                //包含头部和尾部时合并成一行显示，getSpanCount代表列数
                return gridManager.getSpanCount();
            }
            return 1;
        }
    }


}
  • MyGridAdapter继承GridlayoutAdapter进行细节处理：
public class MyGridAdapter extends GridLayoutAdapter{


    public MyGridAdapter(List<String> list, int headerViewRes) {
        super(list, headerViewRes);
    }

    public MyGridAdapter(List<String> list) {
        super(list);
    }

    public MyGridAdapter(List<String> list, int headerViewRes, int footerViewRes) {
        super(list, headerViewRes, footerViewRes);
    }

    @Override
    public RecyclerView.ViewHolder onCreateHolder(ViewGroup parent, int viewType) {
        View view=LayoutInflater.from(parent.getContext()).inflate(R.layout.item,parent,false);
        return new ItemViewHolder(view);
    }

    @Override
    protected void onBindHeaderView(View headerView) {
        //这是HeadView数据绑定的过程
    }

    @Override
    protected void onBindFooterView(View footerView) {
        //这是FootView数据绑定的过程
    }

    @Override
    protected void onBindItemView(RecyclerView.ViewHolder holder, String item)
    {
        ItemViewHolder itemViewHolder = (ItemViewHolder) holder;
        Picasso.with(holder.itemView.getContext()).load(item).into(itemViewHolder.icon);
    }

    static class ItemViewHolder extends RecyclerView.ViewHolder {
        ImageView icon;
        public ItemViewHolder(View itemView) {
            super(itemView);
            icon = (ImageView) itemView.findViewById(R.id.item_image);
        }
    }
}
  • 效果图：

这里写图片描述

  • 瀑布流adapterGridLayoutAdapter如下：
public abstract class StaggeredGridLayoutAdapter<T extends String> extends RecyclerViewAdapter<T> {
    public StaggeredGridLayoutAdapter(List<T> list) {
        super(list);
    }

    public StaggeredGridLayoutAdapter(List<T> list, int headerViewRes) {
        super(list, headerViewRes);
    }

    public StaggeredGridLayoutAdapter(List<T> list, int headerViewRes, int footerViewRes) {
        super(list, headerViewRes, footerViewRes);
    }

    @Override
    public void onViewAttachedToWindow(RecyclerView.ViewHolder holder) {
        super.onViewAttachedToWindow(holder);
        if (isStaggeredGridLayout(holder)) {
            handleLayoutIfStaggeredGridLayout(holder, holder.getLayoutPosition());
        }
    }

    private boolean isStaggeredGridLayout(RecyclerView.ViewHolder holder) {
        ViewGroup.LayoutParams layoutParams = holder.itemView.getLayoutParams();
        if (layoutParams != null && layoutParams instanceof StaggeredGridLayoutManager.LayoutParams) {
            return true;
        }
        return false;
    }

    protected void handleLayoutIfStaggeredGridLayout(RecyclerView.ViewHolder holder, int position) {
        if (isHeader(position) || isFooter(position)) {
            StaggeredGridLayoutManager.LayoutParams p = (StaggeredGridLayoutManager.LayoutParams) holder.itemView.getLayoutParams();
            //有头尾时合并一列显示
            p.setFullSpan(true);
        }
    }
}
  • MyRecAdapter 继承StaggeredGridLayoutAdapter进行细节处理：
public class MyRecAdapter extends StaggeredGridLayoutAdapter{


    public MyRecAdapter(List<String> list, int headerViewRes) {
        super(list, headerViewRes);
    }

    public MyRecAdapter(List<String> list) {
        super(list);
    }

    public MyRecAdapter(List<String> list, int headerViewRes, int footerViewRes) {
        super(list, headerViewRes, footerViewRes);
    }

    @Override
    public RecyclerView.ViewHolder onCreateHolder(ViewGroup parent, int viewType) {
        View view=LayoutInflater.from(parent.getContext()).inflate(R.layout.item,parent,false);
        return new ItemViewHolder(view);
    }

    @Override
    protected void onBindHeaderView(View headerView) {
        //这是HeadView数据绑定的过程
    }

    @Override
    protected void onBindFooterView(View footerView) {
        //这是FootView数据绑定的过程
    }

    @Override
    protected void onBindItemView(RecyclerView.ViewHolder holder, String item)
    {
        ItemViewHolder itemViewHolder = (ItemViewHolder) holder;
        Picasso.with(holder.itemView.getContext()).load(item).into(itemViewHolder.icon);
    }

    static class ItemViewHolder extends RecyclerView.ViewHolder {
        ImageView icon;
        public ItemViewHolder(View itemView) {
            super(itemView);
            icon = (ImageView) itemView.findViewById(R.id.item_image);
        }
    }
}
  • 效果图：

这里写图片描述



记录下学习过程，希望能帮到您！源码下载




寒小枫
关注
专栏目录
Android RecyclerView详解(一)
Android开发-CXY的博客
03-14 1331
Android RecyclerView详解(一) RecyclerView Android 5.0之后，谷歌公司推出了RecyclerView控件 一.什么是RecyclerView？ RecylerView是support-v7包中的新组件，是一个强大的滑动组件，与ListView相比，同样拥有item回收复用的功能，并且从它的名字recylerview即回收view也可以看出。其他可
安卓RecyclerView详解
weixin_43547832的博客
10-27 946
RecyclerView 今天我们就来学习一下我们最常用的控件，又是比较难的控件——recyclerview 下面就是本节课我们学习的效果图： 第一步，添加RecyclerView的依赖库 我们在使用recyclerview之前，需要在项目的build.gradle中添加相应的依赖库我们才能使用这个控件 打开app/build.gradle文件，在dependencies闭包中添加以下的内容： ...
展开说说：Android列表之RecyclerView
最新发布
Hidanchaofan的博客
06-27 953
RecyclerView 内置ViewHolder，省去了每次findViewById() 创建视图；当列表滑动的时候，只有少量相邻的视图会被创建。当视图滑出屏幕时，RecyclerView 会复用它并且填充新的数据。由于它是通过回收已有的结构而不是持续创建新的列表项，所以它可以有效提高应用的时间效率和空间效率。
android RecyclerView 讲解
mffandxx的博客
01-11 630
文章的前面奉送上代码,方便对照学习。1 前言RecyclerView是Android5.0带来的一个旨在替代ListView的新控件，收录在android.support.v7.widget包下。转眼之间，它已经面世2多年了。最近仔细的学习学习这个控件，做一个记录。 本文介绍如下内容：1.添加分隔线的介绍（DividerItemDecoration）。 2.添加删除动画的实现。 3.布局管理器的实
Android基础-RecyclerView详解
AdrianAndroid的专栏
10-23 1711
资料 ItemDecoration深入解析与实战（一）——源码分析 一款不错的流式布局LayoutManager-FlowLayout
Android RecyclerView使用详解一
Shi_Liz的博客
12-06 4292
今天，开始总结一下RecyclerView。本篇内容，介绍下RecyclerView，然后讲解RecyclerView的常规使用方法，包括点击事件通用添加的方法。 介绍说到RecyclerView，我想大部分朋友都会想到ListView。没错，这两者都是用来展示一个页面一定数量的列表信息的。而且，它们的内部实现也何其相似，都是通过维护少量view来展示大量信息，这个少量view就是一页的view。那
Android RecyclerView详解及简单实例
08-31
【Android RecyclerView详解】 Android RecyclerView 是一个强大的视图组件，它在Android 5.0（API级别21）中被引入，用于替代ListView等传统的列表视图。RecyclerView的主要优点在于其高度可定制化和高效的内存...
Android RecyclerView 复用错乱通用解法详解
08-29
Android RecyclerView 复用错乱通用解法详解 Android RecyclerView 是一个非常流行的UI控件，用于展示大量内容。在实际开发中，我们经常会遇到 RecyclerView 的复用错乱问题。本文将详细介绍RecyclerView 复用错乱...
Android RecyclerView详解之实现 ListView GridView瀑布流效果
01-05
什么是RecyclerView RecyclerView 是Google推出的最新的 替代ListView、GridView的组件，RecyclerView是用来显示大量数据的容器，并通过有限数量的子View，来提高滚动时的性能。 与ListView不同，RecyclerView 不再...
Android RecyclerView 基础知识详解
09-01
Android RecyclerView 是Android开发中的一个核心组件，它在Android Lollipop（API 21）及以后的版本中引入，作为ListView和GridView的替代品。RecyclerView的设计目标是提高性能、可定制性和用户体验，尤其是在处理...
Android控件知识点-RecyclerView（全网最详解）
jdaljd的博客
10-22 4296
RecyclerView简称 RV， 是作为 ListView 和 GridView 的加强版出现的，目的是在有限的屏幕之上展示大量的内容，因此 RecyclerView 的复用机制的实现是它的一个核心部分。RecyclerView可以说是做Android应用开发使用最广的几个控件之一。在最新的的Android版本里是如下导包的改完了build.gradle记得要Sync Now。提供了多种LayoutManager，可轻松实现多种样式的布局支持局部刷新。
Android RecyclerView基本使用详解
01-03
什么是RecyclerView 关于RecyclerView，是一个主要用于展示和回收View的有一个控件，在官用了一句话来概括 RecyclerView 是一种通过提供有限的数据项窗口有效显示大数据集的视图。 基提供几个基本的功能， 控制其显示的方式 ———>LayoutManager—(必需) 控制Item间的间隔 ———>ItemDecoration—-(非必需) 控制Item增删的动画——->ItemAnimator——(非必需) 以上就可以完成ListView大部的功能了，但是确缺少了一个很常用的功能，就是Item的点需事件。当然，这个并不是什么问题，上文也说了，RecyclerV
Android学习笔记之RecyclerView详解
GodV的博客
09-22 2480
Android学习笔记之RecyclerView详解 RecyclerView是什么？　　在android5.0，开始出现了一些新特性，其中就包括了非常受欢迎的RecyclerView。RecyclerView是一种新的视图组，其目的是为任何基于适配器的视图提供相似的渲染方式。该控件用于在有限的窗口中展示大量数据集，它被作为ListView和GirdView控件的继承者。RecyclerView高度
Android RecyclerView使用详解二
Shi_Liz的博客
12-07 1150
上一篇，介绍了RecyclerView的特点，并展示了一个基本的RecyclerView需要涉及到的步骤：获取RecyclerView，创建并设置排布方式，复写adapter和内部的ViewHolder，并设置adapter。本篇将展示一下，水平排布、网格排布和添加删除动画效果。 在上一篇，有说过，RecyclerView的子View的排布方式有： 1. LinearLayoutManager 线
深入理解Android RecyclerView
weixin_42487687的博客
04-21 965
RecyclerView作为Android开发中重要的UI组件，具有高效、灵活和可定制的特点。通过深入理解其工作原理、核心组件和使用场景，并结合优化策略，开发者可以创建出高效且美观的列表和网格视图，提升应用的性能和用户体验。在实际开发中，建议多参考官方文档和社区资源，以获取更多的实现方法和最佳实践。
Android开发之最新Recyclerview控件的使用详解（一）
qq_36430886的博客
03-09 2201
本篇博文主要给大家分享关于RecyclerView控件的使用及通过继承RecyclerView来实现滑动时加载图片的优化方案，也同样能解决防止图片乱序的问题，之前有在网上有看到大神对Android中ListView异步加载图片乱序问题进行过分析，并深入剖析原理后分别给出了3种对应的解决方案：一 、使用findViewWithTag。二、使用弱引用关联。三、使用ImageLoad框架进行处理。
RecyclerView超详总结
m0_74225871的博客
06-05 1330
实现各种复杂的布局效果和动画效果，适用于各种需要列表或网格显示的Android应用，无论是简单的联系人列表还是复杂的瀑布流布局，甚至是在列表项中嵌入复杂交互，RecyclerView都能胜任。
Android RecyclerView原理语法和用法
micro9981的专栏
06-20 974
是 Android 中用于显示大量数据的高级视图组件。它是 的改进版，具有更高的性能和灵活性。以下是关于 的详细介绍，包括其原理、语法、优缺点和使用方法。 的核心原理是通过视图复用来提高性能。当用户滚动列表时， 只会创建和绑定当前可见的项，而不是为每个数据项都创建一个新的视图。这是通过 ViewHolder 模式和 Adapter 来实现的。使用 的基本步骤包括： 优缺点 优点 性能优越: 通过视图复用和 ViewHolder 模式， 能够有效减少内存使用和提高滚动性能。 灵活性高: 支持不
Android RecyclerView 使用完全解析 体验艺术般的控件
weixin_30390075的博客
04-16 2573
转载请标明出处： http://blog.csdn.net/lmj623565791/article/details/45059587； 本文出自:【张鸿洋的博客】 概述 RecyclerView出现已经有一段时间了，相信大家肯定不陌生了，大家可以通过导入support-v7对其进行使用。 据官方的介绍，该控件用于在有限的窗口中展示大量数据集，其实...
Android RecyclerView详解：从入门到精通
"本文详细介绍了Android平台上的滚动控件RecyclerView，阐述了其相对于ListView的优势，并逐步解析了使用RecyclerView的七个关键步骤，包括添加依赖库、布局配置、创建适配器、定义数据源、找到控件、设置布局管理器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值