Android自定义左右滑动柱状图

最新推荐文章于 2024-08-08 04:20:03 发布
最新推荐文章于 2024-08-08 04:20:03 发布
阅读量512 收藏 3
点赞数
分类专栏： android 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/carter_yu/article/details/104039812
版权

参考：https://www.jianshu.com/p/1595ce6aa3a7

技术点记录

/**
* 是否可以滑动
*
* @param direction 方位，正数：向左滑动；负数：从左向右滑动；
* @return 是否可以
*/
@Override
public boolean canScrollHorizontally(int direction) { }

getMeasuredWidth()获取的是view原始的大小，是view在XML文件中配置或者是代码中设置的大小，即可以看到的大小。
getWidth（）获取的是这个view最终显示的大小，即view实际大小。

getScrollX返回的是当前视图左上角坐标与视图初始位置x轴方向上的距离，为正数。

在这里插入图片描述

public class HistogramItemBean {

    private float value;
    private String suffix;

    public String getSuffix() {
        return suffix;
    }

    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }

    public float getValue() {
        return value;
    }

    public void setValue(float value) {
        this.value = value;
    }
}

public class HistogramListBean {

    private String groupName;
    private List<HistogramItemBean> list;

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

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

    public String getGroupName() {
        return groupName;
    }

    public void setGroupName(String groupName) {
        this.groupName = groupName;
    }
}

/**
 * 柱状图
 */
public class HistogramView extends View {

    private int width;
    private int height;

    //直方图视图总宽度
    private int histogramContentWidth;
    //坐标轴线宽度
    private int coordinateAxisWidth;

    //组名字体大小
    private int groupNameTextSize;
    //各组之间间距
    private int groupInterval;

    //组内子直方图间距
    private int histogramInterval;
    //直方图值文字大小
    private int histogramValueTextSize;
    //图标数值小数点位数
    private int histogramValueDecimalCount;
    //直方图宽度
    private int histogramWidth;
    //直方图最大高度
    private int maxHistogramHeight;
    //图标距离顶部距离
    private int chartPaddingTop;
    private int histogramPaddingStart;
    private int histogramPaddingEnd;

    //各组名称到X轴的距离
    private int distanceFromGroupNameToAxis;
    //直方图上方数值到直方图的距离
    private int distanceFromValueToHistogram;

    //轴线画笔
    private Paint coordinateAxisPaint;
    //组名画笔
    private Paint groupNamePaint;
    //直方图画笔
    private Paint histogramPaint;
    //直方图数值画笔
    private Paint histogramValuePaint;
    // 轴线颜色
    int coordinateAxisColor;
    // 组名字体颜色
    int groupNameTextColor;
    // 直方图数值文本颜色
    int histogramValueTextColor;

    //字体指标
    private Paint.FontMetrics groupNameFontMetrics;
    private Paint.FontMetrics histogramValueFontMetrics;

    //直方图绘制区域
    private Rect histogramPaintRect;
    //每组直方图的shade和color，即每组有几个直方图
    private SparseArray<int[]> histogramShaderColorArray;

    //滚动轴
    private Scroller scroller;
    //最小移动速度
    private int minimumVelocity;
    //最大移动速度
    private int maximumVelocity;
    //滑动速度跟踪器
    private VelocityTracker velocityTracker;
    //上次X轴位置
    private float lastX;

    //图标数据列表
    private List<HistogramListBean> dataList;
    private SparseArray<Float> childMaxValueArray;

    public HistogramView(Context context) {
        this(context, null);
    }

