如何在Android中使用固定数量的项目创建水平ListView？

Question

我在互联网上搜索了几个小时，但没有找到任何示例或文档说明如何创建具有固定数量元素的水平列表视图。

基本上，我想说，没有考虑到scree的大小，屏幕上显示的n个元素（总元素数量）中的3个元素。元素的大小可以与屏幕成比例，但可见元素的数量应该是相同的，固定的。看到图像。

我该怎么做？任何提示表示赞赏！谢谢！

Answer 1

您可以使用TwoWayWiew第三方库（我真的不推荐这种解决方案），或者如果你想避免使用LIB为此，只需使用RecyclerView，并且可以设置水平参数去布局管理器。

Answer 2

我不会为此使用ListView，而是使用RecyclerView。 RecyclerView的性能更好，我真的觉得它们更容易使用。您可以通过LayoutManager为您的RecyclerView允许水平滚动。

Answer 3

使用线性布局与其取向相对布局

Answer 4

可以使用以下代码用于水平列表视图下设定为水平的。

import java.util.LinkedList; 
import java.util.Queue; 

import android.content.Context; 
import android.database.DataSetObserver; 
import android.graphics.Rect; 
import android.util.AttributeSet; 
import android.view.GestureDetector; 
import android.view.GestureDetector.OnGestureListener; 
import android.view.MotionEvent; 
import android.view.View; 
import android.widget.AdapterView; 
import android.widget.ListAdapter; 
import android.widget.Scroller; 

public class HorizontalListView extends AdapterView<ListAdapter> { 

    public boolean mAlwaysOverrideTouch = true; 
    protected ListAdapter mAdapter; 
    private int mLeftViewIndex = -1; 
    private int mRightViewIndex = 0; 
    protected int mCurrentX; 
    protected int mNextX; 
    private int mMaxX = Integer.MAX_VALUE; 
    private int mDisplayOffset = 0; 
    protected Scroller mScroller; 
    private GestureDetector mGesture; 
    private Queue<View> mRemovedViewQueue = new LinkedList<View>(); 
    private OnItemSelectedListener mOnItemSelected; 
    private OnItemClickListener mOnItemClicked; 
    private OnItemLongClickListener mOnItemLongClicked; 
    private boolean mDataChanged = false; 


    public HorizontalListView(Context context, AttributeSet attrs) { 
     super(context, attrs); 
     initView(); 
    } 

    private synchronized void initView() { 
     mLeftViewIndex = -1; 
     mRightViewIndex = 0; 
     mDisplayOffset = 0; 
     mCurrentX = 0; 
     mNextX = 0; 
     mMaxX = Integer.MAX_VALUE; 
     mScroller = new Scroller(getContext()); 
     mGesture = new GestureDetector(getContext(), mOnGesture); 
    } 

    @Override 
    public void setOnItemSelectedListener(AdapterView.OnItemSelectedListener listener) { 
     mOnItemSelected = listener; 
    } 

    @Override 
    public void setOnItemClickListener(AdapterView.OnItemClickListener listener){ 
     mOnItemClicked = listener; 
    } 

    @Override 
    public void setOnItemLongClickListener(AdapterView.OnItemLongClickListener listener) { 
     mOnItemLongClicked = listener; 
    } 

    private DataSetObserver mDataObserver = new DataSetObserver() { 

     @Override 
     public void onChanged() { 
      synchronized(HorizontalListView.this){ 
       mDataChanged = true; 
      } 
      invalidate(); 
      requestLayout(); 
     } 

     @Override 
     public void onInvalidated() { 
      reset(); 
      invalidate(); 
      requestLayout(); 
     } 

    }; 

    @Override 
    public ListAdapter getAdapter() { 
     return mAdapter; 
    } 

    @Override 
    public View getSelectedView() { 
     //TODO: implement 
     return null; 
    } 

    @Override 
    public void setAdapter(ListAdapter adapter) { 
     if(mAdapter != null) { 
      mAdapter.unregisterDataSetObserver(mDataObserver); 
     } 
     mAdapter = adapter; 
     mAdapter.registerDataSetObserver(mDataObserver); 
     reset(); 
    } 

