MPAndroidChart

ゝ一世哀愁。 2022-05-24 00:21 216阅读 0赞

## 0001 ##

## 刷新 ##

*  invalidate() : 在chart中调用会使其刷新重绘
 *  notifyDataSetChanged() : 让chart知道它依赖的基础数据已经改变，并执行所有必要的重新计算（比如偏移量，legend，最大值，最小值 …）。在动态添加数据时需要用到。

## 三、打印日志 ##

*  setLogEnabled(boolean enabled) : 设置为true将激活chart的logcat输出。但这不利于性能，如果不是必要的，应保持禁用。

## 四、基本chart风格 ##

这里我们先定义一个LineChart范例：

<com.github.mikephil.charting.charts.LineChart android:id="@+id/line_chart" android:layout_width="match_parent" android:layout_height="300dp" android:background="#ffffff" android:layout_margin="16dp"/>

![LineChart范例 原始效果图][LineChart_]

下面是一些可以直接在 chart 上使用的设置 style 的方法：

*  `setBackgroundColor(int color)` : 设置背景颜色，将覆盖整个图表视图。 此外，背景颜色可以在布局文件 `.xml` 中进行设置。  
    ![LineChart范例 原始效果图][LineChart_]![chart.setBackgroundColor(0xff00ff00);][chart.setBackgroundColor_0xff00ff00]

注意：设置颜色时要ARGB完整的八位（如 `0xff00ff00`），否则可能会被视为“设置透明颜色”（如 `0xff0000`）

*  `setDescription(String desc)` : 设置图表的描述文字，会显示在图表的右下角。
 *  `setDescriptionColor(int color)` : 设置描述文字的颜色。  
    ![LineChart范例 原始效果图][LineChart_]![chart.setDescription( zhuanghongji );  chart.setDescriptionColor(Color.RED);][chart.setDescription_ zhuanghongji _ chart.setDescriptionColor_Color.RED]
 *  `setDescriptionPosition(float x, float y)` : 自定义描述文字在屏幕上的位置（单位是像素）。
 *  `setDescriptionTypeface(Typeface t)` : 设置描述文字的 Typeface。
 *  `setDescriptionTextSize(float size)` : 设置以像素为单位的描述文字，最小6f，最大16f。  
    ![chart.setDescription( zhuanghongji );  chart.setDescriptionColor(Color.RED);][chart.setDescription_ zhuanghongji _ chart.setDescriptionColor_Color.RED]![chart.setDescriptionPosition(150f,150f); chart.setDescriptionTextSize(16f);][chart.setDescriptionPosition_150f_150f_ chart.setDescriptionTextSize_16f]
 *  `setNoDataTextDescription(String desc)` : 设置当 chart 为空时显示的描述文字。  
    ![LineChart范例 原始效果图][LineChart_]![chart.setNoDataTextDescription( Data 为空！) ;][chart.setNoDataTextDescription_ Data _]
 *  `setDrawGridBackground(boolean enabled)` : 如果启用，chart 绘图区后面的背景矩形将绘制。  
    ![chart.setDrawGridBackground(false);][LineChart_]![chart.setDrawGridBackground(true);][chart.setDrawGridBackground_true]
 *  `setGridBackgroundColor(int color)` : 设置网格背景应与绘制的颜色。  
    ![chart.setDrawGridBackground(true);][chart.setDrawGridBackground_true]![chart.setDrawGridBackground(true); chart.setGridBackgroundColor(Color.BLUE);][chart.setDrawGridBackground_true_ chart.setGridBackgroundColor_Color.BLUE]
 *  `setDrawBorders(boolean enabled)` : 启用/禁用绘制图表边框（chart周围的线）。
 *  `setBorderColor(int color)` : 设置 chart 边框线的颜色。
 *  `setBorderWidth(float width)` : 设置 chart 边界线的宽度，单位 dp。
 *  ![LineChart范例 原始效果图][LineChart_]![chart.setDrawBorders(true);chart.setBorderColor(Color.YELLOW);chart.setBorderWidth(4f);][chart.setDrawBorders_true_chart.setBorderColor_Color.YELLOW_chart.setBorderWidth_4f]
 *  `setMaxVisibleValueCount(int count)` : 设置最大可见绘制的 chart count 的数量。 只在 `setDrawValues()` 设置为 `true` 时有效。  
    
    # 0002 #

## 启用/ 禁止 手势交互 ##

*  `setTouchEnabled(boolean enabled)` : 启用/禁用与图表的所有可能的触摸交互。
 *  `setDragEnabled(boolean enabled)` : 启用/禁用拖动（平移）图表。
 *  `setScaleEnabled(boolean enabled)` : 启用/禁用缩放图表上的两个轴。
 *  `setScaleXEnabled(boolean enabled)` : 启用/禁用缩放在x轴上。
 *  `setScaleYEnabled(boolean enabled)` : 启用/禁用缩放在y轴。
 *  `setPinchZoom(boolean enabled)` : 如果设置为true，捏缩放功能。 如果false，x轴和y轴可分别放大。
 *  `setDoubleTapToZoomEnabled(boolean enabled)` : 设置为false以禁止通过在其上双击缩放图表。
 *  `setHighlightPerDragEnabled(boolean enabled)` : 设置为true，允许每个图表表面拖过，当它完全缩小突出。 默认值：true
 *  `setHighlightPerTapEnabled(boolean enabled)` : 设置为false，以防止值由敲击姿态被突出显示。 值仍然可以通过拖动或编程方式突出显示。 默认值：true

## 图表的 抛掷/减速 ##

*  `setDragDecelerationEnabled(boolean enabled)` : 如果设置为true，手指滑动抛掷图表后继续减速滚动。 默认值：true。
 *  `setDragDecelerationFrictionCoef(float coef)` : 减速的摩擦系数在\[0; 1\]区间，数值越高表示速度会缓慢下降，例如，如果将其设置为0，将立即停止。 1是一个无效的值，会自动转换至0.9999。

## 高亮 ##

*  `highlightValues(Highlight[] highs)` : 高亮显示值，高亮显示的点击的位置在数据集中的值。 设置null或空数组则撤消所有高亮。
 *  `highlightValue(int xIndex, int dataSetIndex)` : 高亮给定xIndex在数据集的值。 设置xIndex或dataSetIndex为-1撤消所有高亮。
 *  `getHighlighted()` : 返回一个 `Highlight[]` 其中包含所有高亮对象的信息，xIndex和dataSetIndex。

以java编程方式使得值高亮不会回调 `OnChartValueSelectedListener` .

## 选择回调 ##

MPAndroidChart 提供了许多用于交互回调的方法，其中 `OnChartValueSelectedListener` 在点击高亮值时回调。

public interface OnChartValueSelectedListener { 
        /** * Called when a value has been selected inside the chart. * * @param e The selected Entry. * @param dataSetIndex The index in the datasets array of the data object * the Entrys DataSet is in. * @param h the corresponding highlight object that contains information * about the highlighted position */
        public void onValueSelected(Entry e, int dataSetIndex, Highlight h);
        /** * Called when nothing has been selected or an "un-select" has been made. */
        public void onNothingSelected();
    }

让你的类实现该接口并设置对 chart 进行监听，即可接受回调。  
Simply let your class that should receive the callbacks implement this interface and set it as a listener to the chart:

chart.setOnChartValueSelectedListener(this);

*  1

## 手势回调 ##

监听器 `OnChartGestureListener` 可以使得 chart 与手势操作进行交互。

public interface OnChartGestureListener { 
    
        /** * Callbacks when a touch-gesture has started on the chart (ACTION_DOWN) * * @param me * @param lastPerformedGesture */
        void onChartGestureStart(MotionEvent me, ChartTouchListener.ChartGesture lastPerformedGesture);
    
        /** * Callbacks when a touch-gesture has ended on the chart (ACTION_UP, ACTION_CANCEL) * * @param me * @param lastPerformedGesture */
        void onChartGestureEnd(MotionEvent me, ChartTouchListener.ChartGesture lastPerformedGesture);
    
        /** * Callbacks when the chart is longpressed. * * @param me */
        public void onChartLongPressed(MotionEvent me);
    
        /** * Callbacks when the chart is double-tapped. * * @param me */
        public void onChartDoubleTapped(MotionEvent me);
    
        /** * Callbacks when the chart is single-tapped. * * @param me */
        public void onChartSingleTapped(MotionEvent me);
    
        /** * Callbacks then a fling gesture is made on the chart. * * @param me1 * @param me2 * @param velocityX * @param velocityY */
        public void onChartFling(MotionEvent me1, MotionEvent me2, float velocityX, float velocityY);
    
       /** * Callbacks when the chart is scaled / zoomed via pinch zoom gesture. * * @param me * @param scaleX scalefactor on the x-axis * @param scaleY scalefactor on the y-axis */
        public void onChartScale(MotionEvent me, float scaleX, float scaleY);
    
       /** * Callbacks when the chart is moved / translated via drag gesture. * * @param me * @param dX translation distance on the x-axis * @param dY translation distance on the y-axis */
        public void onChartTranslate(MotionEvent me, float dX, float dY);
    }

让你的类实现该接口并设置对 chart 进行监听，即可接受回调。

chart.setOnChartGestureListener(this);

设置了监听器后，chart 会根据你的 `setXXXEnable()` 进行放缩移动等操作。不用在接口方法里对图表进行放缩移动等其他操作，接口方法可以让你实现其他对应功能，比如说你要打印放缩是的 `ScaleX，ScaleY` :

@Override
        public void onChartScale(MotionEvent me, float scaleX, float scaleY) {
            Log.i("Scale / Zoom", "ScaleX: " + scaleX + ", ScaleY: " + scaleY);
        }

打印的日志类似：

I/Gesture: START
    I/Scale / Zoom: ScaleX: 1.0, ScaleY: 1.0
    I/Scale / Zoom: ScaleX: 1.0, ScaleY: 1.0
    I/Scale / Zoom: ScaleX: 1.0174584, ScaleY: 1.0174584
    I/Scale / Zoom: ScaleX: 1.240304, ScaleY: 1.240304
    I/Scale / Zoom: ScaleX: 1.4446417, ScaleY: 1.4446417
    I/Scale / Zoom: ScaleX: 1.5617653, ScaleY: 1.5617653
    I/Scale / Zoom: ScaleX: 1.0241176, ScaleY: 1.0241176
    I/Scale / Zoom: ScaleX: 1.1038365, ScaleY: 1.1038365
    I/Gesture: END, lastGesture: PINCH_ZOOM

下面是练习时写的一些 `OnChartGestureListener` 接口实现方法：

@Override
        public void onChartGestureStart(MotionEvent me, ChartTouchListener.ChartGesture lastPerformedGesture) {
            Log.i("Gesture", "START");
        }
    
        @Override
        public void onChartGestureEnd(MotionEvent me, ChartTouchListener.ChartGesture lastPerformedGesture) {
            Log.i("Gesture", "END, lastGesture: " + lastPerformedGesture);
    
            // un-highlight values after the gesture is finished and no single-tap
            if (lastPerformedGesture != ChartTouchListener.ChartGesture.SINGLE_TAP)
                mChart.highlightValues(null); // or highlightTouch(null) for callback to onNothingSelected(...)
        }
    
        @Override
        public void onChartLongPressed(MotionEvent me) {
            Log.i("LongPress", "Chart longpressed.");
        }
    
        @Override
        public void onChartDoubleTapped(MotionEvent me) {
            Log.i("DoubleTap", "Chart double-tapped.");
        }
    
        @Override
        public void onChartSingleTapped(MotionEvent me) {
            Log.i("SingleTap", "Chart single-tapped.");
        }
    
        @Override
        public void onChartFling(MotionEvent me1, MotionEvent me2, float velocityX, float velocityY) {
            Log.i("Fling", "Chart flinged. VeloX: " + velocityX + ", VeloY: " + velocityY);
        }
    
        @Override
        public void onChartScale(MotionEvent me, float scaleX, float scaleY) {
            Log.i("Scale / Zoom", "ScaleX: " + scaleX + ", ScaleY: " + scaleY);
        }
    
        @Override
        public void onChartTranslate(MotionEvent me, float dX, float dY) {
            Log.i("Translate / Move", "dX: " + dX + ", dY: " + dY);
        }
    
        @Override
        public void onValueSelected(Entry e, int dataSetIndex, Highlight h) {
            Log.i("Entry selected", e.toString());
            Log.i("", "low: " + mChart.getLowestVisibleXIndex() + ", high: " + mChart.getHighestVisibleXIndex());
        }
    
        @Override
        public void onNothingSelected() {
            Log.i("Nothing selected", "Nothing selected.");
        }
    }

## 坐标轴 ##

### 1.Document ###

在文档中，AxisBase是XAxis和YAxis的父类

*  AxisBase  
    Baseclass of all labels.
 *  XAxis  
    Class representing the x-axis labels settings. Only use the setter methods to modify it. Do not access public variables directly. Be aware that not all features the XLabels class provides are suitable for the RadarChart.  
    X轴标签设置。只使用setter方法来修改它，不要直接访问公共变量。请注意，not all features the XLabels class provides are suitable for the RadarChart（对于RadarChart蜘蛛网状图不是所有的Xlabels 都适用）。
 *  YAxis  
    Class representing the y-axis labels settings and its entries. Only use the setter methods to modify it. Do not access public variables directly. Be aware that not all features the YLabels class provides are suitable for the RadarChart. Customizations that affect the value range of the axis need to be applied before setting data for the chart.  
    Y轴标签设置和它的条目。只使用setter方法来修改它，不要直接访问公共变量。请注意，not all features the XLabels class provides are suitable for the RadarChart（对于RadarChart蜘蛛网状图不是所有的Ylabels 都适用）。在为 `chart` 设置 data 之前，影响轴的值范围的 Customizations 需要先被应用。

### 2. 概述 ###

下面提及的方法可以适用于两个轴 。

“轴”类允许特定的Style，由以下 components/parts 组成（可以包含）：

*  轴的标签（y轴垂直绘制 或 x轴水平取向），contain 轴的描述值。
 *  所谓 `axis-line` 被直接绘制在便签旁且平行。
 *  `grid-lines` 在水平方向，且源自每一个轴标签。
 *  `LimitLines` 允许呈现的特别信息，如边界或限制。

### 3. 控制轴的哪些部分被绘制 ###

*  `setEnabled(boolean enabled)` : 设置轴启用或禁用。如果false，该轴的任何部分都不会被绘制（不绘制坐标轴/便签等）。比如：  
    ![xAxis.setEnabled(true);][xAxis.setEnabled_true]![xAxis.setEnabled(false);][xAxis.setEnabled_false]

//上面右边效果图的部分代码，设置X轴
            XAxis xAxis = chart.getXAxis();
            xAxis.setPosition(XAxis.XAxisPosition.BOTTOM); // 设置X轴的位置
    // xAxis.setTypeface(mTf); // 设置字体
            xAxis.setEnabled(false);
            // 上面第一行代码设置了false,所以下面第一行即使设置为true也不会绘制AxisLine
            xAxis.setDrawAxisLine(true); 
    
            // 前面xAxis.setEnabled(false);则下面绘制的Grid不会有"竖的线"（与X轴有关）
            xAxis.setDrawGridLines(true); // 效果如下图

*  `setDrawGridLines(boolean enabled)` : 设置为true，则绘制网格线。  
    ![左边效果图][20151214180828611]![右边效果图][20151214180842785]

// 上面左边效果图的代码
            // 两个都设置为 true
            xAxis.setEnabled(true);
            xAxis.setDrawGridLines(true);
    
            // 上面右边效果图的代码
            xAxis.setEnabled(false);
            // xAxis.setEnabled(false);则下面绘制的Grid不会有 "竖的线(与X轴有关)"
            xAxis.setDrawGridLines(true);

*  `setDrawAxisLine(boolean enabled)` : 设置为true，则绘制该行旁边的轴线（axis-line）。  
    ![xAxis.setEnabled(true);][xAxis.setEnabled_true]![xAxis.setEnabled(false);][xAxis.setEnabled_false 1]
 *  `setDrawLabels(boolean enabled)` : 设置为true，则绘制轴的标签。  
    ![xAxis.setDrawLabels(true);][xAxis.setEnabled_true]![xAxis.setDrawLabels(false);][xAxis.setDrawLabels_false]

### 4. Styling / 修改轴　 ###

*  `setTextColor(int color)` : 设置轴标签的颜色。
 *  `setTextSize(float size)` : 设置轴标签的文字大小。
 *  `setTypeface(Typeface tf)` : 设置轴标签的 Typeface。
 *  `setGridColor(int color)` : 设置该轴的网格线颜色。
 *  `setGridLineWidth(float width)` : 设置该轴网格线的宽度。
 *  `setAxisLineColor(int color)` : 设置轴线的轴的颜色。
 *  `setAxisLineWidth(float width)` : 设置该轴轴行的宽度。  
    ![左边效果图][20151214180828611]![下面代码的效果图][20151214194142156]

xAxis.setTextColor(Color.BLUE);
            xAxis.setTextSize(24f);
            xAxis.setGridLineWidth(10f);
            xAxis.setGridColor(Color.RED);
            xAxis.setAxisLineColor(Color.GREEN);
            xAxis.setAxisLineWidth(5f);

*  `enableGridDashedLine(float lineLength, float spaceLength, float phase)` : 启用网格线的虚线模式中得出，比如像这样“ - - - - - - ”。
    
     *  “lineLength”控制虚线段的长度
     *  “spaceLength”控制线之间的空间
     *  “phase”controls the starting point.
    
    ![未设置虚线的图][20151214180828611]![xAxis.enableGridDashedLine(4,4,1);][xAxis.enableGridDashedLine_4_4_1]

### 5. 限制线 ###

