Android自定义ViewPager实现无限循环效果的完整指南

public class loopviewpager extends viewpager {
    public loopviewpager(context context) {
        super(context);
        // 初始化代码
    }

    public loopviewpager(context context, attributeset attrs) {
        super(context, attrs);
        // 初始化代码
    }
    // 在这里重写其他方法，如onmeasure、ontouchevent等
}

@override
protected void onpagescrolled(int position, float positionoffset, int positionoffsetpixels) {
    // 重写的逻辑来处理页面滚动
}

@override
protected void onpageselected(int position) {
    // 重写的逻辑来处理页面选中
}

@override
public void onpagescrollstatechanged(int state) {
    // 重写的逻辑来处理页面滚动状态改变
}

@override
public void onpagescrolled(int position, float positionoffset, int positionoffsetpixels) {
    super.onpagescrolled(position, positionoffset, positionoffsetpixels);

    // 获取页面总数
    int totalcount = adapter.getcount();
    if (position == 0 && positionoffset > 0.5f) {
        setcurrentitem(totalcount - 2, false);
    } else if (position == totalcount - 1 && positionoffset < 0.5f) {
        setcurrentitem(1, false);
    }
}

@override
public void onpageselected(int position) {
    super.onpageselected(position);
    // 当页面选中时进行的操作，如更新ui
    updateuiforpageselected(position);
    // 在无限循环中处理边界情况
    if (isfirstpage(position) || islastpage(position)) {
        updateindicatorforboundaryposition(position);
    }
}

public class looppageradapter extends pageradapter {

    private list<page>(pages) = new arraylist<>();

    @override
    public int getcount() {
        // 不仅返回实际的数据项数量，还返回虚拟的重复项。
        // 这样viewpager就不会显示空页面。
        return pages.size() * 2 - 2;
    }

    @override
    public boolean isviewfromobject(view view, object object) {
        return view == object;
    }

    @override
    public object instantiateitem(viewgroup container, int position) {
        int virtualpos = position % pages.size();
        page page = pages.get(virtualpos);
        // ... 初始化页面视图 ...
        container.addview(page.getview());
        return page.getview();
    }

    @override
    public void destroyitem(viewgroup container, int position, object object) {
        container.removeview((view) object);
    }
}

private sparsearray<view> cachedviews = new sparsearray<>();

@override
public object instantiateitem(viewgroup container, int position) {
    // 判断是否可以重用缓存中的视图
    view cachedview = cachedviews.get(position);
    if (cachedview != null) {
        container.addview(cachedview);
        return cachedview;
    }

    int virtualpos = position % pages.size();
    page page = pages.get(virtualpos);
    // ... 创建页面视图 ...
    container.addview(page.getview());
    return page.getview();
}

@override
public void destroyitem(viewgroup container, int position, object object) {
    container.removeview((view) object);
    // 将移除的视图缓存起来，以便之后重用
    cachedviews.put(position, (view) object);
}

// 假设我们使用的是loopviewpager类
loopviewpager viewpager = findviewbyid(r.id.loop_view_pager);

// 设置初始偏移量的方法
viewpager.setinitialoffset(100); // 假设初始偏移量为100px

// 在loopviewpager类中的setinitialoffset方法实现
public void setinitialoffset(int offset){
    // 保存初始偏移量
    this.initialoffset = offset;
    // 重新设置当前选中的页面位置，需要考虑偏移量的影响
    setcurrentitem(currentitem + (initialoffset / width), false);
}

// 假设我们已知页面总数为pagecount
int pagecount = adapter.getcount();

// 设置初始位置为中间页面
int middleposition = pagecount / 2;
viewpager.setcurrentitem(middleposition, false);