    public HistogramView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public HistogramView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(attrs);
    }

    private void init(AttributeSet attributeSet) {
        //硬件加速
        setLayerType(View.LAYER_TYPE_HARDWARE, null);
        @SuppressLint("Recycle")
        TypedArray typedArray = getContext().obtainStyledAttributes(attributeSet, R.styleable.HistogramView);
        //轴线宽度和颜色
        coordinateAxisWidth = typedArray.getDimensionPixelSize(R.styleable.HistogramView_coordinateAxisWidth, DisplayUtil.dp2px(2));
        coordinateAxisColor = typedArray.getColor(R.styleable.HistogramView_coordinateAxisColor, Color.parseColor("#434343"));
        //组名大小和颜色、组名距离轴线距离、组间距、组内间距
        groupNameTextSize = typedArray.getDimensionPixelSize(R.styleable.HistogramView_groupNameTextSize, DisplayUtil.dp2px(15));
        groupNameTextColor = typedArray.getColor(R.styleable.HistogramView_groupNameTextColor, Color.parseColor("#CC202332"));
        distanceFromGroupNameToAxis = typedArray.getDimensionPixelSize(R.styleable.HistogramView_distanceFormGroupNameToAxis, DisplayUtil.dp2px(15));
        groupInterval = typedArray.getDimensionPixelSize(R.styleable.HistogramView_groupInterval, DisplayUtil.dp2px(30));
        histogramInterval = typedArray.getDimensionPixelSize(R.styleable.HistogramView_histogramInterval, DisplayUtil.dp2px(10));
        //直方图数值大小和颜色、小数点位数、数值距离直方图距离
        histogramValueTextSize = typedArray.getDimensionPixelSize(R.styleable.HistogramView_histogramValueTextSize, DisplayUtil.dp2px(12));
        histogramValueTextColor = typedArray.getColor(R.styleable.HistogramView_histogramValueTextColor, Color.parseColor("#CC202332"));
        histogramValueDecimalCount = typedArray.getInt(R.styleable.HistogramView_histogramValueDecimalCount, 0);
        distanceFromValueToHistogram = typedArray.getDimensionPixelSize(R.styleable.HistogramView_distanceFromValueToHistogram, DisplayUtil.dp2px(10));
        //直方图宽度、距离顶部、距离开始、距离结束
        histogramWidth = typedArray.getDimensionPixelSize(R.styleable.HistogramView_histogramHistogramWidth, DisplayUtil.dp2px(20));
        chartPaddingTop = typedArray.getDimensionPixelSize(R.styleable.HistogramView_chartPaddingTop, DisplayUtil.dp2px(10));
        histogramPaddingStart = typedArray.getDimensionPixelSize(R.styleable.HistogramView_histogramPaddingStart, DisplayUtil.dp2px(15));
        histogramPaddingEnd = typedArray.getDimensionPixelSize(R.styleable.HistogramView_histogramPaddingEnd, DisplayUtil.dp2px(15));
        typedArray.recycle();

        coordinateAxisPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        coordinateAxisPaint.setStyle(Paint.Style.FILL);
        coordinateAxisPaint.setStrokeWidth(coordinateAxisWidth);
        coordinateAxisPaint.setColor(coordinateAxisColor);

        groupNamePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        groupNamePaint.setTextSize(groupNameTextSize);
        groupNamePaint.setColor(groupNameTextColor);
        groupNameFontMetrics = groupNamePaint.getFontMetrics();

        histogramValuePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        histogramValuePaint.setTextSize(histogramValueTextSize);
        histogramValuePaint.setColor(histogramValueTextColor);
        histogramValueFontMetrics = histogramValuePaint.getFontMetrics();

        histogramPaintRect = new Rect();
        histogramPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        scroller = new Scroller(getContext(), new LinearInterpolator());
        ViewConfiguration configuration = ViewConfiguration.get(getContext());
        minimumVelocity = configuration.getScaledMinimumFlingVelocity();
        maximumVelocity = configuration.getScaledMaximumFlingVelocity();
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        width = getMeasuredWidth();
        height = getMeasuredHeight();
        maxHistogramHeight = height - groupNameTextSize - distanceFromGroupNameToAxis - coordinateAxisWidth - distanceFromValueToHistogram - histogramValueTextSize - chartPaddingTop;
    }

    /**
     * 是否可以滑动
     *
     * @param direction 方位，正数：向左滑动；负数：向右滑动；
     * @return 是否可以
     */
    @Override
    public boolean canScrollHorizontally(int direction) {
        if (direction > 0) {
            return (histogramContentWidth - getScrollX() - width + histogramPaddingStart + histogramPaddingEnd) > 0;
        } else {
            return getScrollX() > 0;
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        initVelocityTracker();
        velocityTracker.addMovement(event);
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                //终止动画
                if (!scroller.isFinished()) {
                    scroller.abortAnimation();
                }
                lastX = event.getX();
                return true;
            case MotionEvent.ACTION_MOVE:
                //X轴增量
                int deltaX = (int) (event.getX() - lastX);
                lastX = event.getX();
                if (deltaX > 0 && canScrollHorizontally(-1)) {
                    scrollBy(-Math.min(getMaxCanScrollX(-1), deltaX), 0);
                } else if (deltaX < 0 && canScrollHorizontally(1)) {
                    scrollBy(Math.min(getMaxCanScrollX(1), -deltaX), 0);
                }
                break;
            case MotionEvent.ACTION_UP:
                velocityTracker.computeCurrentVelocity(1000, maximumVelocity);
                int velocityX = (int) velocityTracker.getXVelocity();
                fling(velocityX);
                recycleVelocityTracker();
                break;
            case MotionEvent.ACTION_CANCEL:
                recycleVelocityTracker();
                break;
        }
        return super.onTouchEvent(event);
    }

    /**
     * 初始化滑动速度跟踪器
     */
    private void initVelocityTracker() {
        if (velocityTracker == null) {
            velocityTracker = VelocityTracker.obtain();
        }
    }

    /**
     * 回收滑动速度跟踪器
     */
    private void recycleVelocityTracker() {
        if (velocityTracker != null) {
            velocityTracker.recycle();
            velocityTracker = null;
        }
    }

    /**
     * 惯性滑动
     *
     * @param velocityX 横轴滑动速度
     */
    private void fling(int velocityX) {
        if (Math.abs(velocityX) > minimumVelocity) {
            if (Math.abs(velocityX) > maximumVelocity) {
                velocityX = maximumVelocity * velocityX / Math.abs(velocityX);
            }
            scroller.fling(getScrollX(), getScrollY(), -velocityX, 0, 0, histogramContentWidth + histogramPaddingStart - width, 0, 0);
        }
    }

    /**
     * 最大可滑动距离
     *
     * @param direction 滑动方向，正数：由又向左滑动；
     * @return 可滑动距离
     */
    private int getMaxCanScrollX(int direction) {
        if (direction > 0) {
            int size = histogramContentWidth - getScrollX() - width + histogramPaddingStart + histogramPaddingEnd;
            return size > 0 ? size : 0;
        } else if (direction < 0) {
            return getScrollX();
        } else {
            return 0;
        }
    }

    /**
     * 计算拖动位移量
     */
    @Override
    public void computeScroll() {
        if (scroller.computeScrollOffset()) {
            scrollTo(scroller.getCurrX(), 0);
        }
    }

    /**
     * 设置直方图数据
     *
     * @param dataList 直方图数据
     */
    public void setDataList(List<HistogramListBean> dataList) {
        this.dataList = dataList;
        if (childMaxValueArray == null) {
            childMaxValueArray = new SparseArray<>();
        } else {
            childMaxValueArray.clear();
        }
        histogramContentWidth = 0;
        for (HistogramListBean listBean : dataList) {
            List<HistogramItemBean> itemBeans = listBean.getList();
            if (itemBeans != null && itemBeans.size() > 0) {
                for (int i = 0; i < itemBeans.size(); i++) {
                    histogramContentWidth += (histogramWidth + histogramInterval);
                    HistogramItemBean itemBean = itemBeans.get(i);
                    Float childMaxValue = childMaxValueArray.get(i);
                    if (childMaxValue == null || childMaxValue < itemBean.getValue()) {
                        childMaxValueArray.put(i, itemBean.getValue());
                    }
                }
                histogramContentWidth += (groupInterval - histogramInterval);
            }
        }
        histogramContentWidth += (-groupInterval);
        postInvalidate();
    }

    /**
     * 设置直方图颜色
     *
     * @param colors 颜色
     */
    public void setHistogramColor(int[]... colors) {
        if (colors != null && colors.length > 0) {
            if (histogramShaderColorArray == null) {
                histogramShaderColorArray = new SparseArray<>();
            } else {
                histogramShaderColorArray.clear();
            }
            for (int i = 0; i < colors.length; i++) {
                histogramShaderColorArray.put(i, colors[i]);
            }
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        if (width == 0 || height == 0) {
            return;
        }
        int scrollX = getScrollX();
        int axisBottom = height - groupNameTextSize - distanceFromGroupNameToAxis - coordinateAxisWidth / 2;
        canvas.drawLine(coordinateAxisWidth / 2 + scrollX, 0, coordinateAxisWidth / 2 + scrollX, axisBottom, coordinateAxisPaint);
        canvas.drawLine(scrollX, axisBottom, width + scrollX, axisBottom, coordinateAxisPaint);
        if (dataList != null && dataList.size() > 0) {
            int xAxisOffset = histogramPaddingStart;
            for (HistogramListBean listBean : dataList) {
                List<HistogramItemBean> itemBeanList = listBean.getList();
                if (itemBeanList != null && itemBeanList.size() > 0) {
                    int groupWidth = 0;
                    for (int i = 0; i < itemBeanList.size(); i++) {
                        HistogramItemBean itemBean = itemBeanList.get(i);
                        histogramPaintRect.left = xAxisOffset;
                        histogramPaintRect.right = histogramPaintRect.left + histogramWidth;
                        int childHistogramHeight;
                        if (itemBean.getValue() <= 0 || childMaxValueArray.get(i) <= 0) {
                            childHistogramHeight = 0;
                        } else {
                            childHistogramHeight = (int) (itemBean.getValue() / childMaxValueArray.get(i) * maxHistogramHeight);
                        }
                        histogramPaintRect.top = height - childHistogramHeight - coordinateAxisWidth - distanceFromGroupNameToAxis - groupNameTextSize;
                        histogramPaintRect.bottom = histogramPaintRect.top + childHistogramHeight;
                        int[] histogramShaderColor = histogramShaderColorArray.get(i);
                        LinearGradient gradient = null;
                        if (histogramShaderColor != null && histogramShaderColor.length > 0) {
                            gradient = getHistogramShader(histogramPaintRect.left, chartPaddingTop + distanceFromValueToHistogram + histogramValueTextSize,
                                    histogramPaintRect.right, histogramPaintRect.bottom, histogramShaderColor);
                        }
                        histogramPaint.setShader(gradient);
                        canvas.drawRect(histogramPaintRect, histogramPaint);
                        //直方图数值
                        String childHistogramValue = StringUtil.NumericScaleByFloor(String.valueOf(itemBean.getValue()), histogramValueDecimalCount);
                        float valueX = xAxisOffset + (histogramWidth - histogramValuePaint.measureText(childHistogramValue)) / 2;
                        float valueY = histogramPaintRect.top - distanceFromGroupNameToAxis + (histogramValueFontMetrics.bottom) / 2;
                        canvas.drawText(childHistogramValue, valueX, valueY, histogramValuePaint);

                        int delta = (i < itemBeanList.size() - 1) ? (histogramWidth + histogramInterval) : histogramWidth;
                        groupWidth += delta;
                        xAxisOffset += (((itemBeanList.size() - 1) == i) ? (delta + groupWidth) : delta);
                    }
                    //组名
                    String groupName = listBean.getGroupName();
                    float groupNameWidth = groupNamePaint.measureText(groupName);
                    float groupNameX = xAxisOffset - groupWidth - groupInterval + (groupWidth - groupNameWidth) / 2;
                    float groupNameY = height - groupNameFontMetrics.bottom / 2;
                    canvas.drawText(groupName, groupNameX, groupNameY, groupNamePaint);
                }
            }
        }
    }

    /**
     * 线性渐变
     *
     * @param x0     起点x轴
     * @param y0     起点y轴
     * @param x1     终点x轴
     * @param y1     终点y轴
     * @param colors 渐变色数组
     * @return LinearGradient
     */
    private LinearGradient getHistogramShader(float x0, float y0, float x1, float y1, int[] colors) {
        return new LinearGradient(x0, y0, x1, y1, colors, null, Shader.TileMode.CLAMP);
    }

}