两个轴支持 `LimitLines` 来呈现特定信息，如边界或限制线。`LimitLines` 加入到 `YAxis` 在水平方向上绘制，添加到 `XAxis` 在垂直方向绘制。 如何通过给定的轴添加和删除 `LimitLines`：

*  `addLimitLine(LimitLine l)` : 给该轴添加一个新的 LimitLine 。
 *  `removeLimitLine(LimitLine l)` : 从该轴删除指定 LimitLine 。
 *  还有其他的方法进行 添加/删除 操作。  
    ![设置x轴的LimitLine][x_LimitLine]![设置y轴的LimitLine][y_LimitLine]

// 设置x轴的LimitLine，index是从0开始的
            LimitLine xLimitLine = new LimitLine(4f,"xL 测试");
            xLimitLine.setLineColor(Color.GREEN);
            xLimitLine.setTextColor(Color.GREEN);
            xAxis.addLimitLine(xLimitLine);
    
            // 设置x轴的LimitLine
            LimitLine yLimitLine = new LimitLine(50f,"yLimit 测试");
            yLimitLine.setLineColor(Color.RED);
            yLimitLine.setTextColor(Color.RED);
            // 获得左侧侧坐标轴
            YAxis leftAxis = chart.getAxisLeft();
            leftAxis.addLimitLine(yLimitLine);

*  `setDrawLimitLinesBehindData(boolean enabled)` : 控制 `LimitLines` 与 `actual data` 之间的 `z-order` 。 如果设置为 true，LimitLines 绘制在 actual data 的后面，否则在其前面。 默认值：false  
    ![xAxis.setDrawLimitLinesBehindData(true);][xAxis.setDrawLimitLinesBehindData_true]![20151214202753278][]

// 查看setLimitLinesBehindData()方法，true或false的效果图
            LimitLine xLimitLine = new LimitLine(2f,"is Behind");
            xLimitLine.setLineColor(Color.BLUE);
            xLimitLine.setTextColor(Color.BLUE);
            xAxis.addLimitLine(xLimitLine);
            xAxis.setDrawLimitLinesBehindData(true);
    // xAxis.setDrawLimitLinesBehindData(false);

Limit lines（`LimitLine类`） 用来为用户提供简单明了的额外信息。

再举一个例子，在用户登录用的应用程序中，图表可能会显示各种血压测量结果。 为了让用户知道超过140mmHg 的血压是被认为是一个健康风险的用户，可以添加一个 `140` 的 `LimitLine` 来提供该信息。示例代码 ：

YAxis leftAxis = chart.getAxisLeft();
    
    LimitLine ll = new LimitLine(140f, "血压偏高");
    ll.setLineColor(Color.RED);
    ll.setLineWidth(4f);
    ll.setTextColor(Color.BLACK);
    ll.setTextSize(12f);
    // .. and more styling options
    
    leftAxis.addLimitLine(ll);

## `二、X坐标轴` ##

### `1. 概述` ###

`XAxis 类是 AxisBase 的一个子类。 XAxis 类是所有与水平轴相关的 “数据和信息容器”。 每个 Line-, Bar-, Scatter-, CandleStick- and RadarChart 都有一个 XAxis 对象。 XAxis 对象展示了以 ArrayList<String> 或 String[] ("xVals") 形式递交给 ChartData 对象的数据。`

`为了获得 XAxis 类的实例，可执行以下操作：`

XAxis xAxis = chart.getXAxis();

### 2. 自定义轴值 ###

*  `setSpaceBetweenLabels(int characters)` : 设置标签字符间的空隙，默认characters间隔是4 。  
    ![默认间隔：4][20151214180828611]![setSpaceBetweenLabels(1)][setSpaceBetweenLabels_1]
 *  `setLabelsToSkip(int count)` : 设置在”绘制下一个标签”时，要忽略的标签数。 This will disable the feature that automatically calculates an adequate space between the axis labels and set the number of labels to be skipped to the fixed number provided by this method. Call `resetLabelsToSkip(...)` to re-enable automatic calculation.  
    ![setLabelsToSkip(2)][setLabelsToSkip_2]![setLabelsToSkip(3)][setLabelsToSkip_3]
 *  `resetLabelsToSkip()` : 调用这个方法将使得通过 `setLabelsToSkip(...)` 的“忽略效果”失效 while drawing the x-axis. Instead, the number of values to skip will again be calculated automatically.  
    ![有resetLabelsToSkip()][resetLabelsToSkip]![没有resetLabelsToSkip()][resetLabelsToSkip 1]

// 上面左图的代码
        xAxis.setLabelsToSkip(4);
        // xAxis.resetLabelsToSkip();
    
        // 上面右图的代码，会发现 xAxis.setLabelsToSkip(4); 的效果并没有出现
        xAxis.setLabelsToSkip(4);
        xAxis.resetLabelsToSkip();

*  `setAvoidFirstLastClipping(boolean enabled)` : 如果设置为true，则在绘制时会避免“剪掉”在x轴上的图表或屏幕边缘的第一个和最后一个坐标轴标签项。
 *  `setPosition(XAxisPosition pos)` : 设置XAxis出现的位置。
    
     *  `TOP`，`BOTTOM`，
     *  `TOP_INSIDE`，`BOTTOM_INSIDE` 或 `BOTH_SIDED`。 (从左到右，从上到下，对应下图)  
        ![XAxisPosition.TOP][]![XAxisPosition.BOTTOM][]  
        ![XAxisPosition.TOP\_INSIDE][XAxisPosition.TOP_INSIDE]![XAxisPosition.BOTTOM\_INSIDE][XAxisPosition.BOTTOM_INSIDE]  
        ![XAxisPosition.BOTH\_SIDED][XAxisPosition.BOTH_SIDED]

### 3. 格式化值 ###

setValueFormatter(XAxisValueFormatter formatter)设置自定义格式，在绘制之前动态调整x的值。

### 4. 范例代码 ###

XAxis xAxis = chart.getXAxis();
    xAxis.setPosition(XAxisPosition.BOTTOM);
    xAxis.setTextSize(10f);
    xAxis.setTextColor(Color.RED);
    xAxis.setDrawAxisLine(true);
    xAxis.setDrawGridLines(false);
    // set a custom value formatter
    xAxis.setXValueFormatter(new MyCustomFormatter()); 
    // and more...

# 0003 #

## 三、Y轴 ##

### 1. 概述 ###

`YAxis` 是 `AxisBase` 的一个子类。

`YAxis` 类是一切与垂直轴相关的数据和信息的容器。 每个 Line-, Bar-, Scatter or CandleStickChart 都有 `left` 和 `right` 的 `YAxis` 的对象，分别在左右两边。 但是 `RadarChart` 只有一个 `YAxis` 。 缺省情况下，图表的两个轴都被启用，并且将被绘制。

通过以下方法可获得 `YAxis` 类实例 ：

YAxis leftAxis = chart.getAxisLeft();
    YAxis rightAxis = chart.getAxisRight();
    
    YAxis leftAxis = chart.getAxis(AxisDependency.LEFT);
    
    YAxis yAxis = radarChart.getYAxis(); // this method radarchart only

在运行时，使用 `public AxisDependency getAxisDependency()` 方法以确定此轴表示图表的侧面。

### 2. 自定义轴值 ###

*  `setStartAtZero(boolean enabled)` : 设置为 true，则无论图表显示的是哪种类型的数据，该轴最小值总是0 。
 *  `setAxisMaxValue(float max)` : 设置该轴的最大值。 如果设置了，这个值将不会是根据提供的数据计算出来的。
 *  `resetAxisMaxValue()` : 调用此方法撤销先前设置的最大值。 通过这样做，你将再次允许轴自动计算出它的最大值。
 *  `setAxisMinValue(float min)` : 设置该轴的自定义最小值。 如果设置了，这个值将不会是根据提供的数据计算出来的。
 *  `resetAxisMinValue()` : 调用此撤销先前设置的最小值。 通过这样做，你将再次允许轴自动计算它的最小值。  
    ![原始图][20151215003245914]![进行下面的代码设置后][20151215003305229]

// 上面的右图是以下代码设置后的效果图
            leftAxis.setStartAtZero(false);
            leftAxis.setAxisMinValue(30);
            leftAxis.setAxisMaxValue(60);

*  `setInverted(boolean enabled)` : 如果设置为true，该轴将被反转，这意味着最高值将在底部，顶部的最低值。  
    ![setInverted(false)][20151215003305229]![setInverted(true)][setInverted_true]
 *  `setSpaceTop(float percent)` : 设置图表中的最高值的顶部间距占最高值的值的百分比（设置的百分比 = 最高柱顶部间距/最高柱的值）。默认值是10f，即10% 。  
    ![leftAxis.setSpaceTop(50f);][leftAxis.setSpaceTop_50f]![leftAxis.setSpaceTop(100f);][leftAxis.setSpaceTop_100f]

// 上面左图，间距长度是值长度的50%,间距长度是值长度的二分之一
        leftAxis.setSpaceTop(20f);
    
        // 上面左图，间距长度是值长度的100%，即两者相等
        leftAxis.setSpaceTop(100f);

*  `setSpaceBottom(float percent)` : Sets the bottom spacing (in percent of the total axis-range) of the lowest value in the chart in comparison to the lowest value on the axis.
 *  `setLabelCount(int count, boolean force)` : 设置y轴的标签数量。 请注意，这个数字是不固定 `if(force == false)`，只能是近似的。 如果 `if(force == true)`，则确切绘制指定数量的标签，但这样可能导致轴线分布不均匀。
 *  `setShowOnlyMinMax(boolean enabled)` : 如果启用，该轴将只显示它的最小值和最大值。 如果 `force == true` 这可能会被 `忽略/覆盖` 。  
    ![20151215005846507][]![20151215005904346][]

// 上面的左图
        leftAxis.setLabelCount(5, false);
        leftAxis.setShowOnlyMinMax(true);
    
        // 上面的右图
        leftAxis.setLabelCount(5, false);
        leftAxis.setShowOnlyMinMax(true);

*  `setPosition(YAxisLabelPosition pos)` : 设置，其中轴标签绘制的位置。 无论是 `OUTSIDE_CHART` 或 `INSIDE_CHART` 。
 *  ![YAxis.YAxisLabelPosition.OUTSIDE\_CHART][YAxis.YAxisLabelPosition.OUTSIDE_CHART]![YAxis.YAxisLabelPosition.INSIDE\_CHART][YAxis.YAxisLabelPosition.INSIDE_CHART]

为图表设定数据前，影响图表轴所需的值范围要先定义好。

### 3. 自定义格式的轴标签 ###

*  `setValueFormatter(YAxisValueFormatterf)` : 设置该轴的自定义 ValueFormatter 。 该接口允许 格式化/修改 原来的标签文本，返回一个自定义的文本。

### 4. 示例代码 ###

YAxis yAxis = mChart.getAxisLeft();
    yAxis.setTypeface(...); // set a different font
    yAxis.setTextSize(12f); // set the textsize
    yAxis.setAxisMaxValue(100f); // the axis maximum is 100
    yAxis.setTextColor(Color.BLACK);
    yAxis.setValueFormatter(new MyValueFormatter());
    yAxis.setLabelCount(6, false);
    //... and more

`ChartData 类 为了让大家更容易理解，这里先简单介绍下 MPAndroidChart 的数据模型 ChartData 。后面有文章再详细介绍该图标库的其它数据类型。 ChartData 类是所有数据类的基类，比如 LineData，BarData 等，它是用来为 Chart 提供数据的，通过 setData(ChartData data){...} 方法。`

public class LineData extends ChartData { ...

*  1

以下提到的方法是在 `ChartData` 类中被实现，因此可用于所有子类。

### 1. Styling data ###

*  `setDrawValues(boolean enabled)` : 启用/禁用 绘制所有 `DataSets` 数据对象包含的数据的值文本。
 *  `setValueTextColor(int color)` : 设置 `DataSets` 数据对象包含的数据的值文本的颜色。
 *  `setValueTextSize(float size)` : 设置 `DataSets` 数据对象包含的数据的值文本的大小（单位是dp）。  
    ![dataSet.setDrawValues(true);][dataSet.setDrawValues_true]![dataSet.setDrawValues(false);][dataSet.setDrawValues_false]

//LineDataSet可以看做是一条线
        LineDataSet dataSet = new LineDataSet(entryList, "dataLine");
        dataSet.setLineWidth(2.5f);
        dataSet.setCircleSize(4.5f);
        dataSet.setHighLightColor(Color.RED); // 设置点击某个点时，横竖两条线的颜色
        dataSet.setDrawValues(true); // 是否在点上绘制Value
        dataSet.setValueTextColor(Color.GREEN);
        dataSet.setValueTextSize(12f);
        allLinesList.add(dataSet);

*  `setValueTypeface(Typeface tf)` : 设置Typeface的所有价值标签的所有DataSets这些数据对象包含。  
    ![左图][20151215102302035]![右图][20151215102320390]  
    ![创建 Typeface 的一些方法][Typeface]

dataSet.setValueTextSize(24f);
            allLinesList.add(dataSet);
    
            // 设置上面左图的字体
            Typeface tf1 = Typeface.createFromAsset(getAssets(), "OpenSans-BoldItalic.ttf");
            dataSet.setValueTypeface(tf1);
    
            // 设置上面右图的字体
            Typeface tf2 = Typeface.createFromAsset(getAssets(), "OpenSans-LightItalic.ttf");
            dataSet.setValueTypeface(tf2);

*  `setValueFormatter(ValueFormatter f)` : 为`DataSets` 数据对象包含的数据设置自定义的 `ValueFormatter` 。

### 2. Getters / Convenience ###

*  `getDataSetByIndex(int index)` : 返回目标 `DataSet` 列表中给定索引的数据对象。
 *  `contains(Entry entry)` : 检查此数据对象是否包含指定的Entry 。 注：这个相当影响性能，性能严峻情况下，不要过度使用。
 *  `contains(T dataSet)` : Returns true if this data object contains the provided DataSet , false if not.

### 3. Clear ###

*  `clearValues()` : 清除所有 `DataSet` 对象和所有 `Entries` 的数据 。 不会删除所提供的 `x-values` 。

### 4, 选中高亮 ###

*  `setHighlightEnabled(boolean enabled)` : 设置为true，允许通过点击高亮突出 `ChartData` 对象和其 `DataSets` 。

## 二、设置数据 ##

### 1. 概述 ###

如果你想为图表添加数据，你可以通过下面这个方法：

public void setData(ChartData data) { ... }

基类 `ChartData` 封装了渲染过程中所需要的图表中的所有数据和信息。 对于每种类型的图表，不同的 `ChartData` 子类（例如 `LineData`）应该被用于为图表设置数据。 在构造函数中，你可以通过 `ArrayList<? extends DataSet>` 作为要显示的值，一个额外 `ArrayList` 的 `String` 用来描述 x 轴上的标签。 例如，通过 `LineData` 将数据添加到一个 `LineChart` :

// this is just one of many constructors
        public LineData(ArrayList<String> xVals, ArrayList<LineDataSet> sets) { ... }

那么，`DataSet` 到底是什么和为什么你会需要它？ 很简单，一个 `DataSet` 对象代表一组 `entries`（数据类型 `Entry`），在图表内属于一个整体。 它在图表中被设计成 **逻辑上分离的不同组的值** 。 每种类型的图表，通过一个不同的 `DataSet` 对象（如 `LineDataSet`）来做出特定的 style 。

### 2. 举个例子 ###

你可能想用 `LineChart` 来 **显示两个不同公司一年的季度收入** 。在这种情况下，将建议创建两个不同的 `LineDataSet` 对象，每个包含四个值（四个季度）。 用一个 `ArrayList` 描述在x轴上的标签，您只需提供四个 `String` : `“第一季度”，“第二季度”，“第三季度”，“第四季度”` 。

当然，也有可能只提供一个包含两个公司的所有8个值的 `LineDataSet` 对象。

那么，如何建立一个 `LineDataSet` 对象？

// LineDataSet 类的源码
    public class LineDataSet extends LineRadarDataSet<Entry> { 
        ....
        public LineDataSet(List<Entry> yVals, String label) {
            super(yVals, label);
    
            // mCircleSize = Utils.convertDpToPixel(4f);
            // mLineWidth = Utils.convertDpToPixel(1f);
    
            mCircleColors = new ArrayList<Integer>();
    
            // default colors
            // mColors.add(Color.rgb(192, 255, 140));
            // mColors.add(Color.rgb(255, 247, 140));
            mCircleColors.add(Color.rgb(140, 234, 255));
        }
        ....
    }

在构造函数中，很明显 `LineDataSet` 需要一个 `Entry` 的 `ArrayList` 参数，和一个 `String` 参数作为 **图例** （`Legend`）的 `label` 来描述 `LineDataSet` 。 此外， this label can be used to find the LineDataSet amongst other LineDataSet objects in the LineData object.

该 `Entry` 类型的 `ArrayList` 封装了图表所有的值。 `Entry` 相当一个容器，用来封装并保存“一对值”，and it’s position on the x-axis ( `the index inside the ArrayList of String of the LineData object the value is mapped to` ) :

public Entry(float val, int xIndex) { ... }

### 3. 还是用之前的例子 ###

以前面提到的（这两家公司一年的季度营收）为例：

0) 总的数据包含和操作类似：

// 假设是为 LineChart 设置数据，数据操作顺序大概如下：
    new Entry(float val, int xIndex);
    new ArrayList<Entry>();
    
    new LineDataSet(ArrayList<Entry> , "label");
    new ArrayList<LineDataSet>();
    
    new LineData(List<String> xVals, List<LineDataSet> dataSets));
    chart.setData(LineData);
    // 详细步骤继续往下看

1) 首先，创建类型的列表Entry ，将保留您的值：

