根据columnKeys 随机选取显示柱状图

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.geom.Ellipse2D;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartUtilities;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.StandardChartTheme;
import org.jfree.chart.axis.CategoryAxis;
import org.jfree.chart.axis.CategoryLabelPositions;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.plot.CategoryPlot;
import org.jfree.chart.plot.DatasetRenderingOrder;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.renderer.category.BarRenderer;
import org.jfree.chart.renderer.category.LineAndShapeRenderer;
import org.jfree.chart.renderer.category.StandardBarPainter;
import org.jfree.data.category.CategoryDataset;
import org.jfree.data.general.DatasetUtilities;

public class ChartsMixed {
private static final long serialVersionUID = 1L;

public void createMixedCharts(double[][] data_sucRate,
String[] rowKeys_sucRate, String[] columnKeys_sucRate,
double[][] data_useCase, String[] rowKeys_useCase,
String[] columnKeys_useCase, String picName) {
if (data_sucRate == null || rowKeys_sucRate == null
|| columnKeys_sucRate == null || data_useCase == null
|| rowKeys_useCase == null || columnKeys_useCase == null
|| picName == null || "".equals(picName.trim())) {
return;
}
int min = 1;
int max = columnKeys_sucRate.length;
// 处理成小数
data_sucRate = getDataSucRateDouble(data_sucRate);
double[][] data_useCaseBuilded = null;
double[][] data_sucRateBuilded = null;
String[] columnKeys_Builded = null;
if (max > 10) {
columnKeys_Builded = getColumnKeysBuilded(min, max);
columnKeys_sucRate = columnKeys_Builded;
columnKeys_useCase = columnKeys_Builded;
data_useCaseBuilded = getDataBuildedArr(columnKeys_Builded,
data_useCase);
data_useCase = data_useCaseBuilded;
data_sucRateBuilded = getDataBuildedArr(columnKeys_Builded,
data_sucRate);
data_sucRate = data_sucRateBuilded;
}
CategoryDataset dataSetColumn = createDataset(data_useCase,
rowKeys_useCase, columnKeys_useCase);
CategoryDataset dataSetLine = createDataset(data_sucRate,
rowKeys_sucRate, columnKeys_sucRate);

createChart(dataSetColumn, dataSetLine, picName);
}

@SuppressWarnings("deprecation")
private void createChart(CategoryDataset dataSetColumn,
CategoryDataset dataSetLine, String picName) {
setChartTheme();
Font font = new Font("宋体", Font.BOLD, 12);

// 创建图形对象
JFreeChart jfreeChart = ChartFactory.createBarChart("", // 图表标题
"", // 目录轴的显示标签
"",// 数值轴的显示标签
dataSetColumn, // 数据集
PlotOrientation.VERTICAL,// 图表方向：水平、垂直
false, // 是否显示图例(对于简单的柱状图必须是false)
true,// 是否生成工具
false);// 是否生成URL链接
jfreeChart.getTitle().setFont(font);
// 图表的背景色(默认为白色)
jfreeChart.setBackgroundPaint(Color.white);
// 设置图片背景色
GradientPaint gradientPaint = new GradientPaint(0, 1000, Color.WHITE,
0, 0, Color.WHITE, false);
jfreeChart.setBackgroundPaint(gradientPaint);

CategoryPlot categoryPlot = (CategoryPlot) jfreeChart.getPlot();

// 设置图形的背景色
categoryPlot.setBackgroundPaint(Color.WHITE);
// 设置图形上竖线是否显示
categoryPlot.setDomainGridlinesVisible(false);
// 设置图形上竖线的颜色
categoryPlot.setDomainGridlinePaint(Color.GRAY);
// 设置图形上横线的颜色
categoryPlot.setRangeGridlinePaint(Color.GRAY);

// 设置柱状图的Y轴显示样式
setNumberAxisToColumn(categoryPlot);
CategoryAxis categoryaxis = categoryPlot.getDomainAxis();
categoryaxis.setCategoryLabelPositions(CategoryLabelPositions.DOWN_45);// 横轴斜45度
// 设置折线图的Y轴显示样式
setNumberAxisLine(categoryPlot);

categoryPlot.setDataset(1, dataSetLine);// 设置数据集索引
categoryPlot.mapDatasetToRangeAxis(1, 1);// 将该索引映射到axis
// 第一个参数指数据集的索引,第二个参数为坐标轴的索引
LineAndShapeRenderer lineAndShapeRenderer = new LineAndShapeRenderer();
// 数据点被填充即不是空心点
lineAndShapeRenderer.setShapesFilled(true);
// 数据点间连线可见
lineAndShapeRenderer.setLinesVisible(true);
// 设置折线拐点的形状，圆形
lineAndShapeRenderer.setSeriesShape(0, new Ellipse2D.Double(-2D, -2D,
4D, 4D));
// 设置折线线条颜色
lineAndShapeRenderer.setSeriesPaint(0, new Color(244, 193, 66));
// 设置折线线条粗细
lineAndShapeRenderer.setSeriesStroke(0, new BasicStroke(2.5F));

// 设置某坐标轴索引上数据集的显示样式
categoryPlot.setRenderer(1, lineAndShapeRenderer);
// 设置两个图的前后顺序
// ，DatasetRenderingOrder.FORWARD表示后面的图在前者上面，DatasetRenderingOrder.REVERSE表示
// 表示后面的图在前者后面
categoryPlot.setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD);

createPicture(picName, jfreeChart);
}