<FrameLayout 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"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    tools:context="com.thinta.modules.basicDataRead.AddressAndNo.ui.Fragment2">

    <com.thinta.views.HistogramView
        android:id="@+id/histogram"
        android:layout_marginTop="50dp"
        android:layout_width="match_parent"
        android:layout_height="280dp"
        android:layout_marginEnd="20dp"
        android:layout_marginStart="20dp"
        app:chartPaddingTop="15dp"
        app:coordinateAxisColor="#FF727884"
        app:coordinateAxisWidth="1dp"
        app:distanceFormGroupNameToAxis="10dp"
        app:distanceFromValueToHistogram="10dp"
        app:groupInterval="30dp"
        app:groupNameTextColor="#FF727884"
        app:groupNameTextSize="13sp"
        app:histogramHistogramWidth="20dp"
        app:histogramInterval="15dp"
        app:histogramPaddingEnd="15dp"
        app:histogramPaddingStart="15dp"
        app:histogramValueDecimalCount="ZERO"
        app:histogramValueTextColor="#FF727884"
        app:histogramValueTextSize="10sp" />

</FrameLayout>


Random random = new Random();
        int groupSize = random.nextInt(5) + 10;
        List<HistogramListBean> groupDataList = new ArrayList<>();
        // 生成测试数据 
        for (int i = 0; i < groupSize; i++) {
            List<HistogramItemBean> childDataList = new ArrayList<>();
            HistogramListBean groupData = new HistogramListBean();
            groupData.setGroupName("第" + (i + 1) + "组");
            HistogramItemBean childData1 = new HistogramItemBean();
            childData1.setSuffix("分");
            childData1.setValue(random.nextInt(50) + 51);
            childDataList.add(childData1);

            HistogramItemBean childData2 = new HistogramItemBean();
            childData2.setSuffix("%");
            childData2.setValue(random.nextInt(50) + 51);
            childDataList.add(childData2);
            groupData.setList(childDataList);
            groupDataList.add(groupData);
        }
        histogramView.setDataList(groupDataList);
        int[] color1 = new int[]{getResources().getColor(R.color.gold), getResources().getColor(R.color.colorPrimary)};

        int[] color2 = new int[]{getResources().getColor(R.color.pink), getResources().getColor(R.color.yellow)};
        // 设置直方图颜色
        histogramView.setHistogramColor(color1, color2);