ArrayList<Entry> valsComp1 = new ArrayList<Entry>();
        ArrayList<Entry> valsComp2 = new ArrayList<Entry>();

*  1
 *  2

2) 然后，给 `lists` 集合添加 `Entry` 对象。  
确保 `Entry` 对象包含的 index 都是正确的 （对于x轴来说）。

Entry c1e1 = new Entry(100.000f, 0); // 0 == quarter 1
        valsComp1.add(c1e1);
        Entry c1e2 = new Entry(50.000f, 1);  // 1 == quarter 2 ...
        valsComp1.add(c1e2);
        // and so on ...
    
        Entry c2e1 = new Entry(120.000f, 0); // 0 == quarter 1
        valsComp2.add(c2e1);
        Entry c2e2 = new Entry(110.000f, 1); // 1 == quarter 2 ...
        valsComp2.add(c2e2);
        //...

3) 现在，有了 `Entry` 对象的 `lists` 集合，再创建 `LineDataSet` 对象：

LineDataSet setComp1 = new LineDataSet(valsComp1, "Company 1");
        setComp1.setAxisDependency(AxisDependency.LEFT);
        LineDataSet setComp2 = new LineDataSet(valsComp2, "Company 2");
        setComp2.setAxisDependency(AxisDependency.LEFT);

通过调用 `setAxisDependency(...)` 使得 `DataSet` 对应指定轴，进行绘制。

4) 通过 `DataSets` 集合和 `x-axis entries` 集合，来创建我们的 `ChartData` 对象：

// public LineData(List<String> xVals, List<LineDataSet> dataSets) { 
    // super(xVals, dataSets);
    // }
    
        ArrayList<LineDataSet> dataSets = new ArrayList<LineDataSet>();
        dataSets.add(setComp1);
        dataSets.add(setComp2);
    
        ArrayList<String> xVals = new ArrayList<String>();
        xVals.add("1.Q"); xVals.add("2.Q"); xVals.add("3.Q"); xVals.add("4.Q"); 
    
        LineData data = new LineData(xVals, dataSets);
        mLineChart.setData(data);
        mLineChart.invalidate(); // refresh

*  调用 `invalidate()` 后图表被刷新，所提供的数据重新绘制。

## 三、设置颜色 ##

### 1. ColorTemplate 类简介 ###

*  **Class that holds predefined color integer arrays (e.g. ColorTemplate.VORDIPLOM\_COLORS) and convenience methods for loading colors from resources.**  
    该类封装有 **预定义的颜色整数数组**（例如 `ColorTemplate.VORDIPLOM_COLORS`）和便利的从资源加载颜色的方法。
 *  `ColorTemplate` 类的源码

public class ColorTemplate { 
    
        /** * an "invalid" color that indicates that no color is set */
        public static final int COLOR_NONE = -1;
    
        /** * this "color" is used for the Legend creation and indicates that the next * form should be skipped */
        public static final int COLOR_SKIP = -2;
    
        /** * THE COLOR THEMES ARE PREDEFINED (predefined color integer arrays), FEEL * FREE TO CREATE YOUR OWN WITH AS MANY DIFFERENT COLORS AS YOU WANT */
        public static final int[] LIBERTY_COLORS = {
                Color.rgb(207, 248, 246), Color.rgb(148, 212, 212), Color.rgb(136, 180, 187),
                Color.rgb(118, 174, 175), Color.rgb(42, 109, 130)
        };
        public static final int[] JOYFUL_COLORS = {
                Color.rgb(217, 80, 138), Color.rgb(254, 149, 7), Color.rgb(254, 247, 120),
                Color.rgb(106, 167, 134), Color.rgb(53, 194, 209)
        };
        public static final int[] PASTEL_COLORS = {
                Color.rgb(64, 89, 128), Color.rgb(149, 165, 124), Color.rgb(217, 184, 162),
                Color.rgb(191, 134, 134), Color.rgb(179, 48, 80)
        };
        public static final int[] COLORFUL_COLORS = {
                Color.rgb(193, 37, 82), Color.rgb(255, 102, 0), Color.rgb(245, 199, 0),
                Color.rgb(106, 150, 31), Color.rgb(179, 100, 53)
        };
        public static final int[] VORDIPLOM_COLORS = {
                Color.rgb(192, 255, 140), Color.rgb(255, 247, 140), Color.rgb(255, 208, 140),
                Color.rgb(140, 234, 255), Color.rgb(255, 140, 157)
        };
    
        /** * Returns the Android ICS holo blue light color. * * @return */
        public static int getHoloBlue() {
            return Color.rgb(51, 181, 229);
        }
    
        /** * turn an array of resource-colors (contains resource-id integers) into an * array list of actual color integers * * @param r * @param colors an integer array of resource id's of colors * @return */
        public static List<Integer> createColors(Resources r, int[] colors) {
    
            List<Integer> result = new ArrayList<Integer>();
    
            for (int i : colors) {
                result.add(r.getColor(i));
            }
    
            return result;
        }
    
        /** * Turns an array of colors (integer color values) into an ArrayList of * colors. * * @param colors * @return */
        public static List<Integer> createColors(int[] colors) {
    
            List<Integer> result = new ArrayList<Integer>();
    
            for (int i : colors) {
                result.add(i);
            }
    
            return result;
        }
    }

*  当时自从 MPAndroidChart V1.4.0 之后，`ColorTemplate` 这个类就不再重要了。我们可以直接通过 `DataSet` 对象进行指定颜色，从而可以区分每个 `DataSet` 的 Style 。

### 2. 举例说明 ###

还是用公司季度营收的例子，我们有两个不同的 `LineDataSet` 代表两家公司，为此我们现在要设置不同的颜色。

我们希望：

*  “公司1” 的颜色用四种不同变化“红”来表示
 *  “连队2” 的颜色用四种不同变化“绿”来表示
 *  （效果如下面效果图的右图，左图是单色的）

效果图如下所示：  
![单色][20151215140240947]![变化色][20151215140302263]

ArrayList<LineDataSet> allLinesList = new ArrayList<LineDataSet>();
        //LineDataSet可以看做是一条线
        LineDataSet dataSet1 = new LineDataSet(entryList1, "dataLine1");
        LineDataSet dataSet2 = new LineDataSet(entryList2, "dataLine2");
    
        // 上面左效果图的代码
        // dataSet1.setColor(Color.RED);
        // dataSet2.setColor(Color.GREEN);
    
        // sets colors for the dataset, 
        // resolution of the resource name to a "real" color is done internally
        dataSet1.setColors(new int[]{R.color.red1, R.color.red2, R.color.red3,
            R.color.red4}, context);
        dataSet2.setColors(new int[]{R.color.green1, R.color.green2, R.color.green3,
            R.color.green4}, context);
    
        allLinesList.add(dataSet1);
        allLinesList.add(dataSet2);
    
        List<String> quarterStrs = new ArrayList<String>();
        quarterStrs.add("第一季度");
        quarterStrs.add("第二季度");
        quarterStrs.add("第三季度");
        quarterStrs.add("第四季度");
        //LineData表示一个LineChart的所有数据(即一个LineChart中所有折线的数据)
        LineData mChartData = new LineData(quarterStrs, allLinesList);

除此之外，还有很多其他的方法来设置 `DataSet` 的颜色 。 下面是完整的文档：