    private synchronized void reset(){ 
     initView(); 
     removeAllViewsInLayout(); 
     requestLayout(); 
    } 

    @Override 
    public void setSelection(int position) { 
     //TODO: implement 
    } 

    private void addAndMeasureChild(final View child, int viewPos) { 
     LayoutParams params = child.getLayoutParams(); 
     if(params == null) { 
      params = new LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT); 
     } 

     addViewInLayout(child, viewPos, params, true); 
     child.measure(MeasureSpec.makeMeasureSpec(getWidth(), MeasureSpec.AT_MOST), 
       MeasureSpec.makeMeasureSpec(getHeight(), MeasureSpec.AT_MOST)); 
    } 



    @Override 
    protected synchronized void onLayout(boolean changed, int left, int top, int right, int bottom) { 
     super.onLayout(changed, left, top, right, bottom); 

     if(mAdapter == null){ 
      return; 
     } 

     if(mDataChanged){ 
      int oldCurrentX = mCurrentX; 
      initView(); 
      removeAllViewsInLayout(); 
      mNextX = oldCurrentX; 
      mDataChanged = false; 
     } 

     if(mScroller.computeScrollOffset()){ 
      int scrollx = mScroller.getCurrX(); 
      mNextX = scrollx; 
     } 

     if(mNextX <= 0){ 
      mNextX = 0; 
      mScroller.forceFinished(true); 
     } 
     if(mNextX >= mMaxX) { 
      mNextX = mMaxX; 
      mScroller.forceFinished(true); 
     } 

     int dx = mCurrentX - mNextX; 

     removeNonVisibleItems(dx); 
     fillList(dx); 
     positionItems(dx); 

     mCurrentX = mNextX; 

     if(!mScroller.isFinished()){ 
      post(new Runnable(){ 
       @Override 
       public void run() { 
        requestLayout(); 
       } 
      }); 

     } 
    } 

    private void fillList(final int dx) { 
     int edge = 0; 
     View child = getChildAt(getChildCount()-1); 
     if(child != null) { 
      edge = child.getRight(); 
     } 
     fillListRight(edge, dx); 

     edge = 0; 
     child = getChildAt(0); 
     if(child != null) { 
      edge = child.getLeft(); 
     } 
     fillListLeft(edge, dx); 


    } 

    private void fillListRight(int rightEdge, final int dx) { 
     while(rightEdge + dx < getWidth() && mRightViewIndex < mAdapter.getCount()) { 

      View child = mAdapter.getView(mRightViewIndex, mRemovedViewQueue.poll(), this); 
      addAndMeasureChild(child, -1); 
      rightEdge += child.getMeasuredWidth(); 

      if(mRightViewIndex == mAdapter.getCount()-1) { 
       mMaxX = mCurrentX + rightEdge - getWidth(); 
      } 

      if (mMaxX < 0) { 
       mMaxX = 0; 
      } 
      mRightViewIndex++; 
     } 

    } 

    private void fillListLeft(int leftEdge, final int dx) { 
     while(leftEdge + dx > 0 && mLeftViewIndex >= 0) { 
      View child = mAdapter.getView(mLeftViewIndex, mRemovedViewQueue.poll(), this); 
      addAndMeasureChild(child, 0); 
      leftEdge -= child.getMeasuredWidth(); 
      mLeftViewIndex--; 
      mDisplayOffset -= child.getMeasuredWidth(); 
     } 
    } 

    private void removeNonVisibleItems(final int dx) { 
     View child = getChildAt(0); 
     while(child != null && child.getRight() + dx <= 0) { 
      mDisplayOffset += child.getMeasuredWidth(); 
      mRemovedViewQueue.offer(child); 
      removeViewInLayout(child); 
      mLeftViewIndex++; 
      child = getChildAt(0); 

     } 

     child = getChildAt(getChildCount()-1); 
     while(child != null && child.getLeft() + dx >= getWidth()) { 
      mRemovedViewQueue.offer(child); 
      removeViewInLayout(child); 
      mRightViewIndex--; 
      child = getChildAt(getChildCount()-1); 
     } 
    } 

    private void positionItems(final int dx) { 
     if(getChildCount() > 0){ 
      mDisplayOffset += dx; 
      int left = mDisplayOffset; 
      for(int i=0;i<getChildCount();i++){ 
       View child = getChildAt(i); 
       int childWidth = child.getMeasuredWidth(); 
       child.layout(left, 0, left + childWidth, child.getMeasuredHeight()); 
       left += childWidth + child.getPaddingRight(); 
      } 
     } 
    } 

    public synchronized void scrollTo(int x) { 
     mScroller.startScroll(mNextX, 0, x - mNextX, 0); 
     requestLayout(); 
    } 

    @Override 
    public boolean dispatchTouchEvent(MotionEvent ev) { 
     boolean handled = super.dispatchTouchEvent(ev); 
     handled |= mGesture.onTouchEvent(ev); 
     return handled; 
    } 

    protected boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, 
       float velocityY) { 
     synchronized(HorizontalListView.this){ 
      mScroller.fling(mNextX, 0, (int)-velocityX, 0, 0, mMaxX, 0, 0); 
     } 
     requestLayout(); 

     return true; 
    } 

    protected boolean onDown(MotionEvent e) { 
     mScroller.forceFinished(true); 
     return true; 
    } 

    private OnGestureListener mOnGesture = new GestureDetector.SimpleOnGestureListener() { 

     @Override 
     public boolean onDown(MotionEvent e) { 
      return HorizontalListView.this.onDown(e); 
     } 

     @Override 
     public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, 
       float velocityY) { 
      return HorizontalListView.this.onFling(e1, e2, velocityX, velocityY); 
     } 

     @Override 
     public boolean onScroll(MotionEvent e1, MotionEvent e2, 
       float distanceX, float distanceY) { 

      synchronized(HorizontalListView.this){ 
       mNextX += (int)distanceX; 
      } 
      requestLayout(); 

      return true; 
     } 

     @Override 
     public boolean onSingleTapConfirmed(MotionEvent e) { 
      for(int i=0;i<getChildCount();i++){ 
       View child = getChildAt(i); 
       if (isEventWithinView(e, child)) { 
        if(mOnItemClicked != null){ 
         mOnItemClicked.onItemClick(HorizontalListView.this, child, mLeftViewIndex + 1 + i, mAdapter.getItemId(mLeftViewIndex + 1 + i)); 
        } 
        if(mOnItemSelected != null){ 
         mOnItemSelected.onItemSelected(HorizontalListView.this, child, mLeftViewIndex + 1 + i, mAdapter.getItemId(mLeftViewIndex + 1 + i)); 
        } 
        break; 
       } 

      } 
      return true; 
     } 

     @Override 
     public void onLongPress(MotionEvent e) { 
      int childCount = getChildCount(); 
      for (int i = 0; i < childCount; i++) { 
       View child = getChildAt(i); 
       if (isEventWithinView(e, child)) { 
        if (mOnItemLongClicked != null) { 
         mOnItemLongClicked.onItemLongClick(HorizontalListView.this, child, mLeftViewIndex + 1 + i, mAdapter.getItemId(mLeftViewIndex + 1 + i)); 
        } 
        break; 
       } 

      } 
     } 

     private boolean isEventWithinView(MotionEvent e, View child) { 
      Rect viewRect = new Rect(); 
      int[] childPosition = new int[2]; 
      child.getLocationOnScreen(childPosition); 
      int left = childPosition[0]; 
      int right = left + child.getWidth(); 
      int top = childPosition[1]; 
      int bottom = top + child.getHeight(); 
      viewRect.set(left, top, right, bottom); 
      return viewRect.contains((int) e.getRawX(), (int) e.getRawY()); 
     } 
    }; 
} 

欲了解更多信息，请查看此链接。

http://sandyandroidtutorials.blogspot.in/2013/06/horizontal-listview-tutorial.html

Answer 5

如果不介意的3项水平滚动，你可以使用与每个View含三贵元素有 android:layout_width="0dp"的LinearLayout（水平方向）和 andriod:layout_weight="1" 为ViewPager均匀分布。当你“滚动”时，你只需要将下一个“页面”动画到屏幕中，并引入下3个元素。

这可能不是最优雅的解决方案，但我认为它会以您想要的方式行事。