carter_yu
关注
专栏目录
Android自定义控件横向柱状统计图
08-18
主要为大家详细介绍了Android自定义控件横向柱状统计图，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
可以左右拖动和快速滑动的折线统计图
05-23
使用surfaceview开发的折线统计图，可以左右滑动，手指快速滚动后可以有快速滚动的效果，只需要传入一个对应的list 既可以使用。
Android可滑动缩放柱状图
最新发布
weixin_41281005的博客
08-08 13
Android可滑动缩放柱状图的实现 前言 随着移动设备的普及，数据可视化逐渐成为用户体验中的重要组成部分。在众多可视化方案中，柱状图因其直观性和简洁性被广泛应用。在Android开发中，实现可滑动和缩放的柱状图，有助于用户更好地理解和分析数据。本文将讨论如何使用Android中的一些开源库，结合代码示例来实现这一功能。 ...
Android自定义饼状图、柱状图、双折线图
12-16
一开始是使用第三方的绘图框架Achartengine来绘制，能实现一大部分的图形。可针对公司产品天马行空的想象显然Achartengine已经不能满足现在的项目了。为此小编我只能尝试着自己自定义一些图表类的控件。这里给大家带来可点击的饼状图、可点击以及可滑动的柱状图、双折线图
Android柱状图（纯手撸、可左右滑动）
李小伟其实很菜
02-22 1731
前言： Android本身是没有柱状图这个控件的，不过网上有不少强大的开源库，酷炫又方便，这里不再赘述。 效果图： （标清+大水印）凑合着看 代码： 皆尽所能的优化/简化了代码，实际代码量就两百来行，教科书级别的注释，复制粘贴就能用 package com.zistone.factorytest0718.view; import android.content.Context; import android.graphics.Canvas; import android.graphics
Android自定义View-柱状图(java)
s5924854的博客
03-13 1033
自定义柱状图
自定义柱状图（可左右滑动）
12-17
添加了手动滑动效果（在屏幕绘制宽度不够时启动滑动。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。）
Android自定义柱状图，带有标注和左右滑动效果
11-18
最近自己改进了一下柱状图的绘制，支持多跟柱子，自己设置颜色，并且添加了手动滑动效果（在屏幕绘制宽度不够时启动滑动）
Android 自定义左右可滑动的柱状图
xiaozhang0414的博客
11-12 717
//自定义滑动的柱状图 public class HistogramView extends View { private Paint mLinePaint; private Paint mGreenPaint; private Paint mTextPaint; private Paint mWhitePaint; private Context mContext; private float mScale; private String[] y.
Android自定义滑动下表统计图,Android编程实现canvas绘制柱状统计图功能【自动计算宽高及分度值、可左右滑动】...
weixin_29468281的博客
05-25 431
本文实例讲述了Android编程实现canvas绘制柱状统计图功能。分享给大家供大家参考，具体如下：这里实现了一个简单的柱状统计图，如下：特点：1.根据数据源自动计算每个条目的高度、宽度、间距，自动计算分度值。2.当条目数较多时，可左右滑动查看全部内容，图形、文字同步滑动，并且松手后会渐渐的停下来(而不是立刻停下来)。代码：(1)核心代码：BarChartView.Javapackage com...
Android 自定义柱状图（可滑动）
qq_15931971的博客
08-14 1100
先上图 还是有些需要完善的，比如每个柱状图的点击事件，做的有点乱；画柱子画线都比较简单，复杂一点的就是左右滑动；还有画Y轴刻度，还有每个柱子Top的计算有点麻烦；下面贴上所有代码： package com.ex.testview; import android.content.Context; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Paint; impor.
用MPAndroidChart实现可滑动的柱状图
12-02
用MPAndroidChart实现可滑动的柱状图 原理:MPAndroidChart并没有提供给滑动柱状图,但是视图是可以放大的,然后就能滑动了,so,嘿嘿嘿 详情,我的博客中会有的
android可滑动柱状图
06-25
android可滑动柱状图。需要的朋友可以下载看看或者根据自己的需求进行修改
Android使用自定义ListView+ScrollView实现股票界面上下左右滑动
09-30
最近公司做股票相关软件，界面需求是这样的，横向无限长，可以横向滚动，而且最左侧的那一竖栏要定住，网上找了写例子，都太复杂，这里来一个简单的。
Android代码-android可拖动柱状图.rar
08-02
android可拖动柱状图.rar
Android自定义折线图，可左右滑动，可点击
01-10
Android自定义折线图，可左右滑动，可点击，使用简单轻便
Android自定义view实现动态柱状图
08-29
本篇文章将深入探讨如何利用Android自定义View来实现动态柱状图。动态柱状图是一种常见且直观的数据展示方式，它能够以图形的形式生动地展示数据的变化，特别适用于数据分析和监控应用。 首先，我们看到一个名为`...
Android自定义view可拖动的柱状图折线图组合可拖动的折线图
qq_22718203的博客
08-07 1593
公司最近一个需求就是需要每年的每个月的消费概况的统计图 ，因为涉及到一些乱七八糟的需求 。先看图 其中要求本年未到的年份不一样的颜色，且数据不用画出来当然也没有数据。折线下面有个阴影。所以决定自己撸个图。看布局： &lt;com.py.ysl.view.myview.BarGraphView android:id="@+id/bar_view" android...
android 自定义柱状图左右滑动
09-05
要实现在Android上自定义柱状图的左右滑动，可以借助于RecyclerView和ViewPager来实现。 首先，在布局文件中，创建一个包含RecyclerView和一个水平滑动指示器（如RecyclerView下方的TabLayout）的布局。将RecyclerView设置为水平方向，并设置其高度为固定值或MatchParent。 接下来，创建一个Adapter类来加载柱状图的数据，并绑定到RecyclerView上。在Adapter中，可以使用自定义的ViewHolder来展示柱状图的内容。 在Activity或Fragment中，初始化RecyclerView和Adapter，并将Adapter设置给RecyclerView。通过LayoutManager设置RecyclerView的布局管理器为横向滑动的LinearLayoutManager，使得柱状图能够横向滑动。 如果需要添加滑动指示器，可以在布局文件中添加一个TabLayout，并将其与ViewPager绑定。然后，在Adapter中实现RecyclerView的滑动监听器，在滑动状态改变时将当前选中的项设置给ViewPager，并相应地更新指示器的位置。 如果需要添加左右滑动的动画效果，可以在Adapter中重写onViewDetachedFromWindow和onViewAttachedToWindow方法，并在这些方法中添加动画效果，以使柱状图在滑动时具有生动和平滑的动画效果。 通过以上步骤，就可以实现在Android上自定义柱状图的左右滑动功能了。用户可以通过水平滑动手势浏览柱状图的不同部分，而滑动指示器能够方便地显示当前所在的位置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值