*  `setColors(int [] colors, Context c)` : 设置该 DataSet 的颜色。  
    您可以使用 `new int[] {R.color.red，R.color.green，...}` 使得颜色值可以重用。 在内部，颜色是使用 `getResources().getColor(...)` 来实现获取的。
 *  `setColors(int [] colors)` : 设置该 DataSet 的颜色。Colors are reused as soon as the number of Entries the DataSet represents is higher than the size of the colors array. Make sure that the colors are already prepared (by calling `getResources().getColor(...))` before adding them to the DataSet.
 *  `setColors(ArrayList<Integer> colors)` : 设置该 DataSet 的颜色。Sets the colors that should be used fore this DataSet. Colors are reused as soon as the number of Entries the DataSet represents is higher than the size of the colors array. Make sure that the colors are already prepared (by calling `getResources().getColor(...))` before adding them to the DataSet.
 *  `setColor(int color)` : 设置该数据集 **唯一的颜色**。 在内部，实现方式类似上面的”颜色数组”，只不过”颜色数组都是同一种颜色”

### 3. ColorTemplate 的使用例子： ###

LineDataSet set = new LineDataSet(...);
    set.setColors(ColorTemplate.VORDIPLOM_COLORS);

*  如果没有为 `DataSet` 设置颜色，则使用默认颜色。

0004

ValueFormatter 接口

### 1. 简介 ###

*  **Interface that allows custom formatting of all values inside the chart before they are being drawn to the screen. Simply create your own formatting class and let it implement ValueFormatter. Then override the getFormattedValue(…) method and return whatever you want.**  
    ValueFormatter 是一个接口，在被绘制到屏幕之前允许自定义图表内所有的值的格式。方法很简单，创建自己的格式类并让它实现 ValueFormatter 接口，然后覆盖 `getFormattedValue(...)` 方法返回你想要的。

### 2. 源码 ###

public interface ValueFormatter { 
    
        /** * Called when a value (from labels inside the chart) is formatted * before being drawn. For performance reasons, avoid excessive * calculationsand memory allocations inside this method. * * @param value the value to be formatted * @param entry the entry the value belongs to - in * e.g. BarChart, this is of class BarEntry * @param dataSetIndex the index of the DataSet the entry in * focus belongs to * @param viewPortHandler provides information about the current * chart state (scale, translation, ...) * @return the formatted label ready for being drawn */
        String getFormattedValue(float value, Entry entry, int dataSetIndex, 
            ViewPortHandler viewPortHandler);
    }

### 3. 自定义数据格式例子 ###

public interface ValueFormatter { 
    
        /** * Called when a value (from labels inside the chart) is formatted * before being drawn. For performance reasons, avoid excessive calculations * and memory allocations inside this method. * * @param value the value to be formatted * @param entry the entry the value belongs to - in e.g. BarChart, * this is of class BarEntry * @param dataSetIndex the index of the DataSet the entry in focus belongs to * @param viewPortHandler provides information about the current * chart state (scale, translation, ...) * @return the formatted label ready for being drawn */
        String getFormattedValue(float value, Entry entry, int dataSetIndex, 
            ViewPortHandler viewPortHandler);
    }

*  然后，设置格式为ChartData或DataSet对象：

// usage on whole data object
    lineData.setValueFormatter(new MyValueFormatter());
    
    // usage on individual dataset object
    lineDataSet.setValueFormatter(new MyValueFormatter());

### 4. 预定义的自定义格式 ###

#### 1) LargeValueFormatter ####

可用于格式化 **大于”1.000”** 的值。 它会被转变，比如

*  “1.000”变成”1k”
 *  “1.000.000”变成”1m”(million)
 *  “1.000.000.000”将“1b”(billion)

它不支持带有小数的数字，如“1.000,5”数字。**LargeValueFormatter 源码如下：**

public class LargeValueFormatter implements ValueFormatter, YAxisValueFormatter { 
    
        private static String[] SUFFIX = new String[]{
                "", "k", "m", "b", "t"
        };
        private static final int MAX_LENGTH = 4;
        private DecimalFormat mFormat;
        private String mText = "";
    
        public LargeValueFormatter() {
            mFormat = new DecimalFormat("###E0");
        }
    
        /** * Creates a formatter that appends a specified text to the result string * * @param appendix a text that will be appended */
        public LargeValueFormatter(String appendix) {
            this();
            mText = appendix;
        }
    
        // ValueFormatter
        @Override
        public String getFormattedValue(float value, Entry entry, int dataSetIndex, 
                ViewPortHandler viewPortHandler) {
            return makePretty(value) + mText;
        }
    
        // YAxisValueFormatter
        @Override
        public String getFormattedValue(float value, YAxis yAxis) {
            return makePretty(value) + mText;
        }
    
        /** * Set an appendix text to be added at the end of the formatted value. * * @param appendix */
        public void setAppendix(String appendix) {
            this.mText = appendix;
        }
    
        /** * Set custom suffix to be appended after the values. * Default suffix: ["", "k", "m", "b", "t"] * * @param suff new suffix */
        public void setSuffix(String[] suff) {
            if (suff.length == 5) {
                SUFFIX = suff;
            }
        }
    
        /** * Formats each number properly. Special thanks to Roman Gromov * (https://github.com/romangromov) for this piece of code. */
        private String makePretty(double number) {
    
            String r = mFormat.format(number);
    
            r = r.replaceAll("E[0-9]", 
                SUFFIX[Character.getNumericValue(r.charAt(r.length() - 1)) / 3]);
    
            while (r.length() > MAX_LENGTH || r.matches("[0-9]+\\.[a-z]")) {
                r = r.substring(0, r.length() - 2) + r.substring(r.length() - 1);
            }
    
            return r;
        }
    }

#### 2) PercentFormatter ####

**Used for displaying a “%” sign after each value with 1 decimal digit .**  
对于 `PieChart` 来说非常有用。**PercentFormatter 源码如下：**

public class PercentFormatter implements ValueFormatter, YAxisValueFormatter { 
    
        protected DecimalFormat mFormat;
    
        public PercentFormatter() {
            mFormat = new DecimalFormat("###,###,##0.0");
        }
    
        /** * Allow a custom decimalformat * * @param format */
        public PercentFormatter(DecimalFormat format) {
            this.mFormat = format;
        }
    
        // ValueFormatter
        @Override
        public String getFormattedValue(float value, Entry entry, int dataSetIndex, 
                ViewPortHandler viewPortHandler) {
            return mFormat.format(value) + " %";
        }
    
        // YAxisValueFormatter
        @Override
        public String getFormattedValue(float value, YAxis yAxis) {
            return mFormat.format(value) + " %";
        }
    }

## 二、XAxisValueFormatter 接口 ##

### 1. 概述 ###

在 `v2.1.4` 后才有了这个接口。

*  `XAxisValueFormatter` 接口可用于创建定制格式化器类，在它们绘制到屏幕之前 **动态地调整 x-values** 。
 *  对于使用 `XValueFormatter` 只需创建一个新的类，让它实现接口，通过 `getXValue(...)` 方法返回任何你想要显示的 X 轴标签。 50 - > 50.0％

### 2. 自定义格式示例 ###

public class MyCustomXAxisValueFormatter implements XAxisValueFormatter { 
    
        @Override
        public String getXValue(String original, int index, ViewPortHandler viewPortHandler) {
            // original is the original value to use, x-index is the index in your x-values array
            // implement your logic here ...
            return ...;
        }
    }

*  然后，为 X 轴设置格式器：

// usage on XAxis, get axis instance:
    XAxis xAxis = chart.getXAxis();
    
    // set the formatter
    xAxis.setValueFormatter(new MyCustomXAxisValueFormatter());

### 3. 预定义了的 XAxisValueFormatters ###

*  **XAxisValueFormatters 源码：**

package com.github.mikephil.charting.formatter;
    import com.github.mikephil.charting.utils.ViewPortHandler;
    
    /** * Default formatter class for adjusting x-values before drawing them. * This simply returns the original value unmodified. */
    public class DefaultXAxisValueFormatter implements XAxisValueFormatter { 
    
        @Override
        public String getXValue(String original, int index, 
                ViewPortHandler viewPortHandler) {
            return original; // just return original, no adjustments
        }
    }

### 4. 自定义 XAxisValueFormatters 范例 ###

*  **MyCustomXAxisValueFormatter.java 代码：**

package com.xxmassdeveloper.mpchartexample.custom;
    import com.github.mikephil.charting.utils.ViewPortHandler;
    import com.github.mikephil.charting.formatter.XAxisValueFormatter;
    
    public class MyCustomXAxisValueFormatter implements XAxisValueFormatter { 
    
        public MyCustomXAxisValueFormatter() {
            // maybe do something here or provide parameters in constructor
        }
    
        @Override
        public String getXValue(String original, int index, ViewPortHandler viewPortHandler) {
    
            /* Log.i("TRANS", "x: " + viewPortHandler.getTransX() + ", y: " + viewPortHandler.getTransY()); */
    
            // e.g. adjust the x-axis values depending on scale / zoom level
            if (viewPortHandler.getScaleX() > 5)
                return "4";
            else if (viewPortHandler.getScaleX() > 3)
                return "3";
            else if (viewPortHandler.getScaleX() > 1)
                return "2";
            else
                return original;
        }
    }

## 三、YAxisValueFormatter 接口 ##

### 1. 概述 ###

在 `v2.1.4` 后才有了这个接口。

*  `YAxisValueFormatter` 接口可用于创建定制格式化器类，在它们绘制到屏幕之前 **动态地调整 x-values** 。
 *  对于使用 `YValueFormatter` 只需创建一个新的类，让它实现接口，通过 `getFormattedValue(...)` 方法返回任何你想要显示的 。

### 2. 自定义格式示例 ###

public class MyYAxisValueFormatter implements YAxisValueFormatter { 
    
        private DecimalFormat mFormat;
    
        public MyYAxisValueFormatter () {
            mFormat = new DecimalFormat("###,###,##0.0"); // use one decimal
        }
    
        @Override
        public String getFormattedValue(float value, YAxis yAxis) {
            // write your logic here
            // access the YAxis object to get more information
            return mFormat.format(value) + " $"; // e.g. append a dollar-sign
        }
    }

然后，为 `YAxis` 对象设置格式器：

// get an instance of the YAxis (e.g. left axis)
    YAxis leftAxis = chart.getAxisLeft();
    leftAxis.setValueFormatter(new MyYAxisValueFormatter());

### 3. 预定义的自定义格式 ###

`LargeValueFormatter` 和 `PercentFormatter` .

*  详情请看前面介绍的 **ValueFormatter 接口** 的 **预定义的自定义格式** 。

## 四、三种格式器的实例效果图分析 ##

### 1. ValueFormatter ###

### 2. XValueFormatter ###

### 3. YValueFormatter ###

*  自定义的 `YValueFormatter` ：**MyYAxisValueFormatter.java**

public class MyYAxisValueFormatter implements YAxisValueFormatter { 
    
        private DecimalFormat mFormat;
    
        public MyYAxisValueFormatter() {
            mFormat = new DecimalFormat("###,###,###,##0.0");
        }
    
        @Override
        public String getFormattedValue(float value, YAxis yAxis) {
            return mFormat.format(value) + " $";
        }
    }

![未设置格式器][20151216194137344]![leftAxis.setValueFormatter(new MyYAxisValueFormatter());][leftAxis.setValueFormatter_new MyYAxisValueFormatter]

YAxis leftAxis = chart.getAxisLeft();
            leftAxis.setTextSize(24f);
            leftAxis.setTextColor(Color.GREEN);
            // 给Y轴的标签文本设置数据各格式器，上面的左图未设置格式器
            leftAxis.setValueFormatter(new MyYAxisValueFormatter());

注意：`leftAxis` 的 `setValueFormatter` 参数类型只能是 `YAxisFormatter` !

*  ![20151216194716867][]

0005

## 线状图，柱状图，散点图，烛状图 & 气泡图 ： ##

本章将重点介绍各个图表类型特定的设置。

*  `setAutoScaleMinMaxEnabled(boolean enabled)` : 标志，指示自动缩放在y轴已启用。 如果启用Y轴自动调整到最小和当前的X轴的范围，只要视口变化的最大y值。 这是图表显示的财务数据特别有趣。 默认值：false

## 一、柱状图 ##

*  `setDrawValueAboveBar(boolean enabled)` : 如果设置为true，所有值都高于其 bar 的，而不是低于其顶部。默认：true  
    ![缺省或 setDrawValueAboveBar(true)][setDrawValueAboveBar_true]![setDrawValueAboveBar(false)][setDrawValueAboveBar_false]
 *  `setDrawBarShadow(boolean enabled)` : 如果设置为true，会在各条 bar 后面绘制 “灰色全 bar”，用以指示最大值。 启用会降低性能约 40％ 。默认：false  
    ![setDrawBarShadow(false)][setDrawBarShadow_false]![setDrawBarShadow(true)][setDrawBarShadow_true]
 *  `setDrawValuesForWholeStack(boolean enabled)` : If set to true, all values of stacked bars are drawn individually, and not just their sum on top of all.
 *  `setDrawHighlightArrow(boolean enabled)` : Set this to true to draw the highlightning arrow above each bar when highlighted.

## 二、饼形图 ##

*  `setCenterText(SpannableString text)` : 设置所绘制在饼图中心的文本。 较长的文本将被自动“wrapped”，以避免被裁剪成一段一段的。
 *  `setCenterTextRadiusPercent(float percent)` : 设置中心文本 边框的矩形范围，as a percentage of the pie hole default 1.0f (100%) , 该值可以大于1.0f .  
    要想真正改变中心文本的大小，要通过 `chart.setCenterTextSize(float size);` 来进行设置。  
    ![20151222144015437][]![20151222144028576][]

chart.setCenterText("MPChart\nAndroid");
            chart.setCenterTextSize(18f);
            // 上面左图
            chart.setCenterTextRadiusPercent(0.8f);
            // 上面左图
            chart.setCenterTextRadiusPercent(0.1f);

*  `chart.setCenterTextSize(float size)` : 设置所绘制在饼图中心的文本大小。  
    ![20151222145819954][]![20151222145839177][]

chart.setCenterTextSize(150f);
            // 上面左图
            chart.setCenterTextRadiusPercent(1.0f);
            // 上面右图
            chart.setCenterTextRadiusPercent(3.0f);

*  `setUsePercentValues(boolean enabled)` : 如果被启用，在图表内的值绘制在百分之，而不是与它们的原始值。 规定的值ValueFormatter进行格式化，然后以百分比规定。
 *  `setDrawSliceText(boolean enabled)` : 设置为true，在扇区绘制x值。  
    ![20151222141949339][]![20151222141957982][]

ArrayList<String> xValues = new ArrayList<String>();
            xValues.add("第一季度");
            xValues.add("第二季度");
            xValues.add("第三季度");
            xValues.add("第四季度");
            PieData mPieChartData = new PieData(xValues, mPieDataSet);
            // 上面左图
            chart.setDrawSliceText(ture);
            // 上面右图
            chart.setDrawSliceText(false);

*  `setHoleRadius(float percent)` : 设置中心圆孔半径占整个饼状图半径的百分比（100f 是最大=整个图表的半径），默认的50％的百分比（即50f）。
 *  `setTransparentCircleRadius(float percent)` : 设置中心透明圈半径占整个饼状图半径的百分比，默认是 55％ 的半径 -> 大于默认是 50％ 的中心圆孔半径。
 *  `setTransparentCircleColor(int color)` : 设置透明圈的颜色。
 *  `setTransparentCircleAlpha(int alpha)` : 设置透明圈的透明度（0-255）。
 *  `setRotationAngle(float angle)` : 设置饼状图的旋转角度。默认是270f 。  
    ![默认是 270f][270f]![chart.setRotationAngle(0f);][chart.setRotationAngle_0f]
 *  设置文字、颜色  
    ![未设置][20151222140949788]![设置了文字，颜色][20151222141000736]

// 左图是未进行以下代码设置的默认效果图
    
            chart.setHoleRadius(50f);
            chart.setTransparentCircleRadius(50f);
            // 设置文字
            chart.setCenterText("MPChart\nAndroid");
            chart.setDescription("zhuanghongji");
    
            // 设置颜色
            chart.setCenterTextColor(Color.GREEN);
            chart.setHoleColor(Color.BLACK);
            chart.setHoleColorTransparent(false);
            chart.setBackgroundColor(Color.BLUE);
            chart.setDescriptionColor(Color.YELLOW);

*  注意：`HoleRadius` 和 `TransparentCircleRadius` 是独立不同的“中间的圆”的半径比，且`HoleRadius` 会覆盖 `TransparentCircleRadius`：  
    ![20151222140724681][]![20151222140735151][]

chart.setHoleColor(Color.BLACK);
            chart.setHoleColorTransparent(false);
            chart.setTransparentCircleColor(Color.RED);
            // 上面左图
            chart.setHoleRadius(30f);
            chart.setTransparentCircleRadius(50f);
            // 上面右图
            chart.setHoleRadius(70f);
            chart.setTransparentCircleRadius(50f);

## 三、雷达图 ##

*  `setSkipWebLineCount(int count)` : Allows to skip web lines coming from the center of the chart. Especially useful if there are a lot of lines.

## 0006 ##

## 概述 ##

本章将重点介绍各个图表类型特定的设置。

默认情况下，所有的图表类型都支持 `Legend` 且在设置图表数据后会自动生成 `Legend` 。  
`Legend` 通常由一个标签的 形式/形状 来表示多个条目( `entries` ) 的每一个。

`entries` 数量自动生成的 legend 取决于DataSet 的标签 不同颜色的数量（在所有 `DataSet` 的对象）。 `Legend` 的标签取决于图表中所使用的 `DataSet` 对象。 如果没有为 `DataSet` 对象指定标签，图表将自动生成它们。 如果多个颜色用于一个 `DataSet` ，这些颜色分类 ，只通过一个标签说明。

对于定制的 `Legend` ，可以通过图表对象的 `getLegend()` 方法先获取 `Legen` 在进行调用对应方法：

Legend legend = chart.getLegend();

*  1

## 二、是否绘制 Legend ##

*  `setEnabled(boolean enabled)` : 设置Legend启用或禁用。 如果禁用， `Legend` 将不会被绘制。  
    ![默认][20151222211746598]![Legend legend = chart.getLegend(); legend.setEnabled(false);][Legend legend _ chart.getLegend_ legend.setEnabled_false]

## 三、修改 Legend ##

*  `setTextColor(int color)` : 设置图例标签的颜色。
 *  `setTextSize(float size)` : 设置在DP传说标签的文字大小。  
    单位是”像素” min = 6f, max = 24f, default 10f  
    ![默认][20151222211746598]![legend.setTextColor(Color.GREEN);legend.setTextSize(24f);][legend.setTextColor_Color.GREEN_legend.setTextSize_24f]
 *  `setTypeface(Typeface tf)` : 设置自定义Typeface图例标签。

## 四、Wrapping / clipping avoidance ##

*  `setWordWrapEnabled(boolean enabled)` : 如果启用，Legend 的内容将不会超出图表边界之外，而是创建一个新的行。 请注意，这会降低性能和仅适用于”legend 位于图表下面”的情况。
 *  `setMaxSizePercent(float maxSize)` : 设置最大图例的百分比（相对整个图表大小）。 默认值：0.95f（95％）

## 五、自定义 Legend ##

*  `setPosition(LegendPosition pos)` : 通过 LegendPosition 设置 Legend 出现的位置。
    
     *  `RIGHT_OF_CHART`
     *  `RIGHT_OF_CHART_CENTER`
     *  `RIGHT_OF_CHART_INSIDE`
     *  `BELOW_CHART_LEFT`
     *  `BELOW_CHART_RIGHT`
     *  `BELOW_CHART_CENTER`
     *  `PIECHART_CENTER`（`PieChart独有`）等等。  
        ![RIGHT\_OF\_CHART][RIGHT_OF_CHART]![RIGHT\_OF\_CHART\_CENTER][RIGHT_OF_CHART_CENTER]  
        ![RIGHT\_OF\_CHART\_INSIDE][RIGHT_OF_CHART_INSIDE]![BELOW\_CHART\_LEFT][BELOW_CHART_LEFT]  
        ![BELOW\_CHART\_RIGHT][BELOW_CHART_RIGHT]![BELOW\_CHART\_CENTER][BELOW_CHART_CENTER]
 *  `setFormSize(float size)` : 设置 legend-forms 的大小，单位dp。
 *  `setForm(LegendForm shape)` : 设置 `LegendForm` 。This is the shape that is drawn next to the legend-labels with the color of the DataSet the legend-entry represents. 正方形，圆形或线。  
    ![SQUARE 正方形][SQUARE]![CIRCLE 圆形][CIRCLE]![LINE 线][LINE]

legend.setFormSize(18f);
            legend.setForm(Legend.LegendForm.SQUARE);
            legend.setForm(Legend.LegendForm.CIRCLE);
            legend.setForm(Legend.LegendForm.LINE);

*  `setXEntrySpace(float space)` : 设置在水平轴上 `legend-entries` 的间隙。
 *  `setYEntrySpace(float space)` : 设置在垂直轴上 `legend-entries` 的间隙。
 *  `setFormToTextSpace(float space)` : 设置 `legend-form` 和 `legend-label` 之间的空间。
 *  `setWordWrapEnabled(boolean enabled)` : 设置 Legend 是否自动换行？ 目前仅支持`BelowChartLeft`，`BelowChartRight`，`BelowChartCenter`。 / you may want to set maxSizePercent when word wrapping, to set the point where the text wraps.

## 六、设置自定义标签和颜色 ##

*  `setCustom(int[] colors, String[] labels)` : 设置 `自定义Legend` 的标签和颜色。 颜色数应该匹配标签数，并且相对应。A null label will start a group. A (-2) color will avoid drawing a form This will disable the feature that automatically calculates the legend labels and colors from the datasets. 调用 `resetCustom()` 重新启用自动计算（and then notifyDataSetChanged() is needed to auto-calculate the legend again）。
 *  `resetCustom()` : 调用此将禁用通过 `setCustom(...)`方法自定义的图例标签。在 `notifyDataSetChanged()` 被调用后，标签将再次被自动计算。
 *  `setExtra(int[] colors, String[] labels)` : Sets colors and labels that will be appended to the end of the auto calculated colors and labels arrays after calculating the legend. (if the legend has already been calculated, you will need to call `notifyDataSetChanged()` to let the changes take effect)

## 七、代码范例 ##

Legend l = chart.getLegend();
        l.setFormSize(10f); // set the size of the legend forms/shapes
        l.setForm(LegendForm.CIRCLE); // set what type of form/shape should be used
        l.setPosition(LegendPosition.BELOW_CHART_LEFT);
        l.setTypeface(...);
        l.setTextSize(12f);
        l.setTextColor(Color.BLACK);
        l.setXEntrySpace(5f); // set the space between the legend entries on the x-axis
        l.setYEntrySpace(5f); // set the space between the legend entries on the y-axis
    
        // set custom labels and colors
        l.setCustom(ColorTemplate.VORDIPLOM_COLORS, 
                new String[] { "Set1", "Set2", "Set3", "Set4", "Set5" });
    
        // and many more...

0007

在 MPAndroidChart `1.6.3` 版本得以实现，在更新版本不断得到提高。

存在各种方法为图表动态地 **增加新的数据** 或 **移除数据**

*  允许添加或删除 `Entry` 对象到现有的 `DataSet` 。
 *  允许添加或删除 `Entry` 对象到已存在的 `ChartData` 的`DataSet` 。

## 二、动态添加数据 ##

### DataSet 类和所有子类： ###

*  `addEntry(Entry e)` : 添加的 `Entry` 对象到 `DataSet` 。

### ChartData 类和所有子类： ###

*  `addEntry(Entry e, int dataSetIndex)` : 添加 `Entry` 到 `DataSet` 的指定索引处。
 *  `addDataSet(DataSet d)` : 添加 `DataSet` 对象到 `ChartData` 。  
    除此之外，也有用于动态remove数据的方法。

## 二、动态移除数据 ##

### DataSet 类和所有子类： ###

*  `public boolean removeFirst()` : 删除该 `DataSet` 的第一个 `Entry` 项( 索引0 )。 如果成功返回true，否则为false。
 *  `public boolean removeLast()` : 删除该 `DataSet` 的最后一个 `Entry` 项( 索引大小-1 )。 如果成功返回true，否则为false。
 *  `public boolean removeEntry(Entry e)` : 从 `DataSet` 中移除给定的 `Entry` 对象 。 如果成功返回true 。
 *  `public boolean removeEntry(int xIndex)` : 从 `DataSet` 中移除给定索引对应的 `Entry` 对象 。 如果成功返回true 。

### ChartData 类和所有子类： ###

*  `public boolean removeEntry(Entry e, int dataSetIndex)` : 移除给定索引对应的 `DataSet` 中给定的 `Entry` 对象。如果成功，返回true。
 *  `public boolean removeEntry(int xIndex, int dataSetIndex)` : 移除给定索引对应的 `DataSet` 中给定索引对应的 `Entry` 对象。如果成功，返回true。
 *  `public boolean removeDataSet(DataSet d)` : 从该 `ChartData` 对象中移除给定的 `DataSet` 对象。如果成功，返回true。
 *  `public boolean removeDataSet(int index)` : 从该 `ChartData` 对象中移除给定索引对应的 `DataSet` 对象。如果成功，返回true。

## 三、记住 ##

动态添加或移除数据后， 调用`invalidate()`刷新图表之前 **必须调用** `notifyDataSetChanged()` .

// more code ...
     exampleData.addEntry(...);
     chart.notifyDataSetChanged(); // let the chart know it's data changed
     chart.invalidate(); // refresh

> 注 ： `moveViewTo(...)` 方法会自动调用 `invalidate()`

## 四、DynamicalAddingActivity.java ##

下面有6个演示动态添加(删除)数据的小例子：

*  `addEntry()` , `removeLastEntry()` , `addDataSet()` ,
 *  `removeLastDataSet()` , `clearChart()` 和 `setEmptyLineData()` .

[点击查看 DynamicalAddingActivity.java 源码][DynamicalAddingActivity.java]

### 1. addEntry() ###

为最后一个 `DataSet` 添加一个y值随机的 `Entry`，一开始如果没有 `DataSet` 则新增一个 `DataSet` .  
1) 效果图：  
![addEntry()][addEntry]  
2) 对应代码如下：

public void addEntry(View view) {
            LineData lineData = mChart.getData();
    
            if (lineData != null) {
                int indexLast = getLastDataSetIndex(lineData);
                LineDataSet lastSet = lineData.getDataSetByIndex(indexLast);
                // set.addEntry(...); // can be called as well
    
                if (lastSet == null) {
                    lastSet = createLineDataSet();
                    lineData.addDataSet(lastSet);
                }
                // 这里要注意，x轴的index是从零开始的
                // 假设index=2，那么getEntryCount()就等于3了
                int count = lastSet.getEntryCount();
                // add a new x-value first 这行代码不能少
                lineData.addXValue(count + "");
    
                float yValues = (float) (Math.random() * 100);
                // 位最后一个DataSet添加entry
                lineData.addEntry(new Entry(yValues, count), indexLast);
    
                mChart.notifyDataSetChanged();
                mChart.moveViewTo(yValues, count, YAxis.AxisDependency.LEFT);
    
                Log.d(TAG, "set.getEntryCount()=" + lastSet.getEntryCount()
                        + " ; indexLastDataSet=" + indexLast);
    
            }
        }

### 2. removeLastEntry() ###

移除最后一个 `DataSet` 的最后一个 `Entry` 。在效果图中你会发现，即使没有 `Entry` 了，继续点击”removeLastEntry”按钮程序也不会crash掉。  
1) 效果图：  
![removeLastEntry()][removeLastEntry]  
2) 对应代码如下：

public void removeLastEntry(View view) {
            LineData lineData = mChart.getLineData();
            if (lineData != null) {
                int indexLastDataSet = lineData.getDataSetCount() - 1;
                LineDataSet lastDataSet = lineData.getDataSetByIndex(indexLastDataSet);
                if (lastDataSet != null) {
                    Entry lastEntry = lastDataSet.getEntryForXIndex(
                            lastDataSet.getEntryCount() - 1);
                    lineData.removeEntry(lastEntry, indexLastDataSet);
                    // or remove by index
                    // mData.removeEntry(xIndex, dataSetIndex);
    
                    mChart.notifyDataSetChanged();
                    mChart.invalidate();
                }
            }
        }