// 在loopviewpager类中的setcurrentitem方法实现
@override
public void setcurrentitem(int item, boolean smoothscroll) {
    // 如果item不等于当前item，或者item等于中间位置的页面
    if (item != this.currentitem || item == middleposition) {
        this.currentitem = item;
        // 重绘页面，确保偏移量正确设置
        adapter.notifydatasetchanged();
        // 触发页面切换的回调方法
        onpagechangelistener.onpageselected(item);
        // 如果设置了平滑滚动
        if (smoothscroll) {
            // 这里可以调用viewpager的startscroll方法来实现平滑过渡
            // 代码略...
        } else {
            // 如果不平滑滚动，则直接更新页面索引
            this.scrolltocurrentitem();
        }
    }
}

public class looppageradapter extends pageradapter {
    private list<yourdatatype> items; // 实际数据列表
    private int positiveoffset; // 正向偏移量
    private int negativeoffset; // 负向偏移量

    public looppageradapter(list<yourdatatype> items) {
        this.items = items;
        // 正向和负向偏移量设置为数据列表的长度
        this.positiveoffset = this.items.size();
        this.negativeoffset = -this.items.size();
    }

    @override
    public int getcount() {
        // 返回的数据项总数是实际项数的三倍，以实现无缝循环
        return this.items.size() * 3;
    }

    @override
    public boolean isviewfromobject(@nonnull view view, @nonnull object object) {
        return view == object;
    }

    @nonnull
    @override
    public object instantiateitem(@nonnull viewgroup container, int position) {
        int actualposition = position % items.size();
        // 这里我们使用layoutinflater来实例化一个视图，具体的实现依赖于item的布局和数据绑定
        view itemview = layoutinflater.from(container.getcontext()).inflate(r.layout.item_layout, container, false);
        // 将数据绑定到视图
        binddata(itemview, items.get(actualposition));
        container.addview(itemview);
        return itemview;
    }

    @override
    public void destroyitem(@nonnull viewgroup container, int position, @nonnull object object) {
        container.removeview((view) object);
    }

    private void binddata(view itemview, yourdatatype data) {
        // 数据绑定逻辑...
    }
}

// 示例代码：处理配置更改时保持当前页面状态
public class loopviewpager extends viewpager {
    private int currentpage;

    public loopviewpager(context context) {
        super(context);
    }

    @override
    protected void onrestoreinstancestate(parcelable state) {
        if (state instanceof savedstate) {
            currentpage = ((savedstate) state).currentpage;
            super.onrestoreinstancestate(((savedstate) state).getsuperstate());
        } else {
            super.onrestoreinstancestate(state);
            currentpage = -1;
        }
    }

    @override
    protected parcelable onsaveinstancestate() {
        parcelable superstate = super.onsaveinstancestate();
        if (currentpage == -1) {
            currentpage = getcurrentitem();
        }
        savedstate ss = new savedstate(superstate);
        ss.currentpage = currentpage;
        return ss;
    }

    static class savedstate extends basesavedstate {
        int currentpage;

        public savedstate(parcelable superstate) {
            super(superstate);
        }

        private savedstate(parcel in) {
            super(in);
            currentpage = in.readint();
        }

        @override
        public void writetoparcel(parcel dest, int flags) {
            super.writetoparcel(dest, flags);
            dest.writeint(currentpage);
        }

        public static final parcelable.creator<savedstate> creator = new parcelable.creator<savedstate>() {
            @override
            public savedstate createfromparcel(parcel in) {
                return new savedstate(in);
            }

            @override
            public savedstate[] newarray(int size) {
                return new savedstate[size];
            }
        };
    }
}

// 示例代码：优化快速滑动时的页面切换动画
public class customviewpager extends viewpager {
    // ...
    private scroller customscroller;

    public customviewpager(context context, attributeset attrs) {
        super(context, attrs);
        initcustomscroller();
    }

    private void initcustomscroller() {
        setscroller(new scroller(getcontext(), new linearinterpolator()));
    }

    @override
    public void computescroll() {
        if (scroller.computescrolloffset()) {
            setcurrentitem(scroller.getcurrx() / getwidth(), false);
        }
        super.computescroll();
    }
}