/**
* 设置折线图的Y轴显示样式
*
* @param categoryplot
* @return
*/
private CategoryPlot setNumberAxisLine(CategoryPlot categoryplot) {
NumberAxis numberAxis = new NumberAxis("");
// numberAxis.setUpperBound(100.00D); // 纵轴上限
numberAxis.setLowerBound(0.00D); // 纵轴下限
NumberFormat numberformat = new DecimalFormat("0%");
numberAxis.setNumberFormatOverride(numberformat);// 设置y轴以百分比方式显示

// 坐标轴标尺值颜色
numberAxis.setTickLabelPaint(new Color(244, 193, 66));
// 设置坐标轴刻度尺的字体
numberAxis.setTickLabelFont(new Font("宋体", Font.BOLD, 10));
categoryplot.setRangeAxis(1, numberAxis);
return categoryplot;
}

/**
* 设置柱状图的Y轴显示样式,NumberAxis为整数格式
*
* @param categoryplot
* @return
*/
private CategoryPlot setNumberAxisToColumn(CategoryPlot categoryplot) {
// 获取纵轴
NumberAxis numberAxis = (NumberAxis) categoryplot.getRangeAxis();
// 坐标轴标尺值颜色
numberAxis.setTickLabelPaint(new Color(95, 191, 95));
// 设置坐标轴刻度尺的字体
numberAxis.setTickLabelFont(new Font("宋体", Font.BOLD, 10));
// 设置纵轴的刻度线
numberAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
// 数据轴的数据标签是否自动确定（默认为true）
numberAxis.setAutoTickUnitSelection(true);
// 数据轴的数据标签
numberAxis.setStandardTickUnits(numberAxis.getStandardTickUnits());
numberAxis.setLowerBound(0); // 数据轴上的显示最小值;
numberAxis.setAutoRangeMinimumSize(1);// 1为一个间隔单位
categoryplot.setRangeAxis(numberAxis);
BarRenderer renderer = ((BarRenderer) categoryplot.getRenderer());
// 上面面浅绿色、下面绿色
// GradientPaint gp0 = new GradientPaint(0.0f, 0.0f, new Color(230, 244,
// 208), 0.0f, 0.0f, new Color(95, 191, 95));
GradientPaint gp0 = new GradientPaint(0.0f, 0.0f, new Color(177, 222,
163), 0.0f, 0.0f, new Color(95, 191, 95));
// 设置柱体颜色,竖直渐变
renderer.setSeriesPaint(0, gp0);
// 设置柱体宽度
renderer.setMaximumBarWidth(0.08);
// renderer.setItemMargin(0.1);
// 设置阴影不可见
renderer.setShadowVisible(false);
// 设置外边框无
renderer.setDrawBarOutline(false);
// 去掉水平柱体白条
renderer.setBarPainter(new StandardBarPainter());

int count = categoryplot.getDataset().getColumnCount();

if (count >= 10) {
renderer.setItemMargin(0.1);
} else {
renderer.setItemMargin(0.2);
}

categoryplot.setRenderer(renderer);

return categoryplot;
}

/**
* 设置图表主题样式
*/
private void setChartTheme() {
// 创建主题样式
StandardChartTheme standardChartTheme = new StandardChartTheme("CN");
// 设置标题字体
standardChartTheme.setExtraLargeFont(new Font("宋书", Font.BOLD, 12));
// 设置图例的字体
standardChartTheme.setRegularFont(new Font("宋书", Font.PLAIN, 12));
// 设置轴向的字体
standardChartTheme.setLargeFont(new Font("宋书", Font.PLAIN, 12));
// 应用主题样式
ChartFactory.setChartTheme(standardChartTheme);
}