### 3. addDataSet() ###

**动态添加一个 `DataSet`，可以添加N多个 `DataSet` ，没发现有上限**。  
下面的效果图同时也演示了前面的 **为最后一个 `DataSet` 添加一个y值随机的 `Entry`** 和 **移除最后一个 `DataSet` 的最后一个 `Entry`** 。  
1) 效果图：  
![20151224181331155][]  
2) 对应代码如下：

public void addDataSet(View view) {
            LineData lineData = mChart.getLineData();
            if (lineData != null) {
                int count = (lineData.getDataSetCount() + 1);
                // create 10 y-value
                ArrayList<Entry> yValueList = new ArrayList<>();
                if (lineData.getXValCount() == 0) {
                    for (int i = 0; i < 10; i++) {
                        lineData.addXValue((i + 1) + "");
                    }
                }
    
                for (int i = 0; i < lineData.getXValCount(); i++) {
                    yValueList.add(new Entry((float) (Math.random() * 100f), i));
                }
    
                LineDataSet set = new LineDataSet(yValueList, "DataSet " + count);
                // 求余，防止数组越界异常
                int colorIndex = count % mColors.length;
                set.setColor(mColors[colorIndex]);
                set.setCircleColor(mColors[colorIndex]);
                set.setValueTextColor(mColors[colorIndex]);
    
                lineData.addDataSet(set);
                mChart.notifyDataSetChanged();
                mChart.invalidate();
            }
        }

### 4. removeLastDataSet() ###

**移除最后一个DataSet** 。  
在效果图中你会发现，即使没有 `DataSet` 了，继续点击”removeLastDataSet”程序也不会crash掉。  
1) 效果图：  
![20151224181818057][]  
2) 对应代码如下：

public void removeLastDataSet(View view) {
            LineData lineData = mChart.getData();
            if (lineData != null) {
                lineData.removeDataSet(lineData.getDataSetCount() - 1);
                mChart.notifyDataSetChanged();
                mChart.invalidate();
            }
        }

### 5. clearChart() 和 setEmptyLineData() ###

**清空图表** 和 **为图表设置一个空的LineData**.  
在效果图中你会发现，`clearChart()` 后，点击”addDataSet”图表并没有新增 `DataSet` 的响应，clear 后要 `setEmptyLineData()` 才能 `addDataSet()`。  
1) 效果图：  
![20151224182210380][]  
2) 对应代码如下：

// 清空图表
        public void clearChart(View view) {
            mChart.clear();
        }

// 为图表设置一个空的LineData
        public void setEmptyLineData(View view) {
            mChart.setData(new LineData());
            mChart.invalidate();
        }

*  RealtimeDataActivity

0008

概述

MPAndroidChart 图表具有多种不同的方法来修改视窗（图表上那些是可见的，以及 aim of the view）。 注意，这些方法仅适用于 `LineChart` , `BarChart` , `ScatterChart` 和 `CandleStickChart` .

> 请注意， 修改视口的所有方法需要在 **为Chart 设置数据之后** 调用 。

## 二、什么是可见的 ##

*  `setVisibleXRangeMinimum(float minXRange)` : 设定x轴最大可见区域范围的大小。如果设置为17，则不可能进一步放大视图（在x轴超过17的值）。  
    ![默认][20151223131934423]![chart.setVisibleXRangeMinimum(17);][chart.setVisibleXRangeMinimum_17]

// 上面左图不做任何处理
        // 上面右图：
        chart.setVisibleXRangeMinimum(17);

*  `setVisibleXRangeMaximum(float maxXRange)` : 设定x轴最大可见区域范围的大小。 如果设定为3，则在x轴超过3的值被视为不可见（不滑动 chart 的话）。  
    ![20151223131945600][]![20151223132619951][]

chart.setVisibleXRangeMaximum(3); // 效果如上面左图
    
        // 这时你会发现可以移动 chart 了
        // 手指稍微左滑下效果图如上面右图

*  `setVisibleYRangeMaximum(float maxYRange, AxisDependency axis)` : 设定y轴最大可见区域范围的大小。 您还需要提供要对应的轴（`YAxis.AxisDependency.LEFT` 或 `YAxis.AxisDependency.RIGHT` )  
    ![chart.setVisibleYRangeMaximum(50f,YAxis.AxisDependency.LEFT);][chart.setVisibleYRangeMaximum_50f_YAxis.AxisDependency.LEFT]![chart.setVisibleYRangeMaximum(70f,YAxis.AxisDependency.LEFT);][chart.setVisibleYRangeMaximum_70f_YAxis.AxisDependency.LEFT]

// 上面左效果图对应代码
        chart.setVisibleYRangeMaximum(50f,YAxis.AxisDependency.LEFT);
    
        // 上面右效果图对应代码
        chart.setVisibleYRangeMaximum(70f,YAxis.AxisDependency.LEFT);

*  `setViewPortOffsets(float left, float top, float right, float bottom)` : 设置当前视图的偏移量（实际图表窗口的两侧偏移量）。 设置这个，将阻止图表自动计算它的偏移量。  
    使用 `resetViewPortOffsets()` 撤消此设置。  
    ![图1: chart.setViewPortOffsets(50,0,0,0);][1_ chart.setViewPortOffsets_50_0_0_0]![图2: chart.setViewPortOffsets(0,50,0,0);][2_ chart.setViewPortOffsets_0_50_0_0]  
    ![图3: chart.setViewPortOffsets(50,50,0,0);][3_ chart.setViewPortOffsets_50_50_0_0]![图4: chart.setViewPortOffsets(50,50,50,50);][4_ chart.setViewPortOffsets_50_50_50_50]

chart.setViewPortOffsets(50,0,0,0);     // 图1
        chart.setViewPortOffsets(0,50,0,0);     // 图2
        chart.setViewPortOffsets(50,50,0,0);    // 图3
        chart.setViewPortOffsets(50,50,50,50);  // 图4

*  `resetViewPortOffsets()` : 撤销所有通过 `setViewPortOffsets(...)` 方法设置的偏移量 。 允许图表再次自动计算所有偏移。
 *  `setExtraOffsets(float left, float top, float right, float bottom)` : 设置额外的偏移，将被添加到自动计算的偏移。 这不会改变自动计算的偏移量，但增加了额外的空间给它们。

## 三、移动视图 （它的目的） ##

*  `fitScreen()` : 重设所有缩放和拖动，使图表完全适合它的边界（完全缩小）。
 *  `moveViewToX(float xIndex)` : 将当前视口的左侧（边）到指定的 x 值。  
    ![chart.moveViewToX(2);][chart.moveViewToX_2]![chart.moveViewToX(5);][chart.moveViewToX_5]

chart.setVisibleXRangeMaximum(3);
    
        chart.moveViewToX(2);  // 上面左效果图,Mar是三月
        chart.moveViewToX(5);  // 上面右效果图,Jun是六月

*  `moveViewToY(float yValue, AxisDependency axis)` : 使得指定的y值显示在对应y轴( 左or右 )的中间。  
    ![chart.moveViewToY(40,YAxis.AxisDependency.LEFT);][chart.moveViewToY_40_YAxis.AxisDependency.LEFT]![chart.moveViewToY(60,YAxis.AxisDependency.LEFT);][chart.moveViewToY_60_YAxis.AxisDependency.LEFT]

YAxis leftAxis = chart.getAxisLeft();
        leftAxis.setTextSize(18f);
        chart.setVisibleYRangeMaximum(50f,YAxis.AxisDependency.LEFT);
    
        chart.moveViewToY(40,YAxis.AxisDependency.LEFT); // 上面左效果图
        chart.moveViewToY(40,YAxis.AxisDependency.LEFT); // 上面右效果图

*  `moveViewTo(float xIndex, float yValue, AxisDependency axis)` : 相当于`setVisibleXRange(...)` 和 `setVisibleYRange(...)` 组合使用。
 *  `centerViewTo(int xIndex, float yValue, AxisDependency axis)` : 相当于 `setVisibleXRange(...)` 和 `setVisibleYRange(...)` 组合使用。

注：所有 `moveViewTo(...)` 方法会自动 `invalidate()` 刷新图表。 没有必要进行进一步调用 `invalidate()` 。

## 四、变焦 （编程） ##

*  `zoomIn()` : Zooms in by 1.4f, into the charts center.
 *  `zoomOut()` : Zooms out by 0.7f, from the charts center.
 *  `zoom(float scaleX, float scaleY, float x, float y)` : 根据所给的参数进行放大或缩小。 参数 `x` 和 `y` 是变焦中心的坐标（单位：像素）。 记住，**1f = 无放缩** 。

## 五、完整示例 ##

chart.setData(...); // first set data
    
        // now modify viewport
        // allow 20 values to be displayed at 
        once on the x-axis, not more
        chart.setVisibleXRangeMaximum(20); 
        // set the left edge of the chart to x-index 10
        chart.moveViewToX(10); 
    
        // moveViewToX(...) also calls invalidate()

0009

效果图

### 1) LineChart 效果图 ###

