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();
    }
}