/**
* 生成图片
*
* @param picName
* @param jfreechart
*/
private void createPicture(String picName, JFreeChart jfreechart) {
if (picName == null || "".equals(picName.trim()) || jfreechart == null) {
return;
}
FileOutputStream fos_jpg = null;

try {
try {
fos_jpg = new FileOutputStream(picName);
ChartUtilities.writeChartAsJPEG(fos_jpg, 1, jfreechart, 240,
155, null);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
} finally {
if (fos_jpg != null) {
try {
fos_jpg.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

/**
* 创建图表数据集
*
* @param data
* @param rowKeys
* @param columnKeys
* @return
*/
public CategoryDataset createDataset(double[][] data, String[] rowKeys,
String[] columnKeys) {
CategoryDataset dataset = getData(data, rowKeys, columnKeys);
return dataset;
}

/**
* 获取数据集
*
* @param data
* @param rowKeys
* @param columnKeys
* @return
*/
private CategoryDataset getData(double[][] data, String[] rowKeys,
String[] columnKeys) {

return DatasetUtilities
.createCategoryDataset(rowKeys, columnKeys, data);

}

/**
* 重建data
*
* @param columnKeys
* @param data
* @return
*/
private double[][] getDataBuildedArr(String[] columnKeys, double[][] data) {
if (columnKeys == null || data == null) {
return null;
}
if (data.length < 1) {
return null;
}
double[] data_0 = data[0];
double[][] dataBuilded = new double[1][columnKeys.length];

for (int i = 0; i < columnKeys.length; i++) {
// 下标
int ck = Integer.valueOf(columnKeys[i]) - 1;
double dataInner = data_0[ck];
dataBuilded[0][i] = dataInner;
}
return dataBuilded;

}

/**
* 重建ColumnKeys
*
* @param min
* @param max
* @return
*/
private String[] getColumnKeysBuilded(int min, int max) {
List<Integer> list = new ArrayList<Integer>();
while (list.size() < 9) {
int randomData = getRandomData(min, max);
if (!list.contains(randomData)) {
list.add(randomData);
}
}
list.add(max);
Collections.sort(list);
List<String> listStr = new ArrayList<String>();
for (int rd : list) {
listStr.add(String.valueOf(rd));
}
return listStr.toArray(new String[listStr.size()]);
}

/**
* 获取两个整数之间的随机数
*
* @param min
* @param max
* @return
*/
private int getRandomData(int min, int max) {
int num = (int) ((max - min) * Math.random() + min);
return num;
}

/**
* 处理成小数
*
* @param data_sucRate
* @return
*/
private double[][] getDataSucRateDouble(double[][] data_sucRate) {
if (data_sucRate == null) {
return null;
}
if (data_sucRate.length < 1) {
return null;
}
int column = data_sucRate[0].length;
double[] data_0 = data_sucRate[0];
double[][] dataBuilded = new double[1][column];
if (data_0 == null) {
return null;
}
for (int i = 0; i < data_0.length; i++) {
double data = data_0[i] / 100;
data = getDataOfTwoDecimal(data);
dataBuilded[0][i] = data;
}
return dataBuilded;
}

/**
* 保留两位小数
*
* @param data
* @return
*/
private double getDataOfTwoDecimal(double data) {
DecimalFormat df = new DecimalFormat("#.00");
return Double.valueOf(df.format(data));
}
}
public class ChartsMixedTest extends TestCase {

public void ptest_01() {
String picName = "./image/charts/chart2.jpg";
String picPath = (new File(picName)).getAbsolutePath();
picPath = "D://chart2.jpg";
// double[][] data_sucRate = new double[][] { { 0.75, 0.50,0.8,0.75,
// 0.50,0.8} };
// String[] rowKeys_sucRate = { "执行成功率" };
// String[] columnKeys_sucRate = { "1", "2", "3","4","5","6" };
//
// double[][] data_useCase = new double[][] { { 50, 14, 33,77,56,34 } };
// String[] rowKeys_useCase = { "用例总数" };
// String[] columnKeys_useCase = { "1", "2", "3","4","5","6" };

// double[][] data_sucRate = new double[][] { { 0.75} };
// String[] rowKeys_sucRate = { "执行成功率" };
// String[] columnKeys_sucRate = { "1"};
//
// double[][] data_useCase = new double[][] { { 50} };
// String[] rowKeys_useCase = { "用例总数" };
// String[] columnKeys_useCase = { "1"};

double[][] data_sucRate = new double[][] {{53.52, 70.71999999999999, 0.0, 0.0, 78.76000000000001, 87.22, 86.37, 0.0, 0.0, 0.0,
53.52, 70.71999999999999, 0.0, 0.0, 78.76000000000001, 87.22, 86.37, 0.0, 0.0, 0.0,
53.52, 70.71999999999999, 0.0, 0.0, 78.76000000000001, 87.22, 86.37, 0.0, 0.0, 0.0}};
String[] rowKeys_sucRate = { "执行成功率" };
String[] columnKeys_sucRate = {"1","2", "3", "4", "5", "6", "7","8","9","10",
"11","12","13","14","15","16", "17","18", "19", "20",
"21", "22", "23","24","25","26","27","28","29","30"};

double[][] data_useCase = new double[][] {{142.0, 1264.0, 0.0, 0.0, 113.0, 806.0, 653.0, 0.0, 0.0, 0.0,
45,67,34,23,12,78,78,56,70,80,
78,44,55,333,22,77,88,76,50,450}};
String[] rowKeys_useCase = { "用例总数" };
String[] columnKeys_useCase = {"1","2", "3", "4", "5", "6","7","8", "9","10",
"11","12","13","14","15","16", "17","18", "19", "20",
"21", "22", "23","24","25","26","27","28","29","30"};




ChartsMixed chartsMixed = new ChartsMixed();
chartsMixed.createMixedCharts(data_sucRate, rowKeys_sucRate,
columnKeys_sucRate, data_useCase, rowKeys_useCase,
columnKeys_useCase, picPath);
}
}