![animateX(8000); // 图1][animateX_8000_ _ _1]![animateY(8000); // 图2][animateY_8000_ _ _2]  
![animateXY(8000, 8000); // 图3][animateXY_8000_ 8000_ _ _3]![animateY(8000, Easing.EasingOption.EaseInElastic ); // 图4][animateY_8000_ Easing.EasingOption.EaseInElastic _ _ _4]

// 设置动画
        chart.animateX(8000); // 图1
        chart.animateY(8000); // 图2
        chart.animateXY(8000, 8000); // 图3
        chart.animateY(8000, Easing.EasingOption.EaseInElastic ); // 图4

### 2) BarChart 效果图 ###

![animateX(8000); // 图1][animateX_8000_ _ _1 1]![animateY(8000); // 图2][animateY_8000_ _ _2 1]  
![animateXY(8000, 8000); // 图3][animateXY_8000_ 8000_ _ _3 1]![animateY(8000, Easing.EasingOption.EaseInSine); // 图4][animateY_8000_ Easing.EasingOption.EaseInSine_ _ _4]

// 设置动画
        chart.animateX(8000); // 图1
        chart.animateY(8000); // 图2
        chart.animateXY(8000, 8000); // 图3
        chart.animateY(8000, Easing.EasingOption.EaseInSine); // 图4

### 3) PieChart 效果图 ###

![animateX(8000); // 图1][animateX_8000_ _ _1 2]![animateY(8000); // 图2][animateY_8000_ _ _2 2]  
![animateXY(8000,8000); // 图3][animateXY_8000_8000_ _ _3]![animateY(8000, Easing.EasingOption.EaseOutBounce); // 图4][animateY_8000_ Easing.EasingOption.EaseOutBounce_ _ _4]

// 设置动画
        chart.animateX(8000); // 图1
        chart.animateY(8000); // 图2
        chart.animateXY(8000,8000); // 图3
        chart.animateY(8000, Easing.EasingOption.EaseOutBounce); // 图4

## 二、概述 ##

MPAndroidChart 的动画机制只在Android `API 11 (Android 3.0.x)` 和以上有效。  
在低于 **Android 3.0.x** 的版本中动画不会执行（但不会引起 crash）。

所有图表类型都支持动画,可以用来创建/建立图表在一个很棒的方法。三种不同的动画方法存在,动画,或者x轴和y轴分别:

*  `animateX(int durationMillis)` : 水平轴的图表值动画，这意味着在指定的时间内从左到右 **建立图表**。
 *  `animateY(int durationMillis)` : 垂直轴的图表值动画，这意味着在指定的时间内从下到上 **建立图表**。
 *  `animateXY(int xDuration, int yDuration)` : 两个轴的图表值动画，从左到右，从下到上 **建立图表**。

mChart.animateX(3000); // animate horizontal 3000 milliseconds
        // or:
        mChart.animateY(3000); // animate vertical 3000 milliseconds
        // or:
        mChart.animateXY(3000, 3000); // animate horizontal and vertical 3000 milliseconds

任意一种 `animate(...)` 动画方法被调用后，无需再调用 `invalidate()` 方法。

## 三、ChartAnimator 动画源码分析 ##

/** * Object responsible for all animations in the Chart. ANIMATIONS ONLY WORK FOR * API LEVEL 11 (Android 3.0.x) AND HIGHER. */
    @SuppressLint("NewApi")
    public class ChartAnimator { 
    
        /** object that is updated upon animation update */
        private AnimatorUpdateListener mListener;
    
        public ChartAnimator() {}
    
        public ChartAnimator(AnimatorUpdateListener listener) {
            mListener = listener;
        }
    
        /** the phase that is animated and influences the drawn values on the y-axis */
        protected float mPhaseY = 1f;
    
        /** the phase that is animated and influences the drawn values on the x-axis */
        protected float mPhaseX = 1f;
    
        // 下面的动画方法
    }

### 1) animateX( … ) 方法的源码 ###

/** * Animates the rendering of the chart on the x-axis with the specified * animation time. If animate(...) is called, no further calling of * invalidate() is necessary to refresh the chart. * * @param durationMillis */
        public void animateX(int durationMillis) {
    
            if (android.os.Build.VERSION.SDK_INT < 11)
                return;
    
            ObjectAnimator animatorX = ObjectAnimator.ofFloat(this, "phaseX", 0f, 1f);
            animatorX.setDuration(durationMillis);
            animatorX.addUpdateListener(mListener);
            animatorX.start();
        }
    
        public void animateX(int durationMillis, Easing.EasingOption easing) {
    
            if (android.os.Build.VERSION.SDK_INT < 11)
                return;
    
            ObjectAnimator animatorX = ObjectAnimator.ofFloat(this, "phaseX", 0f, 1f);
            animatorX.setInterpolator(Easing.getEasingFunctionFromOption(easing));
            animatorX.setDuration(durationMillis);
            animatorX.addUpdateListener(mListener);
            animatorX.start();
        }
    
    
        public void animateX(int durationMillis, EasingFunction easing) {
    
            if (android.os.Build.VERSION.SDK_INT < 11)
                return;
    
            ObjectAnimator animatorX = ObjectAnimator.ofFloat(this, "phaseX", 0f, 1f);
            animatorX.setInterpolator(easing);
            animatorX.setDuration(durationMillis);
            animatorX.addUpdateListener(mListener);
            animatorX.start();
        }

### 2) animateY( … ) 方法的源码 ###

/** * Animates the rendering of the chart on the y-axis with the specified * animation time. If animate(...) is called, no further calling of * invalidate() is necessary to refresh the chart. * * @param durationMillis */
        public void animateY(int durationMillis) {
    
            if (android.os.Build.VERSION.SDK_INT < 11)
                return;
    
            ObjectAnimator animatorY = ObjectAnimator.ofFloat(this, "phaseY", 0f, 1f);
            animatorY.setDuration(durationMillis);
            animatorY.addUpdateListener(mListener);
            animatorY.start();
        }
    
        public void animateY(int durationMillis, Easing.EasingOption easing) {
    
            if (android.os.Build.VERSION.SDK_INT < 11)
                return;
    
            ObjectAnimator animatorY = ObjectAnimator.ofFloat(this, "phaseY", 0f, 1f);
            animatorY.setInterpolator(Easing.getEasingFunctionFromOption(easing));
            animatorY.setDuration(durationMillis);
            animatorY.addUpdateListener(mListener);
            animatorY.start();
        }
    
        public void animateY(int durationMillis, EasingFunction easing) {
    
            if (android.os.Build.VERSION.SDK_INT < 11)
                return;
    
            ObjectAnimator animatorY = ObjectAnimator.ofFloat(this, "phaseY", 0f, 1f);
            animatorY.setInterpolator(easing);
            animatorY.setDuration(durationMillis);
            animatorY.addUpdateListener(mListener);
            animatorY.start();
        }

### 3) animateXY( … ) 方法的源码 ###

/** * Animates the drawing / rendering of the chart on both x- and y-axis with * the specified animation time. If animate(...) is called, no further * calling of invalidate() is necessary to refresh the chart. * * @param durationMillisX * @param durationMillisY */
        public void animateXY(int durationMillisX, int durationMillisY) {
    
            if (android.os.Build.VERSION.SDK_INT < 11)
                return;
    
            ObjectAnimator animatorY = ObjectAnimator.ofFloat(this, "phaseY", 0f, 1f);
            animatorY.setDuration(
                    durationMillisY);
            ObjectAnimator animatorX = ObjectAnimator.ofFloat(this, "phaseX", 0f, 1f);
            animatorX.setDuration(
                    durationMillisX);
    
            // make sure only one animator produces update-callbacks (which then
            // call invalidate())
            if (durationMillisX > durationMillisY) {
                animatorX.addUpdateListener(mListener);
            } else {
                animatorY.addUpdateListener(mListener);
            }
    
            animatorX.start();
            animatorY.start();
        }
    
        public void animateXY(int durationMillisX, int durationMillisY, Easing.EasingOption easingX,
                Easing.EasingOption easingY) {
    
            if (android.os.Build.VERSION.SDK_INT < 11)
                return;
    
            ObjectAnimator animatorY = ObjectAnimator.ofFloat(this, "phaseY", 0f, 1f);
            animatorY.setInterpolator(Easing.getEasingFunctionFromOption(easingY));
            animatorY.setDuration(
                    durationMillisY);
            ObjectAnimator animatorX = ObjectAnimator.ofFloat(this, "phaseX", 0f, 1f);
            animatorX.setInterpolator(Easing.getEasingFunctionFromOption(easingX));
            animatorX.setDuration(
                    durationMillisX);
    
            // make sure only one animator produces update-callbacks (which then
            // call invalidate())
            if (durationMillisX > durationMillisY) {
                animatorX.addUpdateListener(mListener);
            } else {
                animatorY.addUpdateListener(mListener);
            }
    
            animatorX.start();
            animatorY.start();
        }
    
        public void animateXY(int durationMillisX, int durationMillisY, EasingFunction easingX,
                EasingFunction easingY) {
    
            if (android.os.Build.VERSION.SDK_INT < 11)
                return;
    
            ObjectAnimator animatorY = ObjectAnimator.ofFloat(this, "phaseY", 0f, 1f);
            animatorY.setInterpolator(easingY);
            animatorY.setDuration(
                    durationMillisY);
            ObjectAnimator animatorX = ObjectAnimator.ofFloat(this, "phaseX", 0f, 1f);
            animatorX.setInterpolator(easingX);
            animatorX.setDuration(
                    durationMillisX);
    
            // make sure only one animator produces update-callbacks (which then
            // call invalidate())
            if (durationMillisX > durationMillisY) {
                animatorX.addUpdateListener(mListener);
            } else {
                animatorY.addUpdateListener(mListener);
            }
    
            animatorX.start();
            animatorY.start();
        }

## 四、缓动动画 (Animation easing) ##

这个库可以让你对动画应用”缓动函数”。  
您可以选择以下预定义的静态 `Easing.EasingOption` :

public enum EasingOption {
          Linear,
          EaseInQuad,
          EaseOutQuad,
          EaseInOutQuad,
          EaseInCubic,
          EaseOutCubic,
          EaseInOutCubic,
          EaseInQuart,
          EaseOutQuart,
          EaseInOutQuart,
          EaseInSine,
          EaseOutSine,
          EaseInOutSine,
          EaseInExpo,
          EaseOutExpo,
          EaseInOutExpo,
          EaseInCirc,
          EaseOutCirc,
          EaseInOutCirc,
          EaseInElastic,
          EaseOutElastic,
          EaseInOutElastic,
          EaseInBack,
          EaseOutBack,
          EaseInOutBack,
          EaseInBounce,
          EaseOutBounce,
          EaseInOutBounce,
      }

基本上，有以下两种方式进行 easing 你的动画。

1) 预定义的缓动选项：（下面代码可在所有 Android 版本运行）

public void animateY(int durationmillis, Easing.EasingOption option);

*  1

*  例如，调用带有预定义缓动选项的动画方法

// animate both axes with easing
        mChart.animateY(3000, Easing.EasingOption.EaseOutBack);

*  当你想代码运行在 Android 3.0 (API 11) 以下时0，总是使用 `Easing.EasingOption` 。

2) 自定义缓动函数（在 Android 3.0 自定义缓动函数会使应用 crash）：

public void animateY(int durationmillis, EasingFunction function);

*  **Create your own** easing functions by creating your own easing-function class and implementing the `EasingFunction` interface :

/** * Interface for creating custom made easing functions. */
      public interface EasingFunction { 
         /** * Called everytime the animation is updated. * @param input - the time passed since the animation started (value between 0 and 1) */
          public float getInterpolation(float input);
      }

*  Then call it this way ( **be aware, this will not run below Android 3.0 and crash** ) :

// animate both axes with easing
        mChart.animateY(3000, new MyEasingFunction());

## 五、Easing.EasingOption 所有效果图 ##

### 1,2) Linear , EaseInQuad ###

![Linear][]![EaseInQuad][]

### 3,4) EaseOutQuad , EaseInOutQuad ###

![EaseOutQuad][]![EaseInOutQuad][]

### 5,6) EaseInCubic , EaseOutCubic ###

![EaseInCubic][]![EaseOutCubic][]

### 7,8) EaseInOutCubic , EaseInQuart ###

![EaseInOutCubic][]![EaseInQuart][]

### 9,10) EaseOutQuart , EaseInOutQuart ###

![EaseOutQuart][]![EaseInOutQuart][]

### 11,12) EaseInSine , EaseOutSine ###

![EaseInSine][]![EaseOutSine][]

### 13,14) EaseInOutSine , EaseInExpo ###

![EaseInOutSine][]![EaseInExpo][]

### 15,16) EaseOutExpo , EaseInOutExpo ###

![EaseOutExpo][]![EaseInOutExpo][]

### 17,18) EaseInCirc , EaseOutCirc ###

![EaseInCirc][]![EaseOutCirc][]

### 19,20) EaseInOutCirc , EaseInElastic ###

![EaseInOutCirc][]![EaseInElastic][]

### 21,22) EaseOutElastic , EaseInOutElastic ###

![EaseOutElastic][]![EaseInOutElastic][]

### 23,24) EaseInBack , EaseOutBack ###

![EaseInBack][]![EaseOutBack][]

### 25,26) EaseInOutBack , EaseInBounce ###

![EaseInOutBack][]![EaseInBounce][]

### 27,28) EaseOutBounce , EaseInOutBounce ###

![EaseOutBounce][]![EaseInOutBounce][]

0010

什么是MarkerView

首先来看 `MarkerView` 的效果图：  
![20151229221538935][]![20151229221521125][]

如上图所示，当点击折线图上的点时，会弹出一个View，这就是 `Markerview` 。

*  上面的左图是一个 `TextView` 布局和一个椭圆黑色的 `background`
 *  右图是一个 `TextView` 布局和一个 `bitmap` 的 `background`

那么这具体是如何实现的呢？

## 二、MakerView 抽象类 ##

### 1. 简介 ###

为显示自定义的（弹出的）扩展View并且使得点击的点的值在图表中突出显示，我们可以创建一个类并继承`MakerView` 抽象类，然后实现该类的构造方法和继承自 `MarkerView` 类的抽象方法 。

// extend MarkerView
        public class YourCustomMarkerView extends MarkerView {  ...

*  `MarkerView` 类继承自 `RelativeLayout` 。

### 2. MarkerView 类源码： ###

/** * View that can be displayed when selecting values in the chart. * Extend this class to provide custom layouts for your markers. */
    public abstract class MarkerView extends RelativeLayout { 
    
        /** * Constructor. Sets up the MarkerView with a custom layout resource. * * @param context * @param layoutResource the layout resource to use for the MarkerView */
        public MarkerView(Context context, int layoutResource) {
            super(context);
            setupLayoutResource(layoutResource);
        }
    
        /** * Sets the layout resource for a custom MarkerView. * * @param layoutResource */
        private void setupLayoutResource(int layoutResource) {
    
            View inflated = LayoutInflater.from(getContext())
                .inflate(layoutResource, this);
    
            inflated.setLayoutParams(
                new LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT, 
                RelativeLayout.LayoutParams.WRAP_CONTENT));
    
            inflated.measure(MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED), 
                    MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
    
            // measure(getWidth(), getHeight());
            inflated.layout(0, 0, inflated.getMeasuredWidth(), 
                inflated.getMeasuredHeight());
        }
    
        /** * Draws the MarkerView on the given position on the screen * with the given Canvas object. * * @param canvas * @param posx * @param posy */
        public void draw(Canvas canvas, float posx, float posy) {
    
            // take offsets into consideration
            posx += getXOffset(posx);
            posy += getYOffset(posy);
    
            // translate to the correct position and draw
            canvas.translate(posx, posy);
            draw(canvas);
            canvas.translate(-posx, -posy);
        }
    
        /** * This method enables a specified custom MarkerView to * update it's content everytime the MarkerView is redrawn. * * @param e The Entry the MarkerView belongs to. This can * also be any subclass of Entry, like BarEntry or CandleEntry, * simply cast it at runtime. * @param highlight The highlight object contains information * about the highlighted value such as it's dataset-index, the * selected range or stack-index (only stacked bar entries). */
        public abstract void refreshContent(Entry e, Highlight highlight);
    
        /** * Use this to return the desired offset you wish the MarkerView * to have on the x-axis. By returning -(getWidth() / * 2) you will center the MarkerView horizontally. * * @param xpos the position on the x-axis in pixels where the marker is drawn * @return */
        public abstract int getXOffset(float xpos);
    
        /** * Use this to return the desired position offset you wish the MarkerView * to have on the y-axis. By returning * -getHeight() you will cause the MarkerView to be above the selected value. * * @param ypos the position on the y-axis in pixels where the marker is drawn * @return */
        public abstract int getYOffset(float ypos);
    }

### 3. 设置/获取 MarkerView 的方法 ###

*  `setMarkerView(MarkerView mv)` : 为 `chart` 设置一个 `MarkerView` 从而显示选中的值。
 *  `getMarkerView()` : 获取 `chart` 已经设置了的 `MarkerView` ，未设置的话返回 `null` 。

## 三、实现步骤 ##

后面你可以找到一个实现自定义 `MarkerView` 类的例子。 重要的是，在这个过程中要实现以下从 `MarkerView` 抽象类继承来的方法：

*  `refreshContent(Entry e, Highlight highlight)` : 每次 `MarkerView` 重绘此方法都会被调用，并为您提供更新它显示的内容的机会（例如，为一个 `TextView` 设置文本 ，…）。 它提供了当前突出显示的 `Entry` 和相应的Highlight对象以获得更多信息。
 *  `getXOffset(float xpos)` : 在这里，应返回要绘制的 `MarkerView` 在x轴的偏移位置。 默认情况下，`MarkerView` 的左上边缘处将绘制在 `entry` 的位置。 在 `xpos` 参数表示绘制 `MarkerView` 的默认位置。
 *  `getYOffset(float ypos)` : 在这里，应返回要绘制的 `MarkerView` 在y轴的偏移位置。 默认情况下，`MarkerView` 的左上边缘处将绘制在 `entry` 的位置。 在 `ypos` 参数表示绘制`MarkerView` 的默认位置。

实现自定义 `MarkerView` 类的例子：

public class CustomMarkerView extends MarkerView { 
    
        private TextView tvContent;
    
        public CustomMarkerView (Context context, int layoutResource) {
            super(context, layoutResource);
            // this markerview only displays a textview
            tvContent = (TextView) findViewById(R.id.tvContent);
        }
    
        // callbacks everytime the MarkerView is redrawn, can be used to update the
        // content (user-interface)
        @Override
        public void refreshContent(Entry e, Highlight highlight) {
            tvContent.setText("" + e.getVal()); // set the entry-value as the display text
        }
    
        @Override
        public int getXOffset(float xpos) {
            // this will center the marker-view horizontally
            return -(getWidth() / 2);
        }
    
        @Override
        public int getYOffset(float ypos) {
            // this will cause the marker-view to be above the selected value
            return -getHeight();
        }
    }

*  实现自定义的 `MarkerView` 类后，需要创建一个 `.xml` 文件来作为 `MarkerView` 的布局。 本实例的布局仅是一个有背景图的且内含一个`TextView` 的 `RelativeLayout` ，但 **你可以创建任何你想要在这里显示的布局**。

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="wrap_content" android:layout_height="40dp" android:background="@drawable/markerImage" >
    
        <TextView android:id="@+id/tvContent" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerHorizontal="true" android:text="" android:textSize="12dp" android:textColor="@android:color/white" android:ellipsize="end" android:singleLine="true" android:textAppearance="?android:attr/textAppearanceSmall" />
    
    </RelativeLayout>

*  最后，为图表设置你已经创建了的自定义 `MarkerView`。 创建 `MarkerView` 时请确保你创建的 `.xml` 文件提供了对应的 `layout` 资源。

CustomMarkerView mv = new CustomMarkerView(Context, 
            R.layout.custom_marker_view_layout);
    
        // set the marker to the chart
        chart.setMarkerView(mv);

## 四、 随手写的一个样例 ##

### 1. 动态效果图 ###

![20151230130135728][]

### 2. 主要代码 ###

#### 1) 背景图 bg\_marker.xml ####

<?xml version="1.0" encoding="utf-8"?>
    <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="oval">
        <solid android:color="@android:color/black"/>
    </shape>

#### 2) 布局代码 content\_marker\_view.xml ####

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="72dp" android:layout_height="48dp" android:background="@drawable/bg_marker" android:gravity="center" android:orientation="vertical">
    
        <TextView android:id="@+id/tv_content_marker_view" android:layout_width="wrap_content" android:layout_height="wrap_content" android:padding="4dp" android:textAppearance="?android:attr/textAppearanceSmall" android:textColor="@android:color/white" android:textSize="18sp"/>
    </RelativeLayout>

#### 3) 自定义的 MyMarkerView.java ####

public class MyMarkerView extends MarkerView { 
        private TextView mContentTv;
    
        public MyMarkerView(Context context, int layoutResource) {
            super(context, layoutResource);
            mContentTv = (TextView) findViewById(R.id.tv_content_marker_view);
        }
    
        @Override
        public void refreshContent(Entry e, Highlight highlight) {
            mContentTv.setText("" + e.getVal());
        }
    
        @Override
        public int getXOffset(float xpos) {
            return -(getWidth() / 2);
        }
    
        @Override
        public int getYOffset(float ypos) {
            return -getHeight();
        }
    }

#### 4) 为图表设置 MarkerView ####

// 设置MarkerView
        MarkerView mv = new MyMarkerView(this,R.layout.content_marker_view);
        chart.setMarkerView(mv);

0011

ChartData 类

为了让大家更容易理解，这里先简单介绍下 `MPAndroidChart` 的数据模型 `ChartData` 。后面有文章再详细介绍该图标库的其它数据类型。

`ChartData` 类是所有数据类的基类，比如 `LineData`，`BarData` 等，它是用来为 `Chart` 提供数据的，通过 `setData(ChartData data){...}` 方法。

public class LineData extends ChartData {  ...

以下提到的方法是在 `ChartData` 类中被实现，因此可用于所有子类。

### 1. Styling data ###

*  `setValueFormatter(ValueFormatter f)` : 为`DataSets` 数据对象包含的数据设置自定义的 `ValueFormatter` 。

### 2. Getters / Convenience ###

### 3. Clear ###

*  `clearValues()` : 清除所有 `DataSet` 对象和所有 `Entries` 的数据 。 不会删除所提供的 `x-values` 。

### 4, 选中高亮 ###

*  `setHighlightEnabled(boolean enabled)` : 设置为true，允许通过点击高亮突出 `ChartData` 对象和其 `DataSets` 。

## 二、Data 类详情 ##

这里主要是总结 `ChartData` 类的子类。 所有其他 `ChartData` 子类（下面没有提到的）都未提供任何特定的增强。

### 1. BarData 类（条形图） ###

#### 1) 父类结构 ####

java.lang.Object
            com.github.mikephil.charting.data.ChartData<T>
                com.github.mikephil.charting.data.BarLineScatterCandleBubbleData<BarDataSet>
                    com.github.mikephil.charting.data.BarData

#### 2) 方法 ####

*  `setGroupSpace(float percent)` : 设置不同 `DataSet` 的 **bar组** 之间的间隙（占一个bar的宽度的百分比）。  
    
    
     *  如 20f，间隙刚好就是一个bar的宽度的十分之二（下面左图效果）
     *  如 100f，间隙刚好就是一个bar的宽度（下面右图效果），默认：80  
        ![setGroupSpace(20f)][setGroupSpace_20f]![setGroupSpace(100f)][setGroupSpace_100f]  
        上面效果图的代码如下：

private void loadBarChartData(BarChart chart) {
            //所有数据点的集合
            ArrayList<BarEntry> entries1 = new ArrayList<>();
            for (int i = 0; i < 12; i++) {
                entries1.add(new BarEntry(mDataYs1[i], i));
            }
            ArrayList<BarEntry> entries2 = new ArrayList<>();
            for (int i = 0; i < 12; i++) {
                entries2.add(new BarEntry(mDataYs2[i], i));
            }
    
            //柱形数据的集合
            BarDataSet barDataSet1 = new BarDataSet(entries1, "barDataSet1");
            barDataSet1.setBarSpacePercent(20f);
    // mBarDataSet1.setColors(ColorTemplate.VORDIPLOM_COLORS); // 设置每条柱子的颜色
            barDataSet1.setColors(new int[]{Color.BLUE}); // 设置每条柱子的颜色
            barDataSet1.setHighLightAlpha(255); // 设置点击后高亮颜色透明度
            barDataSet1.setHighLightColor(Color.RED);
    
            BarDataSet barDataSet2 = new BarDataSet(entries2, "barDataSet2");
            barDataSet2.setBarSpacePercent(20f);
            barDataSet2.setColors(new int[]{Color.GREEN}); // 设置每条柱子的颜色
            barDataSet2.setHighLightAlpha(125); // 设置点击后高亮颜色透明度
            barDataSet2.setHighLightColor(Color.GRAY);
    
            //BarData表示挣个柱形图的数据
            BarData barData = new BarData(getXAxisShowLable(), barDataSet1);
            barData.addDataSet(barDataSet2);
            chart.setData(barData);
    
            barDataSet1.setDrawValues(false);
            barDataSet2.setDrawValues(false);
    
            mBarData.setGroupSpace(20f); // 上面左效果图
            mBarData.setGroupSpace(100f); // 上面右效果图
    
            // 上面设置了barDataSet1和barDataSet2总共两条
            // 所以isGrouped()方法返回true
            if (barData.isGrouped()) {
                Log.d(TAG,"isGrouped() 为 true !");
            }

*  `isGrouped()` : 返回true，如果该数据对象进行分组（包括超过1 DataSet ），假如果不是。

#### 3) BarData 类源码 ####

/** * Data object that represents all data for the BarChart. */
    public class BarData extends BarLineScatterCandleBubbleData<BarDataSet> { 
    
        /** the space that is left between groups of bars */
        private float mGroupSpace = 0.8f;
    
        // /**
        // * The maximum space (in pixels on the screen) a single bar can consume.
        // */
        // private float mMaximumBarWidth = 100f;
    
        public BarData() {
            super();
        }
    
        public BarData(List<String> xVals) {
            super(xVals);
        }
    
        public BarData(String[] xVals) {
            super(xVals);
        }
    
        public BarData(List<String> xVals, List<BarDataSet> dataSets) {
            super(xVals, dataSets);
        }
    
        public BarData(String[] xVals, List<BarDataSet> dataSets) {
            super(xVals, dataSets);
        }
    
        public BarData(List<String> xVals, BarDataSet dataSet) {
            super(xVals, toList(dataSet));
        }
    
        public BarData(String[] xVals, BarDataSet dataSet) {
            super(xVals, toList(dataSet));
        }
    
        private static List<BarDataSet> toList(BarDataSet dataSet) {
            List<BarDataSet> sets = new ArrayList<BarDataSet>();
            sets.add(dataSet);
            return sets;
        }
    
        /** * Returns the space that is left out between groups of bars. Always returns * 0 if the BarData object only contains one DataSet (because for one * DataSet, there is no group-space needed). * * @return */
        public float getGroupSpace() {
    
            if (mDataSets.size() <= 1)
                return 0f;
            else
                return mGroupSpace;
        }
    
        /** * Sets the space between groups of bars of different datasets in percent of * the total width of one bar. 100 = space is exactly one bar width, * default: 80 * * @param percent */
        public void setGroupSpace(float percent) {
            mGroupSpace = percent / 100f;
        }
    
        /** * Returns true if this BarData object contains grouped DataSets (more than * 1 DataSet). * * @return */
        public boolean isGrouped() {
            return mDataSets.size() > 1 ? true : false;
        }
    
        //
        // /**
        // * Sets the maximum width (in density pixels) a single bar in the barchart
        // * should consume.
        // *
        // * @param max
        // */
        // public void setBarWidthMaximum(float max) { 
        // mMaximumBarWidth = Utils.convertDpToPixel(max);
        // }
        //
        // /**
        // * Returns the maximum width (in density pixels) a single bar in the
        // * barchart should consume.
        // *
        // * @return
        // */
        // public float getBarWidthMaximum() { 
        // return mMaximumBarWidth;
        // }
    }

### 2. ScatterData 类（散点图） ###

#### 1) 方法 ####

*  `getGreatestShapeSize()` : 返回这个data对象中所有 `ScatterDataSets` 中的最大外形尺寸。

#### 2) ScatterData 类源码 ####

public class ScatterData extends BarLineScatterCandleBubbleData<ScatterDataSet> { 
    
        public ScatterData() {
            super();
        }
    
        public ScatterData(List<String> xVals) {
            super(xVals);
        }
    
        public ScatterData(String[] xVals) {
            super(xVals);
        }
    
        public ScatterData(List<String> xVals, List<ScatterDataSet> dataSets) {
            super(xVals, dataSets);
        }
    
        public ScatterData(String[] xVals, List<ScatterDataSet> dataSets) {
            super(xVals, dataSets);
        }
    
        public ScatterData(List<String> xVals, ScatterDataSet dataSet) {
            super(xVals, toList(dataSet));
        }
    
        public ScatterData(String[] xVals, ScatterDataSet dataSet) {
            super(xVals, toList(dataSet));
        }
    
        private static List<ScatterDataSet> toList(ScatterDataSet dataSet) {
            List<ScatterDataSet> sets = new ArrayList<ScatterDataSet>();
            sets.add(dataSet);
            return sets;
        }
    
        /** * Returns the maximum shape-size across all DataSets. * * @return */
        public float getGreatestShapeSize() {
    
            float max = 0f;
    
            for (ScatterDataSet set : mDataSets) {
                float size = set.getScatterShapeSize();
    
                if (size > max)
                    max = size;
            }
    
            return max;
        }
    }

### 3. PieData 类（饼状图） ###

#### 1) 方法 ####

*  `getDataSet()` : 返回已为这个data对象设置了的 `PieDataSet` 对象。`PieData` 对象不能包含多个 `PieDataSets` 对象。
 *  `setDataSet(PieDataSet set)` : 为这个data对象设置 `PieDataSet` 。

#### 2) PieData 类源码 ####

/** * A PieData object can only represent one DataSet. Unlike all other charts, the * legend labels of the PieChart are created from the x-values array, and not * from the DataSet labels. Each PieData object can only represent one * PieDataSet (multiple PieDataSets inside a single PieChart are not possible). */
    public class PieData extends ChartData<PieDataSet> { 
    
        public PieData() {
            super();
        }
    
        public PieData(List<String> xVals) {
            super(xVals);
        }
    
        public PieData(String[] xVals) {
            super(xVals);
        }
    
        public PieData(List<String> xVals, PieDataSet dataSet) {
            super(xVals, toList(dataSet));
        }
    
        public PieData(String[] xVals, PieDataSet dataSet) {
            super(xVals, toList(dataSet));
        }
    
        private static List<PieDataSet> toList(PieDataSet dataSet) {
            List<PieDataSet> sets = new ArrayList<PieDataSet>();
            sets.add(dataSet);
            return sets;
        }
    
        /** * Sets the PieDataSet this data object should represent. * * @param dataSet */
        public void setDataSet(PieDataSet dataSet) {
            mDataSets.clear();
            mDataSets.add(dataSet);
            init();
        }
    
        /** * Returns the DataSet this PieData object represents. A PieData object can * only contain one DataSet. * * @return */
        public PieDataSet getDataSet() {
            return mDataSets.get(0);
        }
    
        @Override
        public PieDataSet getDataSetByIndex(int index) {
            return index == 0 ? getDataSet() : null;
        }
    
        @Override
        public PieDataSet getDataSetByLabel(String label, boolean ignorecase) {
            return ignorecase ? label.equalsIgnoreCase(mDataSets.get(0).getLabel()) ? mDataSets.get(0)
                    : null : label.equals(mDataSets.get(0).getLabel()) ? mDataSets.get(0) : null;
        }
    }

### 4. BubbleData 类 ###

#### 1) 方法 ####

*  `setHighlightCircleWidth(float width)` : Sets the width of the circle that surrounds the bubble when in highlighted state for all BubbleDataSet objects this data object contains, in dp.

#### 2) BubbleData 类源码 ####

public class BubbleData extends BarLineScatterCandleBubbleData<BubbleDataSet> { 
    
        public BubbleData() {
            super();
        }
    
        public BubbleData(List<String> xVals) {
            super(xVals);
        }
    
        public BubbleData(String[] xVals) {
            super(xVals);
        }
    
        public BubbleData(List<String> xVals, List<BubbleDataSet> dataSets) {
            super(xVals, dataSets);
        }
    
        public BubbleData(String[] xVals, List<BubbleDataSet> dataSets) {
            super(xVals, dataSets);
        }
    
        public BubbleData(List<String> xVals, BubbleDataSet dataSet) {
            super(xVals, toList(dataSet));
        }
    
        public BubbleData(String[] xVals, BubbleDataSet dataSet) {
            super(xVals, toList(dataSet));
        }
    
        private static List<BubbleDataSet> toList(BubbleDataSet dataSet) {
            List<BubbleDataSet> sets = new ArrayList<BubbleDataSet>();
            sets.add(dataSet);
            return sets;
        }
    
        /** * Sets the width of the circle that surrounds the bubble when highlighted * for all DataSet objects this data object contains, in dp. * * @param width */
        public void setHighlightCircleWidth(float width) {
            for (BubbleDataSet set : mDataSets) {
                set.setHighlightCircleWidth(width);
            }
        }
    }

### 5. CombinedData 类 ###

#### 1) 概述 ####

此data对象被设计来包含所有其他数据对象的实例，通过使用此对象提供的数据 `setData(...)` 方法。 这个仅用于 `CombinedChart` 。This data object is designed to contain instances of all other data objects. Use the setData(…) methods to provide the data for this object. This is used for the CombinedChart only.

这是它内部大致结构：

public class CombinedData extends ChartData { 
    
        // ...
    
        public CombinedData(List<String> xVals) { ... }
    
        public CombinedData(String[] xVals) { ... }
    
        public void setData(LineData data) { ... }
    
        public void setData(BarData data) { ... }
    
        public void setData(ScatterData data) { ... }
    
        public void setData(CandleData data) { ... }
    
        // ...
    }

#### 2) CombinedData 类源码 ####

/** * Data object that allows the combination of Line-, Bar-, Scatter-, Bubble- and * CandleData. Used in the CombinedChart class. */
    public class CombinedData extends BarLineScatterCandleBubbleData<BarLineScatterCandleBubbleDataSet<?>> {
    
        private LineData mLineData;
        private BarData mBarData;
        private ScatterData mScatterData;
        private CandleData mCandleData;
        private BubbleData mBubbleData;
    
        public CombinedData() {
            super();
        }
    
        public CombinedData(List<String> xVals) {
            super(xVals);
        }
    
        public CombinedData(String[] xVals) {
            super(xVals);
        }
    
        public void setData(LineData data) {
            mLineData = data;
            mDataSets.addAll(data.getDataSets());
            init();
        }
    
        public void setData(BarData data) {
            mBarData = data;
            mDataSets.addAll(data.getDataSets());
            init();
        }
    
        public void setData(ScatterData data) {
            mScatterData = data;
            mDataSets.addAll(data.getDataSets());
            init();
        }
    
        public void setData(CandleData data) {
            mCandleData = data;
            mDataSets.addAll(data.getDataSets());
            init();
        }
    
        public void setData(BubbleData data) {
            mBubbleData = data;
            mDataSets.addAll(data.getDataSets());
            init();
        }
    
        public BubbleData getBubbleData() {
            return mBubbleData;
        }
    
        public LineData getLineData() {
            return mLineData;
        }
    
        public BarData getBarData() {
            return mBarData;
        }
    
        public ScatterData getScatterData() {
            return mScatterData;
        }
    
        public CandleData getCandleData() {
            return mCandleData;
        }
    
        /** * Returns all data objects in row: line-bar-scatter-candle-bubble if not null. * @return */
        public List<ChartData> getAllData() {
    
            List<ChartData> data = new ArrayList<ChartData>();
            if(mLineData != null)
                data.add(mLineData);
            if(mBarData != null)
                data.add(mBarData);
            if(mScatterData != null)
                data.add(mScatterData);
            if(mCandleData != null)
                data.add(mCandleData);
            if(mBubbleData != null)
                data.add(mBubbleData);
    
            return data;
        }
    
        @Override
        public void notifyDataChanged() {
            if (mLineData != null)
                mLineData.notifyDataChanged();
            if (mBarData != null)
                mBarData.notifyDataChanged();
            if (mCandleData != null)
                mCandleData.notifyDataChanged();
            if (mScatterData != null)
                mScatterData.notifyDataChanged();
            if (mBubbleData != null)
                mBubbleData.notifyDataChanged();
    
            init(); // recalculate everything
        }
    }

## 三、DataSet 类 ##

### 1. 概述 ###

`DataSet` 类是所有数据集类的基类，比如 `LineDataSet`，`BarDataSet` 等等。

public class LineDataSet extends DataSet {  ...

`DataSet` 类是 `Chart` 中一组或一类的 `Entry` 的集合。 它被设计成 `Chart` 内部逻辑上分离的不同值组（例如， `LineChart` 中特定行的值或 `BarChart` 中特定bar组的值）。

以下提到的方法在 `DataSet` 类中被实现，因此可用于所有子类。

### 2. Styling data ###

*  `setValueTextColor(int color)` : 设置该 `DataSet` 的文本的颜色（color in which the value-labels are drawn）。
 *  `setValueTextSize(float size)` : 设置该 `DataSet` 的文本的大小（dp）。
 *  `setValueTypeface(Typeface tf)` : 设置该 `DataSet` 的文本的字体（Typeface）。
 *  `setValueFormatter(ValueFormatter f)` : 设置该 `DataSet` 的文本的格式器。
 *  `setDrawValues(boolean enabled)` : 是否绘制该 `DataSet` 的文本。

如果你的整个 `data` 对象（非 `data-set` 对象）的所有值都具有相同的颜色，you can simply call one of the above mentioned on the ChartData object.

### 3. 突出显示 ###

*  `setHighlightEnabled(boolean enabled)` : 设置为true将允许通过触摸突出显示这个特定的`DataSet` 。

### 4. Getters / Convenience ###

*  `contains(Entry entry)` : 检查此 `DataSet` 对象是否包含指定的 `Entry` 。  
    注意：使用这个方法会使得性能非常糟糕。

## 四、DataSet 类详细 ##

### 1. 概述 ###

这里主要是总结 `DataSet` 类的子类。 所有其他 `DataSet` 子类（下面没有提到的）都未提供任何特定的增强。

1) **Line-, Bar-, Scatter-, Bubble- & CandleDataSet**（下面提到的方法可用于任何所述的`DataSet`类）

*  `setHighLightColor(int color)` : 设置用于绘制加亮显示的颜色。 不要忘了使用 `getResources().getColor(...)` 或 `Color.rgb(...)` 或简单点的`Color.BLACK` 来解析颜色。

2) **Line-, Bar-, Scatter-, Candle- & RadarDataSet**

*  `setDrawHighlightIndicators(boolean enabled)` : 启用/禁用 垂直和水平（两者）的高亮指示线。  
    调用 `setDrawVerticalHighlightIndicator(...)` 和 `setDrawHorizontalHighlightIndicator(...)` 方法可进行于独立配置。
 *  `setHighlightLineWidth(float width)` : 设置高亮线（crosshairs）的宽度（dp）。

3) **Line- & RadarDataSet** （方法仅适用于 `LineDataSet` 和 `RadarDataSet`）

*  `setFillColor(int color)` : 设定填充线表面的颜色。
 *  `setFillAlpha(int alpha)` : 设定填充线面的alpha值（即透明度 0-255）。默认：85。255 =完全不透明，0 =完全透明。
 *  `setDrawFilled(boolean filled)` : Set to true if the DataSet should be drawn filled (surface, area)，而不仅仅是一条线，默认值：false 。**注意：禁止这将给予极大的性能提升！**
 *  `setLineWidth(float width)` : 设置该 `DataSet` 的线宽（最小= 0.2F，最大= 10F）；默认1F；**注意：线越细==性能越好，线越厚==性能越糟糕** 。

下面提到方法仅适用于特别提到的 `DataSet` 的子类。

### 2. LineDataSet 类 ###

*  `setDrawCircles(boolean enabled)` : 设置为true，将绘制 `LineDataSet` 的线圈。默认为true。
 *  `setCircleSize(float size)` : 设置线圈的大小（半径），默认为 4F 。
 *  `setCircleColor(int color)` : 设置线圈的颜色。
 *  `setCircleColors(List colors)` : 设置该 `LineDataSet` 的线圈的颜色（一组颜色）。 还有其它设置颜色的方法。
 *  `setCircleColorHole(int color)` : 设置线圈的内圆（孔）的颜色。
 *  `setDrawCircleHole(boolean enabled)` : 设置为true，允许在该 `DataSet` 的每个圈画了一个洞。 如果设置为false，圆将被填补（无孔）。
 *  `enableDashedLine(float lineLength, float spaceLength, float phase)` : 启用虚线模式，是的连线像这样“ - - - - - - ”。 “lineLength”是虚线线段的长度，“spaceLength”是虚线线段的间距，“phase”是偏移量（通常，使用0） 。  
    ![图一][20160103135921925]![图二][20160103135929862]  
    ![图三][20160103141138624]![图四][20160103135937796]

// 图一
        dataSet.setDrawCircles(false);
    
        // 图二
        dataSet.setDrawCircles(true);
        dataSet.setDrawCircleHole(true);
        dataSet.setCircleSize(16.0f);
        dataSet.setCircleColor(Color.GREEN);
        dataSet.setCircleColorHole(Color.RED);
    
        // 图三
        dataSet.enableDashedLine(10f,8f,0f);
    
        // 图四
        dataSet.setCircleColors(new int[]{Color.GRAY,Color.BLUE,Color.BLACK});

*  `setDrawCubic(boolean enabled)` : 如果设置为true，`LineChart` 线将被绘制成立体式的，而不是线性的。 **设置为true将对性能产生负面影响 ！** 默认值：false 。
 *  `setCubicIntensity(float intensity)` : 设置立体式的程度（如果启用立体式绘制的话）。 最大= 1F =非常立体，最小为0.05f =低的立体效果，默认：0.2F 。  
    ![20160103142605388][]![20160103142614620][]  
    ![20160103142624124][]![20160103142633110][]

// 图一
        setDrawCubic(false);
        // 图二
        setDrawCubic(true); // 默认立体强度为0.2f
        // 图三
        setDrawCubic(true);
        setCubicIntensity(0.5f);
        // 图四
        setDrawCubic(true);
        setCubicIntensity(1.0f);

### 3. BarDataSet 类 ###

*  `setBarSpacePercent(float percent)` : 设置在bar之间的间隙（占一条bar宽度的百分比）。
 *  `setBarShadowColor(int color)` : 设置绘制bar阴影的颜色。 **Don’t for get to use `getResources().getColor(...)` to set this. Or `Color.rgb(...).`**
 *  `setHighLightAlpha(int alpha)` : 设置绘制加亮显示的bar的透明度。 最小= 0（完全透明），最大= 255（完全不透明）。
 *  `setStackLabels(String[] labels)` : Sets labels for different values of bar-stacks, in case there are one.

### 4. ScatterDataSet 类 ###

*  `setScatterShapeSize(float size)` : 设置密度像素的绘制scattershape将有大小。 这仅适用于非自定义形状。Sets the size in density pixels the drawn scattershape will have. This only applies for non custom shapes.
 *  `setScatterShape(ScatterShape shape)` : 设置上绘制其中的值是在该位置的形状。 Sets the shape that is drawn on the position where the values are at.

### 5. CandleDataSet 类 ###

*  `setBodySpace(float space)` : 设置留出每个烛体，默认0.1F（10％），最大值0.45F，最小0F的左侧和右侧的空间。Sets the space that is left out on the left and right side of each candle body, default 0.1f (10%), max 0.45f, min 0f
 *  `setShadowWidth(float width)` : 设置烛影线的DP的宽度。 默认3F。Sets the width of the candle-shadow-line in dp. Default 3f.
 *  `setShadowColor(int color)` : 设置烛影线的颜色。Sets the color of the candle-shadow-line.
 *  `setDecreasingColor(int color)` : 设置应该用于此独一无二的颜色DataSet时，开>关闭。Sets the one and ONLY color that should be used for this DataSet when open > close.
 *  `setIncreasingColor(int color)` : 设置应该用于该数据集的独一无二的颜色，当打开<=关闭。Sets the one and ONLY color that should be used for this DataSet when open <= close.
 *  `setDecreasingPaintStyle(Paint.Style style)` : 设置绘图方式时开>关闭（填充或描边）。Sets paint style when open > close (fill or stroke).
 *  `setIncreasingPaintStyle(Paint.Style style)` : 设置绘制风格，当打开<=关闭（填充或描边）。 Sets paint style when open <= close (fill or stroke).

### 6. BubbleDataSet 类 ###

*  `setHighlightCircleWidth(float width)` : 设置环绕当高亮状态下的泡沫，在DP圆的宽度。 Sets the width of the circle that surrounds the bubble when in highlighted state, in dp.

有关资料CandleDataSet颜色：通常setColors(…)方法仍然可以用于着色图表的一次。 setColor(…) 如果特定的颜色（身体，阴影……）的需要，可使用上述方法。Information concerning CandleDataSet colors: The usual setColors(…), setColor(…), … methods can still be used for coloring the chart all at once. If specific colors (for body, shadow, …) are needed, use the above mentioned methods.

### 7. PieDataSet 类 ###

*  `setSliceSpace(float degrees)` : 设置被排除在饼图切片，默认之间的空间：0° - >没有空间，最大的45岁，最小0（无空格）。Sets the space that is left out between the piechart-slices, default: 0° –> no space, maximum 45, minimum 0 (no space)
 *  `setSelectionShift(float shift)` : 将选中的饼图切片该数据集是距离从图表中，缺省12F中心“转移”掉 。Sets the distance the highlighted piechart-slice of this DataSet is “shifted” away from the center of the chart, default 12f

[LineChart_]: /images/20220524/d945ebf49e7b496e9f26bb12599a48f2.png
[chart.setBackgroundColor_0xff00ff00]: /images/20220524/4cf9f008eafe44ae8e8521d1027e4f2f.png
[chart.setDescription_ zhuanghongji _ chart.setDescriptionColor_Color.RED]: /images/20220524/ea832ce0323441b2a7a613de0948791b.png
[chart.setDescriptionPosition_150f_150f_ chart.setDescriptionTextSize_16f]: /images/20220524/4bec06888b7f4ba6a13ceb86da692c4c.png
[chart.setNoDataTextDescription_ Data _]: /images/20220524/44da621bfffd47b595509527cdf0b1a2.png
[chart.setDrawGridBackground_true]: /images/20220524/2a6a393d813d4f80b14467ed2a020dee.png
[chart.setDrawGridBackground_true_ chart.setGridBackgroundColor_Color.BLUE]: /images/20220524/921a372db6bc40e694c8ce1cf98201b1.png
[chart.setDrawBorders_true_chart.setBorderColor_Color.YELLOW_chart.setBorderWidth_4f]: /images/20220524/1130bb430de3421aa86beb18887b598d.png
[xAxis.setEnabled_true]: https://img-blog.csdn.net/20151214175417086
[xAxis.setEnabled_false]: /images/20220524/a14d7ddcfe7547649dec51a7a6ad31e0.png
[20151214180828611]: https://img-blog.csdn.net/20151214180828611
[20151214180842785]: /images/20220524/386d23b013394869af59cb2b926ff5a7.png
[xAxis.setEnabled_false 1]: /images/20220524/1e706d899c98478ca76d46ef959784bd.png
[xAxis.setDrawLabels_false]: /images/20220524/bc756e7a32004011bd415a4179d6837f.png
[20151214194142156]: /images/20220524/53d86b66363b4d0dbb607d3ae3465727.png
[xAxis.enableGridDashedLine_4_4_1]: /images/20220524/c3ee11fa5e9e4ced9faeccf1febe0287.png
[x_LimitLine]: https://img-blog.csdn.net/20151214201049758
[y_LimitLine]: /images/20220524/ab108e8c6ca241efbfc73473f104fa35.png
[xAxis.setDrawLimitLinesBehindData_true]: https://img-blog.csdn.net/20151214202454550
[20151214202753278]: /images/20220524/ec234867ca4e40e9af0e6160cbb253ce.png
[setSpaceBetweenLabels_1]: /images/20220524/d53d324d0ae44901b35df1c4b198daaa.png
[setLabelsToSkip_2]: https://img-blog.csdn.net/20151214211614491
[setLabelsToSkip_3]: /images/20220524/631634c25aa9444f82b1229e4bc146ff.png
[resetLabelsToSkip]: https://img-blog.csdn.net/20151214214330225
[resetLabelsToSkip 1]: /images/20220524/d3adb145f975489a803befee17d964fa.png
[XAxisPosition.TOP]: https://img-blog.csdn.net/20151214220528257
[XAxisPosition.BOTTOM]: /images/20220524/d5c8e1d079eb4aa1ae92fe74901d9653.png
[XAxisPosition.TOP_INSIDE]: https://img-blog.csdn.net/20151214220553181
[XAxisPosition.BOTTOM_INSIDE]: /images/20220524/c0eb7b1e933e46698c7ead9e28ef0682.png
[XAxisPosition.BOTH_SIDED]: /images/20220524/83d6a2205b704cc69d0b994c00cd1549.png
[20151215003245914]: https://img-blog.csdn.net/20151215003245914
[20151215003305229]: /images/20220524/572f4cc9f13f4cb6a84e6c516db7e3e2.png
[setInverted_true]: /images/20220524/784cbe67828543118f344faba1b072c9.png
[leftAxis.setSpaceTop_50f]: https://img-blog.csdn.net/20151215004104209
[leftAxis.setSpaceTop_100f]: /images/20220524/5a0e5d90128b47f5aca84de278377499.png
[20151215005846507]: https://img-blog.csdn.net/20151215005846507
[20151215005904346]: /images/20220524/47b4d423367b42dfaece22e02065752b.png
[YAxis.YAxisLabelPosition.OUTSIDE_CHART]: https://img-blog.csdn.net/20151215010819696
[YAxis.YAxisLabelPosition.INSIDE_CHART]: /images/20220524/bdd2d9083eb142639270d5fa1fb567a3.png
[dataSet.setDrawValues_true]: https://img-blog.csdn.net/20151215100506752
[dataSet.setDrawValues_false]: /images/20220524/7680ce719681460ba55bd9d5e8ffa946.png
[20151215102302035]: https://img-blog.csdn.net/20151215102302035
[20151215102320390]: /images/20220524/988a8e92c19b4e7485763e0f782ad324.png
[Typeface]: /images/20220524/33322bdee9174b35a44c09fe33fbae28.png
[20151215140240947]: https://img-blog.csdn.net/20151215140240947
[20151215140302263]: /images/20220524/c882e71dd8bd4fd8a6916d78ccb7af2f.png
[20151216194137344]: https://img-blog.csdn.net/20151216194137344
[leftAxis.setValueFormatter_new MyYAxisValueFormatter]: /images/20220524/6f13702dbc7545dbb029fb0ce8805347.png
[20151216194716867]: /images/20220524/733d9beab8ca4f4284144736db686a4f.png
[setDrawValueAboveBar_true]: https://img-blog.csdn.net/20151216221223963
[setDrawValueAboveBar_false]: /images/20220524/867cc7cb9bff4ac4a3a54e5f5c629db1.png
[setDrawBarShadow_false]: https://img-blog.csdn.net/20151216221919004
[setDrawBarShadow_true]: /images/20220524/ac3ee53063c54e86bf3e15b408669210.png
[20151222144015437]: https://img-blog.csdn.net/20151222144015437
[20151222144028576]: /images/20220524/20f19745ff37414a91adbcbddac8bbf9.png
[20151222145819954]: https://img-blog.csdn.net/20151222145819954
[20151222145839177]: /images/20220524/4390956125474b5a9765e45f3c47d63b.png
[20151222141949339]: https://img-blog.csdn.net/20151222141949339
[20151222141957982]: /images/20220524/3fe621e1e09f40dabf62b60a49fc624b.png
[270f]: https://img-blog.csdn.net/20151222151748018
[chart.setRotationAngle_0f]: /images/20220524/cdef40fdc24f406c81ad7c9635ab9049.png
[20151222140949788]: https://img-blog.csdn.net/20151222140949788
[20151222141000736]: /images/20220524/734c4b73e6e247aba2f798a3c1c6ad4c.png
[20151222140724681]: https://img-blog.csdn.net/20151222140724681
[20151222140735151]: /images/20220524/f7eaffa8d7b3414da81f25782fe01ce7.png
[20151222211746598]: https://img-blog.csdn.net/20151222211746598
[Legend legend _ chart.getLegend_ legend.setEnabled_false]: /images/20220524/f90e7642149344c48faf2f7c53a514bf.png
[legend.setTextColor_Color.GREEN_legend.setTextSize_24f]: /images/20220524/da7c170de9bb42aa9347d52b92b22e69.png
[RIGHT_OF_CHART]: https://img-blog.csdn.net/20151222214512192
[RIGHT_OF_CHART_CENTER]: /images/20220524/39c06dc590ac4dc59e18a2e7457dd134.png
[RIGHT_OF_CHART_INSIDE]: https://img-blog.csdn.net/20151222214529887
[BELOW_CHART_LEFT]: /images/20220524/2a1da2bfdb0c4111b9dc3158a7fb52ef.png
[BELOW_CHART_RIGHT]: https://img-blog.csdn.net/20151222214546942
[BELOW_CHART_CENTER]: /images/20220524/abd7281d2c6f4660877f9b6782727a72.png
[SQUARE]: https://img-blog.csdn.net/20151222224100799
[CIRCLE]: https://img-blog.csdn.net/20151222224117771
[LINE]: /images/20220524/86daefda84f148a582c8be87a6e65d5a.png
[DynamicalAddingActivity.java]: https://github.com/zhuanghongji/MPAndroidChart/blob/master/app/src/main/java/com/zhuanghongji/mpandroidchart/DynamicalAddingActivity.java
[addEntry]: /images/20220524/81262faed1f94d6f9e87197443db9d6e.png
[removeLastEntry]: /images/20220524/62ca647a77a64e86b73e9cecaad8a9ea.png
[20151224181331155]: /images/20220524/7f2e338ee07d4e8faddaa28275b32ef9.png
[20151224181818057]: /images/20220524/45e51cad98f3450798d51202edf322dc.png
[20151224182210380]: /images/20220524/86fcc82601eb4cc6b0f39e72d4948dd6.png
[20151223131934423]: https://img-blog.csdn.net/20151223131934423
[chart.setVisibleXRangeMinimum_17]: /images/20220524/9de540781cdb4a89a5122beae7482ad9.png
[20151223131945600]: https://img-blog.csdn.net/20151223131945600
[20151223132619951]: /images/20220524/dd2b68aab6a54201b2cbfeb8e5eef738.png
[chart.setVisibleYRangeMaximum_50f_YAxis.AxisDependency.LEFT]: https://img-blog.csdn.net/20151223133317497
[chart.setVisibleYRangeMaximum_70f_YAxis.AxisDependency.LEFT]: /images/20220524/082d9c7e397e4cc38c7c4dc96ef0ab49.png
[1_ chart.setViewPortOffsets_50_0_0_0]: https://img-blog.csdn.net/20151223134220738
[2_ chart.setViewPortOffsets_0_50_0_0]: /images/20220524/735b51288ef54125a57846706fd6bfb3.png
[3_ chart.setViewPortOffsets_50_50_0_0]: https://img-blog.csdn.net/20151223134241957
[4_ chart.setViewPortOffsets_50_50_50_50]: /images/20220524/53691d431f9d41a699ce984f1605b8b1.png
[chart.moveViewToX_2]: https://img-blog.csdn.net/20151223135143112
[chart.moveViewToX_5]: /images/20220524/bc5dee9ef2994c6abc3b26ba2b388210.png
[chart.moveViewToY_40_YAxis.AxisDependency.LEFT]: https://img-blog.csdn.net/20151223135908438
[chart.moveViewToY_60_YAxis.AxisDependency.LEFT]: /images/20220524/29313137a8f34ec6a4a3a1c40a2789e1.png
[animateX_8000_ _ _1]: https://img-blog.csdn.net/20151222170138194
[animateY_8000_ _ _2]: /images/20220524/cb2c24516e78479a95eb0ba4d7141dfe.png
[animateXY_8000_ 8000_ _ _3]: https://img-blog.csdn.net/20151222170225889
[animateY_8000_ Easing.EasingOption.EaseInElastic _ _ _4]: /images/20220524/d5005b071c044d11849d71a6c029fa76.png
[animateX_8000_ _ _1 1]: https://img-blog.csdn.net/20151222171642638
[animateY_8000_ _ _2 1]: /images/20220524/039c41b5e6e341788c194df0e7e0bd49.png
[animateXY_8000_ 8000_ _ _3 1]: https://img-blog.csdn.net/20151222171719427
[animateY_8000_ Easing.EasingOption.EaseInSine_ _ _4]: /images/20220524/5fba611c54b943adad75c1c9787ec827.png
[animateX_8000_ _ _1 2]: https://img-blog.csdn.net/20151222181636046
[animateY_8000_ _ _2 2]: /images/20220524/d089e3e51f3742cfbfde6ce3b8ec9f1b.png
[animateXY_8000_8000_ _ _3]: https://img-blog.csdn.net/20151222181713391
[animateY_8000_ Easing.EasingOption.EaseOutBounce_ _ _4]: /images/20220524/4f453f954c2c4cd3976df06bd5849483.png
[Linear]: https://img-blog.csdn.net/20151222201136943
[EaseInQuad]: /images/20220524/04d94e3f1f424675805e0e1d5236a232.png
[EaseOutQuad]: https://img-blog.csdn.net/20151222201226249
[EaseInOutQuad]: /images/20220524/ad9101fae93e483fa9f8bb267bf2ff42.png
[EaseInCubic]: https://img-blog.csdn.net/20151222201300027
[EaseOutCubic]: /images/20220524/8bf1a0a5098c48d79e0cd0764c927f97.png
[EaseInOutCubic]: https://img-blog.csdn.net/20151222201332561
[EaseInQuart]: /images/20220524/344f975c14084fd291a114e0360c5c64.png
[EaseOutQuart]: https://img-blog.csdn.net/20151222201611301
[EaseInOutQuart]: /images/20220524/4c6d06e624954eeab94a097301b4ba47.png
[EaseInSine]: https://img-blog.csdn.net/20151222202051685
[EaseOutSine]: /images/20220524/099c5624a3604aed82076184375544ef.png
[EaseInOutSine]: https://img-blog.csdn.net/20151222202131675
[EaseInExpo]: /images/20220524/482b2537bb71433f85f77e4f3db4eb97.png
[EaseOutExpo]: https://img-blog.csdn.net/20151222202156602
[EaseInOutExpo]: /images/20220524/22454cb33310432399c96c054e795257.png
[EaseInCirc]: https://img-blog.csdn.net/20151222202230158
[EaseOutCirc]: /images/20220524/997bc9293f2a4fbc94870c2bba7d3a76.png
[EaseInOutCirc]: https://img-blog.csdn.net/20151222202300712
[EaseInElastic]: /images/20220524/8672a413d64d4d9eb5738dd28ab0f05c.png
[EaseOutElastic]: https://img-blog.csdn.net/20151222202333315
[EaseInOutElastic]: /images/20220524/b4fb72461beb41ad9973717e0b53829f.png
[EaseInBack]: https://img-blog.csdn.net/20151222202359857
[EaseOutBack]: /images/20220524/de1a6bc07155408299f6f201b4a307d9.png
[EaseInOutBack]: https://img-blog.csdn.net/20151222202429265
[EaseInBounce]: /images/20220524/33e3b5e3ef984719b41bd7185faf4903.png
[EaseOutBounce]: https://img-blog.csdn.net/20151222202503503
[EaseInOutBounce]: /images/20220524/9db81f431bfd456595011917d0de91c8.png
[20151229221538935]: https://img-blog.csdn.net/20151229221538935
[20151229221521125]: /images/20220524/6701dd939d5f417aafd893e64b6566ee.png
[20151230130135728]: /images/20220524/f3f4978050394a6195851000aa33959c.png
[setGroupSpace_20f]: https://img-blog.csdn.net/20160103105136547
[setGroupSpace_100f]: /images/20220524/cbb1c824f7e14095b1195baad581d85b.png
[20160103135921925]: https://img-blog.csdn.net/20160103135921925
[20160103135929862]: /images/20220524/278521df29584581997edddb6481121e.png
[20160103141138624]: https://img-blog.csdn.net/20160103141138624
[20160103135937796]: /images/20220524/403eee72cc1f47f1abbcaea2aa598b95.png
[20160103142605388]: https://img-blog.csdn.net/20160103142605388
[20160103142614620]: /images/20220524/b427cabb611d42f38bd878a78abc9780.png
[20160103142624124]: https://img-blog.csdn.net/20160103142624124
[20160103142633110]: /images/20220524/9f97620325b84244afb8d4dbb7b53774.png